# 1 "/home/avi/scylla-maint/seastar/src/rpc/rpc.cc"
# 1 "<built-in>" 1
# 1 "<built-in>" 3
# 478 "<built-in>" 3
# 1 "<command line>" 1
# 1 "<built-in>" 2
# 1 "/home/avi/scylla-maint/seastar/src/rpc/rpc.cc" 2
# 1 "/home/avi/scylla-maint/seastar/include/seastar/rpc/rpc.hh" 1
# 24 "/home/avi/scylla-maint/seastar/include/seastar/rpc/rpc.hh"
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/unordered_map" 1 3
# 33 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/unordered_map" 3

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/requires_hosted.h" 1 3
# 31 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/requires_hosted.h" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/c++config.h" 1 3


# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 4 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/c++config.h" 2 3
# 1875 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/c++config.h" 3
# 2149 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/c++config.h" 3
namespace std
{
  typedef long unsigned int size_t;
  typedef long int ptrdiff_t;


  typedef decltype(nullptr) nullptr_t;


#pragma GCC visibility push(default)


  extern "C++" __attribute__ ((__noreturn__, __always_inline__))
  inline void __terminate() noexcept
  {
    void terminate() noexcept __attribute__ ((__noreturn__,__cold__));
    terminate();
  }
#pragma GCC visibility pop
}
# 2182 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/c++config.h" 3
namespace std
{
  inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { }
}
namespace __gnu_cxx
{
  inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { }
}
# 2375 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/c++config.h" 3
namespace std
{
#pragma GCC visibility push(default)




  __attribute__((__always_inline__))
  constexpr inline bool
  __is_constant_evaluated() noexcept
  {


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






  }
#pragma GCC visibility pop
}
# 2414 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/c++config.h" 3
namespace std
{
#pragma GCC visibility push(default)

  extern "C++" __attribute__ ((__noreturn__))
  void
  __glibcxx_assert_fail
    (const char* __file, int __line, const char* __function,
     const char* __condition)
  noexcept;
#pragma GCC visibility pop
}
# 2442 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/c++config.h" 3
namespace std
{
  __attribute__((__always_inline__,__visibility__("default")))
  inline void
  __glibcxx_assert_fail()
  { }
}
# 2521 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/c++config.h" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/os_defines.h" 1 3
# 39 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/os_defines.h" 3
# 1 "/usr/include/features.h" 1 3 4
# 394 "/usr/include/features.h" 3 4
# 1 "/usr/include/features-time64.h" 1 3 4
# 20 "/usr/include/features-time64.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 21 "/usr/include/features-time64.h" 2 3 4
# 1 "/usr/include/bits/timesize.h" 1 3 4
# 19 "/usr/include/bits/timesize.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 20 "/usr/include/bits/timesize.h" 2 3 4
# 22 "/usr/include/features-time64.h" 2 3 4
# 395 "/usr/include/features.h" 2 3 4
# 481 "/usr/include/features.h" 3 4
# 1 "/usr/include/stdc-predef.h" 1 3 4
# 482 "/usr/include/features.h" 2 3 4
# 503 "/usr/include/features.h" 3 4
# 1 "/usr/include/sys/cdefs.h" 1 3 4
# 576 "/usr/include/sys/cdefs.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 577 "/usr/include/sys/cdefs.h" 2 3 4
# 1 "/usr/include/bits/long-double.h" 1 3 4
# 578 "/usr/include/sys/cdefs.h" 2 3 4
# 504 "/usr/include/features.h" 2 3 4
# 527 "/usr/include/features.h" 3 4
# 1 "/usr/include/gnu/stubs.h" 1 3 4
# 10 "/usr/include/gnu/stubs.h" 3 4
# 1 "/usr/include/gnu/stubs-64.h" 1 3 4
# 11 "/usr/include/gnu/stubs.h" 2 3 4
# 528 "/usr/include/features.h" 2 3 4
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/os_defines.h" 2 3
# 2522 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/c++config.h" 2 3


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/cpu_defines.h" 1 3
# 2525 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/c++config.h" 2 3
# 2728 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/c++config.h" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/pstl/pstl_config.h" 1 3
# 2729 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/c++config.h" 2 3
# 32 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/requires_hosted.h" 2 3
# 35 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/unordered_map" 2 3





# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/initializer_list" 1 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/initializer_list" 3







namespace std __attribute__ ((__visibility__ ("default")))
{

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

    private:
      iterator _M_array;
      size_type _M_len;


      constexpr initializer_list(const_iterator __a, size_type __l)
      : _M_array(__a), _M_len(__l) { }

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


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


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


      constexpr const_iterator
      end() const noexcept { return begin() + size(); }
    };







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







  template<class _Tp>
    constexpr const _Tp*
    end(initializer_list<_Tp> __ils) noexcept
    { return __ils.end(); }
}
# 41 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/unordered_map" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_map.h" 1 3
# 33 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_map.h" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/hashtable.h" 1 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/hashtable.h" 3

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/hashtable_policy.h" 1 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/hashtable_policy.h" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tuple" 1 3
# 33 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tuple" 3





# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_pair.h" 1 3
# 60 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_pair.h" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/type_traits" 1 3
# 33 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/type_traits" 3
# 63 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/type_traits" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 64 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/type_traits" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{


  template<typename _Tp>
    class reference_wrapper;
# 86 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/type_traits" 3
  template<typename _Tp, _Tp __v>
    struct integral_constant
    {
      static constexpr _Tp value = __v;
      using value_type = _Tp;
      using type = integral_constant<_Tp, __v>;
      constexpr operator value_type() const noexcept { return value; }


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

    };
# 106 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/type_traits" 3
  template<bool __v>
    using __bool_constant = integral_constant<bool, __v>;



  using true_type = __bool_constant<true>;


  using false_type = __bool_constant<false>;




  template<bool __v>
    using bool_constant = __bool_constant<__v>;






  template<bool, typename _Tp = void>
    struct enable_if
    { };


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


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

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

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


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


  template <typename _Type>
    struct __type_identity
    { using type = _Type; };

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

  namespace __detail
  {

    template<typename _Tp, typename...>
      using __first_t = _Tp;


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

    template<typename... _Bn>
      auto __or_fn(...) -> true_type;

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

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




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

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

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





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

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

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

    template<typename , typename _B1, typename... _Bn>
      struct __conjunction_impl
      { using type = _B1; };

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


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

  template<>
    struct conjunction<>
    : true_type
    { };

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

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

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




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

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

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





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


  template<typename>
    struct __is_array_unknown_bounds;




  template <typename _Tp, size_t = sizeof(_Tp)>
    constexpr true_type __is_complete_or_unbounded(__type_identity<_Tp>)
    { return {}; }

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


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





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

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

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

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

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


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

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

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

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

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




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


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


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

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

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

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

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

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

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

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

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

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




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

  __extension__
  template<>
    struct __is_integral_helper<unsigned __int128>
    : public true_type { };
# 460 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/type_traits" 3
  template<typename _Tp>
    struct is_integral
    : public __is_integral_helper<__remove_cv_t<_Tp>>::type
    { };


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

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

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

  template<>
    struct __is_floating_point_helper<long double>
    : public true_type { };
# 513 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/type_traits" 3
  template<>
    struct __is_floating_point_helper<__float128>
    : public true_type { };




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



  template<typename _Tp>
    struct is_array
    : public __bool_constant<__is_array(_Tp)>
    { };
# 545 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/type_traits" 3
  template<typename>
    struct __is_pointer_helper
    : public false_type { };

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


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


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

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


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

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



  template<typename _Tp>
    struct is_member_object_pointer
    : public __bool_constant<__is_member_object_pointer(_Tp)>
    { };
# 601 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/type_traits" 3
  template<typename _Tp>
    struct is_member_function_pointer
    : public __bool_constant<__is_member_function_pointer(_Tp)>
    { };
# 622 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/type_traits" 3
  template<typename _Tp>
    struct is_enum
    : public __bool_constant<__is_enum(_Tp)>
    { };


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


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



  template<typename _Tp>
    struct is_function
    : public __bool_constant<__is_function(_Tp)>
    { };
# 661 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/type_traits" 3
  template<typename _Tp>
    struct is_null_pointer
    : public false_type { };

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

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

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

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



  template<typename _Tp>
    struct __is_nullptr_t
    : public is_null_pointer<_Tp>
    { } __attribute__ ((__deprecated__ ("use '" "std::is_null_pointer" "' instead")));






  template<typename _Tp>
    struct is_reference
    : public __bool_constant<__is_reference(_Tp)>
    { };
# 715 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/type_traits" 3
  template<typename _Tp>
    struct is_arithmetic
    : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
    { };


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



  template<typename _Tp>
    struct is_object
    : public __bool_constant<__is_object(_Tp)>
    { };
# 741 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/type_traits" 3
  template<typename>
    struct is_member_pointer;


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


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



  template<typename _Tp>
    struct is_member_pointer
    : public __bool_constant<__is_member_pointer(_Tp)>
    { };
# 779 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/type_traits" 3
  template<typename, typename>
    struct is_same;


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


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

   , signed __int128
# 804 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/type_traits" 3
   >;


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

   , unsigned __int128
# 824 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/type_traits" 3
   >;


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


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





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

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


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

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


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


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


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






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





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


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


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




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



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


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

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



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


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


  template<typename _Tp, typename _Up = _Tp&&>
    _Up
    __declval(int);

  template<typename _Tp>
    _Tp
    __declval(long);


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

  template<typename>
    struct remove_all_extents;


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

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

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

  template<typename _Tp>
    struct __is_array_unknown_bounds<_Tp[]>
    : public true_type
    { };
# 1006 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/type_traits" 3
  struct __do_is_destructible_impl
  {
    template<typename _Tp, typename = decltype(declval<_Tp&>().~_Tp())>
      static true_type __test(int);

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

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

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

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

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

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



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







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

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

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

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

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

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

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



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


  template<typename _Tp, typename... _Args>
    using __is_constructible_impl
      = __bool_constant<__is_constructible(_Tp, _Args...)>;



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


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


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

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

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



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


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

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

  template<typename _Tp>
    using __add_rval_ref_t = typename __add_rvalue_reference_helper<_Tp>::type;



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


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



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


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


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


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


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



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


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


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


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



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


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


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


  template<typename _Tp, typename... _Args>
    using __is_trivially_constructible_impl
      = __bool_constant<__is_trivially_constructible(_Tp, _Args...)>;



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


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


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

  template<typename _Tp>
    struct __is_implicitly_default_constructible
    : __bool_constant<__is_implicitly_default_constructible_v<_Tp>>
    { };
# 1351 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/type_traits" 3
  template<typename _Tp>
    struct is_trivially_copy_constructible
    : public __is_trivially_constructible_impl<_Tp, __add_lval_ref_t<const _Tp>>
    {
      static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
 "template argument must be a complete class or an unbounded array");
    };


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


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



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


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


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


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



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





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


  template<typename>
    struct rank
    : public integral_constant<std::size_t, 0> { };

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

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


  template<typename, unsigned _Uint = 0>
    struct extent
    : public integral_constant<size_t, 0> { };

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

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

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

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






  template<typename _Tp, typename _Up>
    struct is_same
    : public __bool_constant<__is_same(_Tp, _Up)>
    { };
# 1491 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/type_traits" 3
  template<typename _Base, typename _Derived>
    struct is_base_of
    : public __bool_constant<__is_base_of(_Base, _Derived)>
    { };


  template<typename _From, typename _To>
    struct is_convertible
    : public __bool_constant<__is_convertible(_From, _To)>
    { };
# 1540 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/type_traits" 3
  template<typename _ToElementType, typename _FromElementType>
    using __is_array_convertible
      = is_convertible<_FromElementType(*)[], _ToElementType(*)[]>;
# 1558 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/type_traits" 3
  template<typename _From, typename _To,
           bool = __or_<is_void<_From>, is_function<_To>,
                        is_array<_To>>::value>
    struct __is_nt_convertible_helper
    : is_void<_To>
    { };

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
  template<typename _From, typename _To>
    class __is_nt_convertible_helper<_From, _To, false>
    {
      template<typename _To1>
 static void __test_aux(_To1) noexcept;

      template<typename _From1, typename _To1>
 static
 __bool_constant<noexcept(__test_aux<_To1>(std::declval<_From1>()))>
 __test(int);

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

    public:
      using type = decltype(__test<_From, _To>(0));
    };
#pragma GCC diagnostic pop


  template<typename _From, typename _To>
    struct is_nothrow_convertible
    : public __is_nt_convertible_helper<_From, _To>::type
    { };


  template<typename _From, typename _To>
    inline constexpr bool is_nothrow_convertible_v
      = is_nothrow_convertible<_From, _To>::value;






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

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


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

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



  template<typename _Tp>
    struct remove_cv
    { using type = __remove_cv(_Tp); };
# 1644 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/type_traits" 3
  template<typename _Tp>
    struct add_const
    { using type = _Tp const; };


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


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



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


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


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


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


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


  template<typename _Tp>
    using add_cv_t = typename add_cv<_Tp>::type;
# 1692 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/type_traits" 3
  template<typename _Tp>
    struct remove_reference
    { using type = _Tp; };

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

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



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


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



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


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


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







  template<typename _Unqualified, bool _IsConst, bool _IsVol>
    struct __cv_selector;

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

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

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

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

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

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


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

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

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

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

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

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

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


  __extension__
  template<>
    struct __make_unsigned<__int128>
    { using __type = unsigned __int128; };
# 1819 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/type_traits" 3
  template<typename _Tp,
    bool _IsInt = is_integral<_Tp>::value,
    bool _IsEnum = __is_enum(_Tp)>
    class __make_unsigned_selector;

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

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

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

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

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

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

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


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

      using _UInts = _List<unsigned char, unsigned short, unsigned int,
      unsigned long, unsigned long long>;

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

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





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


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


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

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






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


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




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

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

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

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

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

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

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


  __extension__
  template<>
    struct __make_signed<unsigned __int128>
    { using __type = __int128; };
# 1979 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/type_traits" 3
  template<typename _Tp,
    bool _IsInt = is_integral<_Tp>::value,
    bool _IsEnum = __is_enum(_Tp)>
    class __make_signed_selector;

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

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


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

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





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


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


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

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






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


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



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


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





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

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

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


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

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

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



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


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






  template<typename _Tp>
    struct remove_pointer
    { using type = __remove_pointer(_Tp); };
# 2124 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/type_traits" 3
  template<typename _Tp, typename = void>
    struct __add_pointer_helper
    { using type = _Tp; };

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


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

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

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



  template<typename _Tp>
    using remove_pointer_t = typename remove_pointer<_Tp>::type;


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


  template<std::size_t _Len>
    struct __aligned_storage_msa
    {
      union __type
      {
 unsigned char __data[_Len];
 struct __attribute__((__aligned__)) { } __align;
      };
    };
# 2179 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/type_traits" 3
  template<std::size_t _Len, std::size_t _Align =
    __alignof__(typename __aligned_storage_msa<_Len>::__type)>
    struct
    [[__deprecated__]]
    aligned_storage
    {
      union type
      {
 unsigned char __data[_Len];
 struct __attribute__((__aligned__((_Align)))) { } __align;
      };
    };

  template <typename... _Types>
    struct __strictest_alignment
    {
      static const size_t _S_alignment = 0;
      static const size_t _S_size = 0;
    };

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

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
# 2225 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/type_traits" 3
  template <size_t _Len, typename... _Types>
    struct
    [[__deprecated__]]
    aligned_union
    {
    private:
      static_assert(sizeof...(_Types) != 0, "At least one type is required");

      using __strictest = __strictest_alignment<_Types...>;
      static const size_t _S_len = _Len > __strictest::_S_size
 ? _Len : __strictest::_S_size;
    public:

      static const size_t alignment_value = __strictest::_S_alignment;

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

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





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

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

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




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

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

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




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

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


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

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





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


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




  template<bool _Cond, typename _Iftrue, typename _Iffalse>
    struct conditional
    { using type = _Iftrue; };


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


  template<typename... _Tp>
    struct common_type;
# 2340 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/type_traits" 3
  template<typename _Tp>
    struct __success_type
    { using type = _Tp; };

  struct __failure_type
  { };

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



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




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


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

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


  template<>
    struct common_type<>
    { };


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


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


      using type = common_type<_Dp1, _Dp2>;
    };

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


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


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

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

  template<typename, typename, typename = void>
    struct __common_type_fold;


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




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


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

  template<typename _Tp, bool = __is_enum(_Tp)>
    struct __underlying_type_impl
    {
      using type = __underlying_type(_Tp);
    };

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



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


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






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


  template<typename _Signature>
    struct result_of;




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


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


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

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

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


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

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

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


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

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

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


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

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

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

  template<typename _MemPtr, typename _Arg>
    struct __result_of_memobj;

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

  template<typename _MemPtr, typename _Arg, typename... _Args>
    struct __result_of_memfun;

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






  template<typename _Tp, typename _Up = __remove_cvref_t<_Tp>>
    struct __inv_unwrap
    {
      using type = _Tp;
    };

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

  template<bool, bool, typename _Functor, typename... _ArgTypes>
    struct __result_of_impl
    {
      using type = __failure_type;
    };

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

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


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

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

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


  template<typename _Functor, typename... _ArgTypes>
    struct __invoke_result
    : public __result_of_impl<
        is_member_object_pointer<
          typename remove_reference<_Functor>::type
        >::value,
        is_member_function_pointer<
          typename remove_reference<_Functor>::type
        >::value,
 _Functor, _ArgTypes...
      >::type
    { };


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


  template<typename _Functor, typename... _ArgTypes>
    struct result_of<_Functor(_ArgTypes...)>
    : public __invoke_result<_Functor, _ArgTypes...>
    { } __attribute__ ((__deprecated__ ("use '" "std::invoke_result" "' instead")));


#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"

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

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


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


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


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


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


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


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




  template<typename...> using void_t = void;
# 2727 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/type_traits" 3
  template<typename _Def, template<typename...> class _Op, typename... _Args>
    struct __detected_or
    {
      using type = _Def;
      using __is_detected = false_type;
    };


  template<typename _Def, template<typename...> class _Op, typename... _Args>
    requires requires { typename _Op<_Args...>; }
    struct __detected_or<_Def, _Op, _Args...>
    {
      using type = _Op<_Args...>;
      using __is_detected = true_type;
    };
# 2767 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/type_traits" 3
  template<typename _Default, template<typename...> class _Op,
    typename... _Args>
    using __detected_or_t
      = typename __detected_or<_Default, _Op, _Args...>::type;
# 2786 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/type_traits" 3
  template <typename _Tp>
    struct __is_swappable;

  template <typename _Tp>
    struct __is_nothrow_swappable;

  template<typename>
    struct __is_tuple_like_impl : false_type
    { };


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


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

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


  namespace __swappable_details {
    using std::swap;

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

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

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

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

  }

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

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

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

  template<typename _Tp>
    struct __is_nothrow_swappable
    : public __is_nothrow_swappable_impl<_Tp>::type
    { };






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


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



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


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



  namespace __swappable_with_details {
    using std::swap;

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

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

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

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

  }

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


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

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


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



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


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



  template<typename _Tp, typename _Up>
    inline constexpr bool is_swappable_with_v =
      is_swappable_with<_Tp, _Up>::value;


  template<typename _Tp, typename _Up>
    inline constexpr bool is_nothrow_swappable_with_v =
      is_nothrow_swappable_with<_Tp, _Up>::value;
# 3008 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/type_traits" 3
  template<typename _Result, typename _Ret,
    bool = is_void<_Ret>::value, typename = void>
    struct __is_invocable_impl
    : false_type
    {
      using __nothrow_conv = false_type;
    };


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

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

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

      using _Res_t = typename _Result::type;



      static _Res_t _S_get() noexcept;


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


      template<typename _Tp,
        bool _Nothrow = noexcept(_S_conv<_Tp>(_S_get())),
        typename = decltype(_S_conv<_Tp>(_S_get())),



        bool _Dangle = false

       >
 static __bool_constant<_Nothrow && !_Dangle>
 _S_test(int);

      template<typename _Tp, bool = false>
 static false_type
 _S_test(...);

    public:

      using type = decltype(_S_test<_Ret, true>(1));


      using __nothrow_conv = decltype(_S_test<_Ret>(1));
    };
#pragma GCC diagnostic pop

  template<typename _Fn, typename... _ArgTypes>
    struct __is_invocable
    : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type
    { };

  template<typename _Fn, typename _Tp, typename... _Args>
    constexpr bool __call_is_nt(__invoke_memfun_ref)
    {
      using _Up = typename __inv_unwrap<_Tp>::type;
      return noexcept((std::declval<_Up>().*std::declval<_Fn>())(
     std::declval<_Args>()...));
    }

  template<typename _Fn, typename _Tp, typename... _Args>
    constexpr bool __call_is_nt(__invoke_memfun_deref)
    {
      return noexcept(((*std::declval<_Tp>()).*std::declval<_Fn>())(
     std::declval<_Args>()...));
    }

  template<typename _Fn, typename _Tp>
    constexpr bool __call_is_nt(__invoke_memobj_ref)
    {
      using _Up = typename __inv_unwrap<_Tp>::type;
      return noexcept(std::declval<_Up>().*std::declval<_Fn>());
    }

  template<typename _Fn, typename _Tp>
    constexpr bool __call_is_nt(__invoke_memobj_deref)
    {
      return noexcept((*std::declval<_Tp>()).*std::declval<_Fn>());
    }

  template<typename _Fn, typename... _Args>
    constexpr bool __call_is_nt(__invoke_other)
    {
      return noexcept(std::declval<_Fn>()(std::declval<_Args>()...));
    }

  template<typename _Result, typename _Fn, typename... _Args>
    struct __call_is_nothrow
    : __bool_constant<
 std::__call_is_nt<_Fn, _Args...>(typename _Result::__invoke_type{})
      >
    { };

  template<typename _Fn, typename... _Args>
    using __call_is_nothrow_
      = __call_is_nothrow<__invoke_result<_Fn, _Args...>, _Fn, _Args...>;


  template<typename _Fn, typename... _Args>
    struct __is_nothrow_invocable
    : __and_<__is_invocable<_Fn, _Args...>,
             __call_is_nothrow_<_Fn, _Args...>>::type
    { };

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
  struct __nonesuchbase {};
  struct __nonesuch : private __nonesuchbase {
    ~__nonesuch() = delete;
    __nonesuch(__nonesuch const&) = delete;
    void operator=(__nonesuch const&) = delete;
  };
#pragma GCC diagnostic pop




  template<typename _Functor, typename... _ArgTypes>
    struct invoke_result
    : public __invoke_result<_Functor, _ArgTypes...>
    {
      static_assert(std::__is_complete_or_unbounded(__type_identity<_Functor>{}),
 "_Functor must be a complete class or an unbounded array");
      static_assert((std::__is_complete_or_unbounded(
 __type_identity<_ArgTypes>{}) && ...),
 "each argument type must be a complete class or an unbounded array");
    };


  template<typename _Fn, typename... _Args>
    using invoke_result_t = typename invoke_result<_Fn, _Args...>::type;


  template<typename _Fn, typename... _ArgTypes>
    struct is_invocable
    : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type
    {
      static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}),
 "_Fn must be a complete class or an unbounded array");
      static_assert((std::__is_complete_or_unbounded(
 __type_identity<_ArgTypes>{}) && ...),
 "each argument type must be a complete class or an unbounded array");
    };


  template<typename _Ret, typename _Fn, typename... _ArgTypes>
    struct is_invocable_r
    : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>::type
    {
      static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}),
 "_Fn must be a complete class or an unbounded array");
      static_assert((std::__is_complete_or_unbounded(
 __type_identity<_ArgTypes>{}) && ...),
 "each argument type must be a complete class or an unbounded array");
      static_assert(std::__is_complete_or_unbounded(__type_identity<_Ret>{}),
 "_Ret must be a complete class or an unbounded array");
    };


  template<typename _Fn, typename... _ArgTypes>
    struct is_nothrow_invocable
    : __and_<__is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>,
      __call_is_nothrow_<_Fn, _ArgTypes...>>::type
    {
      static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}),
 "_Fn must be a complete class or an unbounded array");
      static_assert((std::__is_complete_or_unbounded(
 __type_identity<_ArgTypes>{}) && ...),
 "each argument type must be a complete class or an unbounded array");
    };





  template<typename _Result, typename _Ret>
    using __is_nt_invocable_impl
      = typename __is_invocable_impl<_Result, _Ret>::__nothrow_conv;



  template<typename _Ret, typename _Fn, typename... _ArgTypes>
    struct is_nothrow_invocable_r
    : __and_<__is_nt_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>,
             __call_is_nothrow_<_Fn, _ArgTypes...>>::type
    {
      static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}),
 "_Fn must be a complete class or an unbounded array");
      static_assert((std::__is_complete_or_unbounded(
 __type_identity<_ArgTypes>{}) && ...),
 "each argument type must be a complete class or an unbounded array");
      static_assert(std::__is_complete_or_unbounded(__type_identity<_Ret>{}),
 "_Ret must be a complete class or an unbounded array");
    };
# 3236 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/type_traits" 3
template <typename _Tp>
  inline constexpr bool is_void_v = is_void<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_null_pointer_v = is_null_pointer<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_integral_v = is_integral<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_floating_point_v = is_floating_point<_Tp>::value;


template <typename _Tp>
  inline constexpr bool is_array_v = __is_array(_Tp);
# 3257 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/type_traits" 3
template <typename _Tp>
  inline constexpr bool is_pointer_v = is_pointer<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_lvalue_reference_v = false;
template <typename _Tp>
  inline constexpr bool is_lvalue_reference_v<_Tp&> = true;
template <typename _Tp>
  inline constexpr bool is_rvalue_reference_v = false;
template <typename _Tp>
  inline constexpr bool is_rvalue_reference_v<_Tp&&> = true;


template <typename _Tp>
  inline constexpr bool is_member_object_pointer_v =
    __is_member_object_pointer(_Tp);







template <typename _Tp>
  inline constexpr bool is_member_function_pointer_v =
    __is_member_function_pointer(_Tp);






template <typename _Tp>
  inline constexpr bool is_enum_v = __is_enum(_Tp);
template <typename _Tp>
  inline constexpr bool is_union_v = __is_union(_Tp);
template <typename _Tp>
  inline constexpr bool is_class_v = __is_class(_Tp);



template <typename _Tp>
  inline constexpr bool is_reference_v = __is_reference(_Tp);
# 3308 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/type_traits" 3
template <typename _Tp>
  inline constexpr bool is_arithmetic_v = is_arithmetic<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_fundamental_v = is_fundamental<_Tp>::value;


template <typename _Tp>
  inline constexpr bool is_object_v = __is_object(_Tp);





template <typename _Tp>
  inline constexpr bool is_scalar_v = is_scalar<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_compound_v = !is_fundamental_v<_Tp>;


template <typename _Tp>
  inline constexpr bool is_member_pointer_v = __is_member_pointer(_Tp);





template <typename _Tp>
  inline constexpr bool is_const_v = false;
template <typename _Tp>
  inline constexpr bool is_const_v<const _Tp> = true;


template <typename _Tp>
  inline constexpr bool is_function_v = __is_function(_Tp);
# 3351 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/type_traits" 3
template <typename _Tp>
  inline constexpr bool is_volatile_v = false;
template <typename _Tp>
  inline constexpr bool is_volatile_v<volatile _Tp> = true;

template <typename _Tp>
  inline constexpr bool is_trivial_v = __is_trivial(_Tp);
template <typename _Tp>
  inline constexpr bool is_trivially_copyable_v = __is_trivially_copyable(_Tp);
template <typename _Tp>
  inline constexpr bool is_standard_layout_v = __is_standard_layout(_Tp);
template <typename _Tp>
  __attribute__ ((__deprecated__ ("use '" "is_standard_layout_v && is_trivial_v" "' instead")))
  inline constexpr bool is_pod_v = __is_pod(_Tp);
template <typename _Tp>
  [[__deprecated__]]
  inline constexpr bool is_literal_type_v = __is_literal_type(_Tp);
template <typename _Tp>
  inline constexpr bool is_empty_v = __is_empty(_Tp);
template <typename _Tp>
  inline constexpr bool is_polymorphic_v = __is_polymorphic(_Tp);
template <typename _Tp>
  inline constexpr bool is_abstract_v = __is_abstract(_Tp);
template <typename _Tp>
  inline constexpr bool is_final_v = __is_final(_Tp);

template <typename _Tp>
  inline constexpr bool is_signed_v = is_signed<_Tp>::value;
template <typename _Tp>
  inline constexpr bool is_unsigned_v = is_unsigned<_Tp>::value;

template <typename _Tp, typename... _Args>
  inline constexpr bool is_constructible_v = __is_constructible(_Tp, _Args...);
template <typename _Tp>
  inline constexpr bool is_default_constructible_v = __is_constructible(_Tp);
template <typename _Tp>
  inline constexpr bool is_copy_constructible_v
    = __is_constructible(_Tp, __add_lval_ref_t<const _Tp>);
template <typename _Tp>
  inline constexpr bool is_move_constructible_v
    = __is_constructible(_Tp, __add_rval_ref_t<_Tp>);

template <typename _Tp, typename _Up>
  inline constexpr bool is_assignable_v = __is_assignable(_Tp, _Up);
template <typename _Tp>
  inline constexpr bool is_copy_assignable_v
    = __is_assignable(__add_lval_ref_t<_Tp>, __add_lval_ref_t<const _Tp>);
template <typename _Tp>
  inline constexpr bool is_move_assignable_v
    = __is_assignable(__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>);

template <typename _Tp>
  inline constexpr bool is_destructible_v = is_destructible<_Tp>::value;

template <typename _Tp, typename... _Args>
  inline constexpr bool is_trivially_constructible_v
    = __is_trivially_constructible(_Tp, _Args...);
template <typename _Tp>
  inline constexpr bool is_trivially_default_constructible_v
    = __is_trivially_constructible(_Tp);
template <typename _Tp>
  inline constexpr bool is_trivially_copy_constructible_v
    = __is_trivially_constructible(_Tp, __add_lval_ref_t<const _Tp>);
template <typename _Tp>
  inline constexpr bool is_trivially_move_constructible_v
    = __is_trivially_constructible(_Tp, __add_rval_ref_t<_Tp>);

template <typename _Tp, typename _Up>
  inline constexpr bool is_trivially_assignable_v
    = __is_trivially_assignable(_Tp, _Up);
template <typename _Tp>
  inline constexpr bool is_trivially_copy_assignable_v
    = __is_trivially_assignable(__add_lval_ref_t<_Tp>,
    __add_lval_ref_t<const _Tp>);
template <typename _Tp>
  inline constexpr bool is_trivially_move_assignable_v
    = __is_trivially_assignable(__add_lval_ref_t<_Tp>,
    __add_rval_ref_t<_Tp>);


template <typename _Tp>
  inline constexpr bool is_trivially_destructible_v = false;

template <typename _Tp>
  requires (!is_reference_v<_Tp>) && requires (_Tp& __t) { __t.~_Tp(); }
  inline constexpr bool is_trivially_destructible_v<_Tp>
    = __has_trivial_destructor(_Tp);
template <typename _Tp>
  inline constexpr bool is_trivially_destructible_v<_Tp&> = true;
template <typename _Tp>
  inline constexpr bool is_trivially_destructible_v<_Tp&&> = true;
template <typename _Tp, size_t _Nm>
  inline constexpr bool is_trivially_destructible_v<_Tp[_Nm]>
    = is_trivially_destructible_v<_Tp>;






template <typename _Tp, typename... _Args>
  inline constexpr bool is_nothrow_constructible_v
    = __is_nothrow_constructible(_Tp, _Args...);
template <typename _Tp>
  inline constexpr bool is_nothrow_default_constructible_v
    = __is_nothrow_constructible(_Tp);
template <typename _Tp>
  inline constexpr bool is_nothrow_copy_constructible_v
    = __is_nothrow_constructible(_Tp, __add_lval_ref_t<const _Tp>);
template <typename _Tp>
  inline constexpr bool is_nothrow_move_constructible_v
    = __is_nothrow_constructible(_Tp, __add_rval_ref_t<_Tp>);

template <typename _Tp, typename _Up>
  inline constexpr bool is_nothrow_assignable_v
    = __is_nothrow_assignable(_Tp, _Up);
template <typename _Tp>
  inline constexpr bool is_nothrow_copy_assignable_v
    = __is_nothrow_assignable(__add_lval_ref_t<_Tp>,
         __add_lval_ref_t<const _Tp>);
template <typename _Tp>
  inline constexpr bool is_nothrow_move_assignable_v
    = __is_nothrow_assignable(__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>);

template <typename _Tp>
  inline constexpr bool is_nothrow_destructible_v =
    is_nothrow_destructible<_Tp>::value;

template <typename _Tp>
  inline constexpr bool has_virtual_destructor_v
    = __has_virtual_destructor(_Tp);

template <typename _Tp>
  inline constexpr size_t alignment_of_v = alignment_of<_Tp>::value;

template <typename _Tp>
  inline constexpr size_t rank_v = 0;
template <typename _Tp, size_t _Size>
  inline constexpr size_t rank_v<_Tp[_Size]> = 1 + rank_v<_Tp>;
template <typename _Tp>
  inline constexpr size_t rank_v<_Tp[]> = 1 + rank_v<_Tp>;

template <typename _Tp, unsigned _Idx = 0>
  inline constexpr size_t extent_v = 0;
template <typename _Tp, size_t _Size>
  inline constexpr size_t extent_v<_Tp[_Size], 0> = _Size;
template <typename _Tp, unsigned _Idx, size_t _Size>
  inline constexpr size_t extent_v<_Tp[_Size], _Idx> = extent_v<_Tp, _Idx - 1>;
template <typename _Tp>
  inline constexpr size_t extent_v<_Tp[], 0> = 0;
template <typename _Tp, unsigned _Idx>
  inline constexpr size_t extent_v<_Tp[], _Idx> = extent_v<_Tp, _Idx - 1>;


template <typename _Tp, typename _Up>
  inline constexpr bool is_same_v = __is_same(_Tp, _Up);






template <typename _Base, typename _Derived>
  inline constexpr bool is_base_of_v = __is_base_of(_Base, _Derived);

template <typename _From, typename _To>
  inline constexpr bool is_convertible_v = __is_convertible(_From, _To);




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






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



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






  template<typename _Tp>
    struct is_aggregate
    : bool_constant<__is_aggregate(remove_cv_t<_Tp>)>
    { };






  template<typename _Tp>
    inline constexpr bool is_aggregate_v = __is_aggregate(remove_cv_t<_Tp>);
# 3581 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/type_traits" 3
  template<typename _Tp>
    struct remove_cvref
    { using type = __remove_cvref(_Tp); };
# 3598 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/type_traits" 3
  template<typename _Tp>
    using remove_cvref_t = typename remove_cvref<_Tp>::type;
# 3608 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/type_traits" 3
  template<typename _Tp>
    struct type_identity { using type = _Tp; };

  template<typename _Tp>
    using type_identity_t = typename type_identity<_Tp>::type;
# 3621 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/type_traits" 3
  template<typename _Tp>
    struct unwrap_reference { using type = _Tp; };

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

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






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

  template<typename _Tp>
    using unwrap_ref_decay_t = typename unwrap_ref_decay<_Tp>::type;
# 3648 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/type_traits" 3
  template<typename _Tp>
    inline constexpr bool is_bounded_array_v = __is_bounded_array(_Tp);
# 3661 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/type_traits" 3
  template<typename _Tp>
    inline constexpr bool is_unbounded_array_v = false;

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



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



  template<typename _Tp>
    struct is_unbounded_array
    : public bool_constant<is_unbounded_array_v<_Tp>>
    { };
# 3744 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/type_traits" 3
  template<typename _Tp>
    struct is_scoped_enum
    : bool_constant<__is_scoped_enum(_Tp)>
    { };
# 3765 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/type_traits" 3
  template<typename _Tp>
    inline constexpr bool is_scoped_enum_v = __is_scoped_enum(_Tp);
# 3816 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/type_traits" 3
  constexpr inline bool
  is_constant_evaluated() noexcept
  {

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



  }




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

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

  template<typename _Ap, typename _Bp, typename = void>
    struct __common_ref_impl
    { };


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


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


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


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


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


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


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


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


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


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

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

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

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


  template<typename... _Tp>
    struct common_reference;

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


  template<>
    struct common_reference<>
    { };


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


  template<typename _Tp1, typename _Tp2, int _Bullet = 1, typename = void>
    struct __common_reference_impl
    : __common_reference_impl<_Tp1, _Tp2, _Bullet + 1>
    { };


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


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

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

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

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


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


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


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


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


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


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







}
# 61 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_pair.h" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/move.h" 1 3
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/move.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{







  template<typename _Tp>
    inline constexpr _Tp*
    __addressof(_Tp& __r) noexcept
    { return __builtin_addressof(__r); }
# 67 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/move.h" 3
  template<typename _Tp>
    [[__nodiscard__]]
    constexpr _Tp&&
    forward(typename std::remove_reference<_Tp>::type& __t) noexcept
    { return static_cast<_Tp&&>(__t); }







  template<typename _Tp>
    [[__nodiscard__]]
    constexpr _Tp&&
    forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
    {
      static_assert(!std::is_lvalue_reference<_Tp>::value,
   "std::forward must not be used to convert an rvalue to an lvalue");
      return static_cast<_Tp&&>(__t);
    }


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

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

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







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


  template<typename _Tp>
    struct __move_if_noexcept_cond
    : public __and_<__not_<is_nothrow_move_constructible<_Tp>>,
                    is_copy_constructible<_Tp>>::type { };
# 143 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/move.h" 3
  template<typename _Tp>
    [[__nodiscard__]]
    constexpr
    __conditional_t<__move_if_noexcept_cond<_Tp>::value, const _Tp&, _Tp&&>
    move_if_noexcept(_Tp& __x) noexcept
    { return std::move(__x); }
# 159 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/move.h" 3
  template<typename _Tp>
    [[__nodiscard__]]
    inline constexpr _Tp*
    addressof(_Tp& __r) noexcept
    { return std::__addressof(__r); }



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


  template <typename _Tp, typename _Up = _Tp>
    constexpr
    inline _Tp
    __exchange(_Tp& __obj, _Up&& __new_val)
    {
      _Tp __old_val = std::move(__obj);
      __obj = std::forward<_Up>(__new_val);
      return __old_val;
    }
# 203 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/move.h" 3
  template<typename _Tp>
    constexpr
    inline

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



    swap(_Tp& __a, _Tp& __b)
    noexcept(__and_<is_nothrow_move_constructible<_Tp>, is_nothrow_move_assignable<_Tp>>::value)

    {




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




  template<typename _Tp, size_t _Nm>
    constexpr
    inline

    typename enable_if<__is_swappable<_Tp>::value>::type



    swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
    noexcept(__is_nothrow_swappable<_Tp>::value)
    {
      for (size_t __n = 0; __n < _Nm; ++__n)
 swap(__a[__n], __b[__n]);
    }



}
# 62 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_pair.h" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/utility.h" 1 3
# 37 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/utility.h" 3






namespace std __attribute__ ((__visibility__ ("default")))
{



  template<typename _Tp>
    struct tuple_size;





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

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

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

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


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



  template<size_t __i, typename _Tp>
    struct tuple_element;


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

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

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

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





  template<typename _Tp, typename... _Types>
    constexpr size_t
    __find_uniq_type_in_pack()
    {
      constexpr size_t __sz = sizeof...(_Types);
      constexpr bool __found[__sz] = { __is_same(_Tp, _Types) ... };
      size_t __n = __sz;
      for (size_t __i = 0; __i < __sz; ++__i)
 {
   if (__found[__i])
     {
       if (__n < __sz)
  return __sz;
       __n = __i;
     }
 }
      return __n;
    }
# 134 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/utility.h" 3
  template<size_t __i, typename _Tp>
    using tuple_element_t = typename tuple_element<__i, _Tp>::type;




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


  template<size_t _Num>
    struct _Build_index_tuple
    {

      template<typename, size_t... _Indices>
 using _IdxTuple = _Index_tuple<_Indices...>;


      using __type = __make_integer_seq<_IdxTuple, size_t, _Num>;




    };




  template<typename _Tp, _Tp... _Idx>
    struct integer_sequence
    {

      static_assert(is_integral_v<_Tp>);

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


  template<typename _Tp, _Tp _Num>
    using make_integer_sequence

      = __make_integer_seq<integer_sequence, _Tp, _Num>;





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


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


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




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

  inline constexpr in_place_t in_place{};

  template<typename _Tp> struct in_place_type_t
  {
    explicit in_place_type_t() = default;
  };

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

  template<size_t _Idx> struct in_place_index_t
  {
    explicit in_place_index_t() = default;
  };

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

  template<typename>
    inline constexpr bool __is_in_place_type_v = false;

  template<typename _Tp>
    inline constexpr bool __is_in_place_type_v<in_place_type_t<_Tp>> = true;

  template<typename _Tp>
    using __is_in_place_type = bool_constant<__is_in_place_type_v<_Tp>>;

  template<typename>
    inline constexpr bool __is_in_place_index_v = false;

  template<size_t _Nm>
    inline constexpr bool __is_in_place_index_v<in_place_index_t<_Nm>> = true;




  template<size_t _Np, typename... _Types>
    struct _Nth_type
    { using type = __type_pack_element<_Np, _Types...>; };
# 276 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/utility.h" 3
  namespace ranges::__detail
  {
    template<typename _Range>
      inline constexpr bool __is_subrange = false;
  }



}
# 63 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_pair.h" 2 3


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/compare" 1 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/compare" 3


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 37 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/compare" 2 3



# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/concepts" 1 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/concepts" 3


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 37 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/concepts" 2 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/concepts" 3
namespace std __attribute__ ((__visibility__ ("default")))
{




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


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

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


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


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


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


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



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

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

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

  template<typename _Tp>
    concept floating_point = is_floating_point_v<_Tp>;

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

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

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

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

  }


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


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


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


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


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


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



  namespace ranges
  {

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

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

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

      public:
 template<typename _Tp, typename _Up>
   requires __adl_swap<_Tp, _Up>
   || (same_as<_Tp, _Up> && is_lvalue_reference_v<_Tp>
       && move_constructible<remove_reference_t<_Tp>>
       && assignable_from<_Tp, remove_reference_t<_Tp>>)
   constexpr void
   operator()(_Tp&& __t, _Up&& __u) const
   noexcept(_S_noexcept<_Tp, _Up>())
   {
     if constexpr (__adl_swap<_Tp, _Up>)
       swap(static_cast<_Tp&&>(__t), static_cast<_Up&&>(__u));
     else
       {
  auto __tmp = static_cast<remove_reference_t<_Tp>&&>(__t);
  __t = static_cast<remove_reference_t<_Tp>&&>(__u);
  __u = static_cast<remove_reference_t<_Tp>&&>(__tmp);
       }
   }

 template<typename _Tp, typename _Up, size_t _Num>
   requires requires(const _Swap& __swap, _Tp& __e1, _Up& __e2) {
     __swap(__e1, __e2);
   }
   constexpr void
   operator()(_Tp (&__e1)[_Num], _Up (&__e2)[_Num]) const
   noexcept(noexcept(std::declval<const _Swap&>()(*__e1, *__e2)))
   {
     for (size_t __n = 0; __n < _Num; ++__n)
       (*this)(__e1[__n], __e2[__n]);
   }
      };
    }


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

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

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



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

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

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




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

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



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

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

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

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


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

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

  template<typename _Tp>
    concept regular = semiregular<_Tp> && equality_comparable<_Tp>;




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


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


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


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


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


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


}
# 41 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/compare" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{


  namespace __cmp_cat
  {
    using type = signed char;

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

    enum class _Ncmp : type { _Unordered = 2 };

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

  class partial_ordering
  {

    __cmp_cat::type _M_value;

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

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

    friend class weak_ordering;
    friend class strong_ordering;

  public:

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


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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

  class weak_ordering
  {
    __cmp_cat::type _M_value;

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

    friend class strong_ordering;

  public:

    static const weak_ordering less;
    static const weak_ordering equivalent;
    static const weak_ordering greater;

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


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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

  class strong_ordering
  {
    __cmp_cat::type _M_value;

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

  public:

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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



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

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

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

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

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

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

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

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

 if constexpr (__cats & 1)
   return;


 else if constexpr (bool(__cats & __cmp_cat_id<partial_ordering>))
   return partial_ordering::equivalent;


 else if constexpr (bool(__cats & __cmp_cat_id<weak_ordering>))
   return weak_ordering::equivalent;

 else
   return strong_ordering::equivalent;
      }
  }


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



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

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

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

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

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

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



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


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

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

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






    template<typename _Tp, typename _Up>
      struct __cmp3way_res_impl
      { };

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


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


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

  namespace __detail
  {




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





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

    using is_transparent = void;
  };



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


 auto __cat = [](_Tp __fp) -> int {
   const int __sign = __builtin_signbit(__fp) ? -1 : 1;
   if (__builtin_isnormal(__fp))
     return (__fp == 0 ? 1 : 3) * __sign;
   if (__builtin_isnan(__fp))
     return 5 * __sign;
   if (int __inf = __builtin_isinf_sign(__fp))
     return 4 * __inf;
   return 2 * __sign;
 };

 auto __po = __e <=> __f;
 if (is_lt(__po))
   return weak_ordering::less;
 else if (is_gt(__po))
   return weak_ordering::greater;
 else if (__po == partial_ordering::equivalent)
   return weak_ordering::equivalent;
 else
   {

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

    void strong_order() = delete;

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

    void weak_order() = delete;

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

    void partial_order() = delete;

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

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

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

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

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

      friend class _Weak_order;
      friend class _Strong_fallback;


      enum class _Fp_fmt
      {
 _Binary16, _Binary32, _Binary64, _Binary128,
 _X86_80bit,
 _M68k_80bit,
 _Dbldbl,
 _Bfloat16,
      };
# 699 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/compare" 3
      template<typename _Tp>
 static consteval _Fp_fmt
 _S_fp_fmt() noexcept
 {

   using enum _Fp_fmt;
# 719 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/compare" 3
   if constexpr (__is_same(_Tp, long double))
     return (-16381) == -16381 ? _X86_80bit : _M68k_80bit;
# 731 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/compare" 3
   constexpr int __width = sizeof(_Tp) * 8;

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


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


      template<typename _Tp>
 struct _Int
 {

   uint64_t _M_lo;
   _Tp _M_hi;





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

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

   constexpr bool operator==(const _Int&) const = default;
# 781 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/compare" 3
   constexpr _Int&
   operator^=(const _Int& __rhs) noexcept
   {
     _M_hi ^= __rhs._M_hi;
     _M_lo ^= __rhs._M_lo;
     return *this;
   }

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

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

   make_unsigned_t<_Tp> __sign = __t >> (__width - 1);


   return __t ^ (__sign >> 1);
 }


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


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

       using enum _Fp_fmt;

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

    return __builtin_bit_cast(__int128, __val);



  }
       else
  static_assert(sizeof(_Tp) == sizeof(int64_t),
         "unsupported floating-point type");
     }
 }

      template<typename _Tp>
 static constexpr strong_ordering
 _S_fp_cmp(_Tp __x, _Tp __y) noexcept
 {
# 885 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/compare" 3
   auto __ix = _S_fp_bits(__x);
   auto __iy = _S_fp_bits(__y);

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


   using enum _Fp_fmt;

   constexpr auto __fmt = _S_fp_fmt<_Tp>();

   if constexpr (__fmt == _Dbldbl)
     {


       struct _Unpacked { double _M_hi; int64_t _M_lo; };
       auto __x2 = __builtin_bit_cast(_Unpacked, __x);
       auto __y2 = __builtin_bit_cast(_Unpacked, __y);


       auto __cmp = _S_fp_cmp(__x2._M_hi, __y2._M_hi);
       if (__cmp != strong_ordering::equal)
  return __cmp;



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


       if (((__x2._M_lo | __y2._M_lo) & 0x7fffffffffffffffULL) == 0)
  return strong_ordering::equal;


       return _S_compl(__x2._M_lo) <=> _S_compl(__y2._M_lo);
     }
   else
     {
       if constexpr (__fmt == _M68k_80bit)
  {



    constexpr uint16_t __maxexp = 0x7fff;
    if ((__ix._M_hi & __maxexp) == __maxexp)
      __ix._M_lo |= 1ull << 63;
    if ((__iy._M_hi & __maxexp) == __maxexp)
      __iy._M_lo |= 1ull << 63;
  }
       else
  {
# 952 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/compare" 3
  }
       return _S_compl(__ix) <=> _S_compl(__iy);
     }
 }

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

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

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

      friend class _Partial_order;
      friend class _Weak_fallback;

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

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

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

      friend class _Partial_fallback;

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

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

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

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

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

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



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

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

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



  inline namespace _Cpo
  {
    inline constexpr __compare::_Strong_order strong_order{};

    inline constexpr __compare::_Weak_order weak_order{};

    inline constexpr __compare::_Partial_order partial_order{};

    inline constexpr __compare::_Strong_fallback
      compare_strong_order_fallback{};

    inline constexpr __compare::_Weak_fallback
      compare_weak_order_fallback{};

    inline constexpr __compare::_Partial_fallback
      compare_partial_order_fallback{};
  }


  namespace __detail
  {

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

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


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


}
# 66 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_pair.h" 2 3


namespace std __attribute__ ((__visibility__ ("default")))
{
# 79 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_pair.h" 3
  struct piecewise_construct_t { explicit piecewise_construct_t() = default; };


  inline constexpr piecewise_construct_t piecewise_construct =
    piecewise_construct_t();




  template<typename _T1, typename _T2>
    struct pair;

  template<typename...>
    class tuple;





  template<typename _Tp, size_t _Nm>
    struct array;

  template<size_t...>
    struct _Index_tuple;

  template<size_t _Int, class _Tp1, class _Tp2>
    constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&
    get(pair<_Tp1, _Tp2>& __in) noexcept;

  template<size_t _Int, class _Tp1, class _Tp2>
    constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&&
    get(pair<_Tp1, _Tp2>&& __in) noexcept;

  template<size_t _Int, class _Tp1, class _Tp2>
    constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&
    get(const pair<_Tp1, _Tp2>& __in) noexcept;

  template<size_t _Int, class _Tp1, class _Tp2>
    constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&&
    get(const pair<_Tp1, _Tp2>&& __in) noexcept;

  template<size_t __i, typename... _Elements>
    constexpr __tuple_element_t<__i, tuple<_Elements...>>&
    get(tuple<_Elements...>& __t) noexcept;

  template<size_t __i, typename... _Elements>
    constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
    get(const tuple<_Elements...>& __t) noexcept;

  template<size_t __i, typename... _Elements>
    constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
    get(tuple<_Elements...>&& __t) noexcept;

  template<size_t __i, typename... _Elements>
    constexpr const __tuple_element_t<__i, tuple<_Elements...>>&&
    get(const tuple<_Elements...>&& __t) noexcept;

  template<size_t _Int, typename _Tp, size_t _Nm>
    constexpr _Tp&
    get(array<_Tp, _Nm>&) noexcept;

  template<size_t _Int, typename _Tp, size_t _Nm>
    constexpr _Tp&&
    get(array<_Tp, _Nm>&&) noexcept;

  template<size_t _Int, typename _Tp, size_t _Nm>
    constexpr const _Tp&
    get(const array<_Tp, _Nm>&) noexcept;

  template<size_t _Int, typename _Tp, size_t _Nm>
    constexpr const _Tp&&
    get(const array<_Tp, _Nm>&&) noexcept;
# 221 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_pair.h" 3
  template<typename _Tp>
    inline constexpr bool __is_tuple_v = false;

  template<typename... _Ts>
    inline constexpr bool __is_tuple_v<tuple<_Ts...>> = true;


  template<typename _Tp>
    inline constexpr bool __is_tuple_like_v = false;

  template<typename... _Elements>
    inline constexpr bool __is_tuple_like_v<tuple<_Elements...>> = true;

  template<typename _T1, typename _T2>
    inline constexpr bool __is_tuple_like_v<pair<_T1, _T2>> = true;

  template<typename _Tp, size_t _Nm>
    inline constexpr bool __is_tuple_like_v<array<_Tp, _Nm>> = true;



  template<typename _Tp>
    concept __tuple_like = __is_tuple_like_v<remove_cvref_t<_Tp>>;

  template<typename _Tp>
    concept __pair_like = __tuple_like<_Tp> && tuple_size_v<remove_cvref_t<_Tp>> == 2;

  template<typename _Tp, typename _Tuple>
    concept __eligible_tuple_like
      = __detail::__different_from<_Tp, _Tuple> && __tuple_like<_Tp>
 && (tuple_size_v<remove_cvref_t<_Tp>> == tuple_size_v<_Tuple>)
 && !ranges::__detail::__is_subrange<remove_cvref_t<_Tp>>;

  template<typename _Tp, typename _Pair>
    concept __eligible_pair_like
      = __detail::__different_from<_Tp, _Pair> && __pair_like<_Tp>
 && !ranges::__detail::__is_subrange<remove_cvref_t<_Tp>>;


  template<typename _U1, typename _U2> class __pair_base
  {







  };
# 283 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_pair.h" 3
  template<typename _T1, typename _T2>
    struct pair
    : public __pair_base<_T1, _T2>
    {
      typedef _T1 first_type;
      typedef _T2 second_type;

      _T1 first;
      _T2 second;


      constexpr pair(const pair&) = default;
      constexpr pair(pair&&) = default;

      template<typename... _Args1, typename... _Args2>
 constexpr
 pair(piecewise_construct_t, tuple<_Args1...>, tuple<_Args2...>);


      constexpr void
      swap(pair& __p)
      noexcept(__and_<__is_nothrow_swappable<_T1>,
        __is_nothrow_swappable<_T2>>::value)
      {
 using std::swap;
 swap(first, __p.first);
 swap(second, __p.second);
      }
# 319 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_pair.h" 3
      constexpr void
      swap(const pair& __p) const
      noexcept(__and_v<__is_nothrow_swappable<const _T1>,
         __is_nothrow_swappable<const _T2>>)
      requires is_swappable_v<const _T1> && is_swappable_v<const _T2>
      {
 using std::swap;
 swap(first, __p.first);
 swap(second, __p.second);
      }


    private:
      template<typename... _Args1, size_t... _Indexes1,
        typename... _Args2, size_t... _Indexes2>
 constexpr
 pair(tuple<_Args1...>&, tuple<_Args2...>&,
      _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>);
    public:





      constexpr
      explicit(__not_<__and_<__is_implicitly_default_constructible<_T1>,
        __is_implicitly_default_constructible<_T2>>>())
      pair()
      requires is_default_constructible_v<_T1>
        && is_default_constructible_v<_T2>
      : first(), second()
      { }

    private:


      template<typename _U1, typename _U2>
 static constexpr bool
 _S_constructible()
 {
   if constexpr (is_constructible_v<_T1, _U1>)
     return is_constructible_v<_T2, _U2>;
   return false;
 }

      template<typename _U1, typename _U2>
 static constexpr bool
 _S_nothrow_constructible()
 {
   if constexpr (is_nothrow_constructible_v<_T1, _U1>)
     return is_nothrow_constructible_v<_T2, _U2>;
   return false;
 }

      template<typename _U1, typename _U2>
 static constexpr bool
 _S_convertible()
 {
   if constexpr (is_convertible_v<_U1, _T1>)
     return is_convertible_v<_U2, _T2>;
   return false;
 }


      template<typename _U1, typename _U2>
 static constexpr bool
 _S_dangles()
 {

   if constexpr (__reference_constructs_from_temporary(_T1, _U1&&))
     return true;
   else
     return __reference_constructs_from_temporary(_T2, _U2&&);



 }


      template<typename _UPair>
 static constexpr bool
 _S_constructible_from_pair_like()
 {
   return _S_constructible<decltype(std::get<0>(std::declval<_UPair>())),
      decltype(std::get<1>(std::declval<_UPair>()))>();
 }

      template<typename _UPair>
 static constexpr bool
 _S_convertible_from_pair_like()
 {
   return _S_convertible<decltype(std::get<0>(std::declval<_UPair>())),
    decltype(std::get<1>(std::declval<_UPair>()))>();
 }

      template<typename _UPair>
 static constexpr bool
 _S_dangles_from_pair_like()
 {
   return _S_dangles<decltype(std::get<0>(std::declval<_UPair>())),
       decltype(std::get<1>(std::declval<_UPair>()))>();
 }



    public:


      constexpr explicit(!_S_convertible<const _T1&, const _T2&>())
      pair(const _T1& __x, const _T2& __y)
      noexcept(_S_nothrow_constructible<const _T1&, const _T2&>())
      requires (_S_constructible<const _T1&, const _T2&>())
      : first(__x), second(__y)
      { }



      template<typename _U1 = _T1, typename _U2 = _T2>



 requires (_S_constructible<_U1, _U2>()) && (!_S_dangles<_U1, _U2>())
 constexpr explicit(!_S_convertible<_U1, _U2>())
 pair(_U1&& __x, _U2&& __y)
 noexcept(_S_nothrow_constructible<_U1, _U2>())
 : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y))
 { }


      template<typename _U1 = _T1, typename _U2 = _T2>



 requires (_S_constructible<_U1, _U2>()) && (_S_dangles<_U1, _U2>())
 constexpr explicit(!_S_convertible<_U1, _U2>())
 pair(_U1&&, _U2&&) = delete;


      template<typename _U1, typename _U2>
 requires (_S_constructible<const _U1&, const _U2&>())
   && (!_S_dangles<_U1, _U2>())
 constexpr explicit(!_S_convertible<const _U1&, const _U2&>())
 pair(const pair<_U1, _U2>& __p)
 noexcept(_S_nothrow_constructible<const _U1&, const _U2&>())
 : first(__p.first), second(__p.second)
 { }

      template<typename _U1, typename _U2>
 requires (_S_constructible<const _U1&, const _U2&>())
       && (_S_dangles<const _U1&, const _U2&>())
 constexpr explicit(!_S_convertible<const _U1&, const _U2&>())
 pair(const pair<_U1, _U2>&) = delete;


      template<typename _U1, typename _U2>
 requires (_S_constructible<_U1, _U2>()) && (!_S_dangles<_U1, _U2>())
 constexpr explicit(!_S_convertible<_U1, _U2>())
 pair(pair<_U1, _U2>&& __p)
 noexcept(_S_nothrow_constructible<_U1, _U2>())
 : first(std::forward<_U1>(__p.first)),
   second(std::forward<_U2>(__p.second))
 { }

      template<typename _U1, typename _U2>
 requires (_S_constructible<_U1, _U2>()) && (_S_dangles<_U1, _U2>())
 constexpr explicit(!_S_convertible<_U1, _U2>())
 pair(pair<_U1, _U2>&&) = delete;



      template<typename _U1, typename _U2>
 requires (_S_constructible<_U1&, _U2&>()) && (!_S_dangles<_U1&, _U2&>())
 constexpr explicit(!_S_convertible<_U1&, _U2&>())
 pair(pair<_U1, _U2>& __p)
 noexcept(_S_nothrow_constructible<_U1&, _U2&>())
 : first(__p.first), second(__p.second)
 { }

      template<typename _U1, typename _U2>
 requires (_S_constructible<_U1&, _U2&>()) && (_S_dangles<_U1&, _U2&>())
 constexpr explicit(!_S_convertible<_U1&, _U2&>())
 pair(pair<_U1, _U2>&) = delete;


      template<typename _U1, typename _U2>
 requires (_S_constructible<const _U1, const _U2>())
   && (!_S_dangles<const _U1, const _U2>())
 constexpr explicit(!_S_convertible<const _U1, const _U2>())
 pair(const pair<_U1, _U2>&& __p)
 noexcept(_S_nothrow_constructible<const _U1, const _U2>())
 : first(std::forward<const _U1>(__p.first)),
   second(std::forward<const _U2>(__p.second))
 { }

      template<typename _U1, typename _U2>
 requires (_S_constructible<const _U1, const _U2>())
   && (_S_dangles<const _U1, const _U2>())
 constexpr explicit(!_S_convertible<const _U1, const _U2>())
 pair(const pair<_U1, _U2>&&) = delete;



      template<__eligible_pair_like<pair> _UPair>
 requires (_S_constructible_from_pair_like<_UPair>())
   && (!_S_dangles_from_pair_like<_UPair>())
 constexpr explicit(!_S_convertible_from_pair_like<_UPair>())
 pair(_UPair&& __p)
 : first(std::get<0>(std::forward<_UPair>(__p))),
   second(std::get<1>(std::forward<_UPair>(__p)))
 { }

      template<__eligible_pair_like<pair> _UPair>
 requires (_S_constructible_from_pair_like<_UPair>())
   && (_S_dangles_from_pair_like<_UPair>())
 constexpr explicit(!_S_convertible_from_pair_like<_UPair>())
 pair(_UPair&&) = delete;


  private:

      template<typename _U1, typename _U2>
 static constexpr bool
 _S_assignable()
 {
   if constexpr (is_assignable_v<_T1&, _U1>)
     return is_assignable_v<_T2&, _U2>;
   return false;
 }

      template<typename _U1, typename _U2>
 static constexpr bool
 _S_const_assignable()
 {
   if constexpr (is_assignable_v<const _T1&, _U1>)
     return is_assignable_v<const _T2&, _U2>;
   return false;
 }

      template<typename _U1, typename _U2>
 static constexpr bool
 _S_nothrow_assignable()
 {
   if constexpr (is_nothrow_assignable_v<_T1&, _U1>)
     return is_nothrow_assignable_v<_T2&, _U2>;
   return false;
 }


      template<typename _UPair>
 static constexpr bool
 _S_assignable_from_tuple_like()
 {
   return _S_assignable<decltype(std::get<0>(std::declval<_UPair>())),
          decltype(std::get<1>(std::declval<_UPair>()))>();
 }

      template<typename _UPair>
 static constexpr bool
 _S_const_assignable_from_tuple_like()
 {
   return _S_const_assignable<decltype(std::get<0>(std::declval<_UPair>())),
         decltype(std::get<1>(std::declval<_UPair>()))>();
 }



  public:

      pair& operator=(const pair&) = delete;


      constexpr pair&
      operator=(const pair& __p)
      noexcept(_S_nothrow_assignable<const _T1&, const _T2&>())
      requires (_S_assignable<const _T1&, const _T2&>())
      {
 first = __p.first;
 second = __p.second;
 return *this;
      }


      constexpr pair&
      operator=(pair&& __p)
      noexcept(_S_nothrow_assignable<_T1, _T2>())
      requires (_S_assignable<_T1, _T2>())
      {
 first = std::forward<first_type>(__p.first);
 second = std::forward<second_type>(__p.second);
 return *this;
      }


      template<typename _U1, typename _U2>
 constexpr pair&
 operator=(const pair<_U1, _U2>& __p)
 noexcept(_S_nothrow_assignable<const _U1&, const _U2&>())
 requires (_S_assignable<const _U1&, const _U2&>())
 {
   first = __p.first;
   second = __p.second;
   return *this;
 }


      template<typename _U1, typename _U2>
 constexpr pair&
 operator=(pair<_U1, _U2>&& __p)
 noexcept(_S_nothrow_assignable<_U1, _U2>())
 requires (_S_assignable<_U1, _U2>())
 {
   first = std::forward<_U1>(__p.first);
   second = std::forward<_U2>(__p.second);
   return *this;
 }



      constexpr const pair&
      operator=(const pair& __p) const
      requires (_S_const_assignable<const first_type&, const second_type&>())
      {
 first = __p.first;
 second = __p.second;
 return *this;
      }


      constexpr const pair&
      operator=(pair&& __p) const
      requires (_S_const_assignable<first_type, second_type>())
      {
 first = std::forward<first_type>(__p.first);
 second = std::forward<second_type>(__p.second);
 return *this;
      }


      template<typename _U1, typename _U2>
 constexpr const pair&
 operator=(const pair<_U1, _U2>& __p) const
 requires (_S_const_assignable<const _U1&, const _U2&>())
 {
   first = __p.first;
   second = __p.second;
   return *this;
 }


      template<typename _U1, typename _U2>
 constexpr const pair&
 operator=(pair<_U1, _U2>&& __p) const
 requires (_S_const_assignable<_U1, _U2>())
 {
   first = std::forward<_U1>(__p.first);
   second = std::forward<_U2>(__p.second);
   return *this;
 }



      template<__eligible_pair_like<pair> _UPair>
 requires (_S_assignable_from_tuple_like<_UPair>())
 constexpr pair&
 operator=(_UPair&& __p)
 {
   first = std::get<0>(std::forward<_UPair>(__p));
   second = std::get<1>(std::forward<_UPair>(__p));
   return *this;
 }

      template<__eligible_pair_like<pair> _UPair>
 requires (_S_const_assignable_from_tuple_like<_UPair>())
 constexpr const pair&
 operator=(_UPair&& __p) const
 {
   first = std::get<0>(std::forward<_UPair>(__p));
   second = std::get<1>(std::forward<_UPair>(__p));
   return *this;
 }
# 995 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_pair.h" 3
    };




  template<typename _T1, typename _T2> pair(_T1, _T2) -> pair<_T1, _T2>;







  template<typename _T1, typename _T2, typename _U1, typename _U2>
    inline constexpr bool
    operator==(const pair<_T1, _T2>& __x, const pair<_U1, _U2>& __y)
    { return __x.first == __y.first && __x.second == __y.second; }
# 1020 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_pair.h" 3
  template<typename _T1, typename _T2, typename _U1, typename _U2>
    constexpr common_comparison_category_t<__detail::__synth3way_t<_T1, _U1>,
        __detail::__synth3way_t<_T2, _U2>>
    operator<=>(const pair<_T1, _T2>& __x, const pair<_U1, _U2>& __y)
    {
      if (auto __c = __detail::__synth3way(__x.first, __y.first); __c != 0)
 return __c;
      return __detail::__synth3way(__x.second, __y.second);
    }
# 1080 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_pair.h" 3
  template<typename _T1, typename _T2>
    constexpr inline


    typename enable_if<__and_<__is_swappable<_T1>,
                              __is_swappable<_T2>>::value>::type



    swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
    noexcept(noexcept(__x.swap(__y)))
    { __x.swap(__y); }


  template<typename _T1, typename _T2>
    requires is_swappable_v<const _T1> && is_swappable_v<const _T2>
    constexpr void
    swap(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
    noexcept(noexcept(__x.swap(__y)))
    { __x.swap(__y); }



  template<typename _T1, typename _T2>
    typename enable_if<!__and_<__is_swappable<_T1>,
          __is_swappable<_T2>>::value>::type
    swap(pair<_T1, _T2>&, pair<_T1, _T2>&) = delete;
# 1129 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_pair.h" 3
  template<typename _T1, typename _T2>
    constexpr pair<typename __decay_and_strip<_T1>::__type,
                   typename __decay_and_strip<_T2>::__type>
    make_pair(_T1&& __x, _T2&& __y)
    {
      typedef typename __decay_and_strip<_T1>::__type __ds_type1;
      typedef typename __decay_and_strip<_T2>::__type __ds_type2;
      typedef pair<__ds_type1, __ds_type2> __pair_type;
      return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y));
    }
# 1152 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_pair.h" 3
  template<typename _T1, typename _T2>
    struct __is_tuple_like_impl<pair<_T1, _T2>> : true_type
    { };



  template<class _Tp1, class _Tp2>
    struct tuple_size<pair<_Tp1, _Tp2>>
    : public integral_constant<size_t, 2> { };


  template<class _Tp1, class _Tp2>
    struct tuple_element<0, pair<_Tp1, _Tp2>>
    { typedef _Tp1 type; };


  template<class _Tp1, class _Tp2>
    struct tuple_element<1, pair<_Tp1, _Tp2>>
    { typedef _Tp2 type; };



  template<size_t __i, typename... _Types>
    struct tuple_element<__i, tuple<_Types...>>;


  template<typename _Tp1, typename _Tp2>
    inline constexpr size_t tuple_size_v<pair<_Tp1, _Tp2>> = 2;

  template<typename _Tp1, typename _Tp2>
    inline constexpr size_t tuple_size_v<const pair<_Tp1, _Tp2>> = 2;

  template<typename _Tp>
    inline constexpr bool __is_pair = false;

  template<typename _Tp, typename _Up>
    inline constexpr bool __is_pair<pair<_Tp, _Up>> = true;



  template<size_t _Int>
    struct __pair_get;

  template<>
    struct __pair_get<0>
    {
      template<typename _Tp1, typename _Tp2>
 static constexpr _Tp1&
 __get(pair<_Tp1, _Tp2>& __pair) noexcept
 { return __pair.first; }

      template<typename _Tp1, typename _Tp2>
 static constexpr _Tp1&&
 __move_get(pair<_Tp1, _Tp2>&& __pair) noexcept
 { return std::forward<_Tp1>(__pair.first); }

      template<typename _Tp1, typename _Tp2>
 static constexpr const _Tp1&
 __const_get(const pair<_Tp1, _Tp2>& __pair) noexcept
 { return __pair.first; }

      template<typename _Tp1, typename _Tp2>
 static constexpr const _Tp1&&
 __const_move_get(const pair<_Tp1, _Tp2>&& __pair) noexcept
 { return std::forward<const _Tp1>(__pair.first); }
    };

  template<>
    struct __pair_get<1>
    {
      template<typename _Tp1, typename _Tp2>
 static constexpr _Tp2&
 __get(pair<_Tp1, _Tp2>& __pair) noexcept
 { return __pair.second; }

      template<typename _Tp1, typename _Tp2>
 static constexpr _Tp2&&
 __move_get(pair<_Tp1, _Tp2>&& __pair) noexcept
 { return std::forward<_Tp2>(__pair.second); }

      template<typename _Tp1, typename _Tp2>
 static constexpr const _Tp2&
 __const_get(const pair<_Tp1, _Tp2>& __pair) noexcept
 { return __pair.second; }

      template<typename _Tp1, typename _Tp2>
 static constexpr const _Tp2&&
 __const_move_get(const pair<_Tp1, _Tp2>&& __pair) noexcept
 { return std::forward<const _Tp2>(__pair.second); }
    };






  template<size_t _Int, class _Tp1, class _Tp2>
    constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&
    get(pair<_Tp1, _Tp2>& __in) noexcept
    { return __pair_get<_Int>::__get(__in); }

  template<size_t _Int, class _Tp1, class _Tp2>
    constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&&
    get(pair<_Tp1, _Tp2>&& __in) noexcept
    { return __pair_get<_Int>::__move_get(std::move(__in)); }

  template<size_t _Int, class _Tp1, class _Tp2>
    constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&
    get(const pair<_Tp1, _Tp2>& __in) noexcept
    { return __pair_get<_Int>::__const_get(__in); }

  template<size_t _Int, class _Tp1, class _Tp2>
    constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&&
    get(const pair<_Tp1, _Tp2>&& __in) noexcept
    { return __pair_get<_Int>::__const_move_get(std::move(__in)); }



  template <typename _Tp, typename _Up>
    constexpr _Tp&
    get(pair<_Tp, _Up>& __p) noexcept
    { return __p.first; }

  template <typename _Tp, typename _Up>
    constexpr const _Tp&
    get(const pair<_Tp, _Up>& __p) noexcept
    { return __p.first; }

  template <typename _Tp, typename _Up>
    constexpr _Tp&&
    get(pair<_Tp, _Up>&& __p) noexcept
    { return std::move(__p.first); }

  template <typename _Tp, typename _Up>
    constexpr const _Tp&&
    get(const pair<_Tp, _Up>&& __p) noexcept
    { return std::move(__p.first); }

  template <typename _Tp, typename _Up>
    constexpr _Tp&
    get(pair<_Up, _Tp>& __p) noexcept
    { return __p.second; }

  template <typename _Tp, typename _Up>
    constexpr const _Tp&
    get(const pair<_Up, _Tp>& __p) noexcept
    { return __p.second; }

  template <typename _Tp, typename _Up>
    constexpr _Tp&&
    get(pair<_Up, _Tp>&& __p) noexcept
    { return std::move(__p.second); }

  template <typename _Tp, typename _Up>
    constexpr const _Tp&&
    get(const pair<_Up, _Tp>&& __p) noexcept
    { return std::move(__p.second); }




  template<typename _T1, typename _T2, typename _U1, typename _U2,
    template<typename> class _TQual, template<typename> class _UQual>
    requires requires { typename pair<common_reference_t<_TQual<_T1>, _UQual<_U1>>,
          common_reference_t<_TQual<_T2>, _UQual<_U2>>>; }
  struct basic_common_reference<pair<_T1, _T2>, pair<_U1, _U2>, _TQual, _UQual>
  {
    using type = pair<common_reference_t<_TQual<_T1>, _UQual<_U1>>,
        common_reference_t<_TQual<_T2>, _UQual<_U2>>>;
  };

  template<typename _T1, typename _T2, typename _U1, typename _U2>
    requires requires { typename pair<common_type_t<_T1, _U1>, common_type_t<_T2, _U2>>; }
  struct common_type<pair<_T1, _T2>, pair<_U1, _U2>>
  { using type = pair<common_type_t<_T1, _U1>, common_type_t<_T2, _U2>>; };






}
# 39 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tuple" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/uses_allocator.h" 1 3
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/uses_allocator.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{




  struct __erased_type { };




  template<typename _Alloc, typename _Tp>
    using __is_erased_or_convertible
      = __or_<is_convertible<_Alloc, _Tp>, is_same<_Tp, __erased_type>>;


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

  inline constexpr allocator_arg_t allocator_arg =
    allocator_arg_t();

  template<typename _Tp, typename _Alloc, typename = __void_t<>>
    struct __uses_allocator_helper
    : false_type { };

  template<typename _Tp, typename _Alloc>
    struct __uses_allocator_helper<_Tp, _Alloc,
       __void_t<typename _Tp::allocator_type>>
    : __is_erased_or_convertible<_Alloc, typename _Tp::allocator_type>::type
    { };


  template<typename _Tp, typename _Alloc>
    struct uses_allocator
    : __uses_allocator_helper<_Tp, _Alloc>::type
    { };

  struct __uses_alloc_base { };

  struct __uses_alloc0 : __uses_alloc_base
  {
    struct _Sink { void constexpr operator=(const void*) { } } _M_a;
  };

  template<typename _Alloc>
    struct __uses_alloc1 : __uses_alloc_base { const _Alloc* _M_a; };

  template<typename _Alloc>
    struct __uses_alloc2 : __uses_alloc_base { const _Alloc* _M_a; };

  template<bool, typename _Tp, typename _Alloc, typename... _Args>
    struct __uses_alloc;

  template<typename _Tp, typename _Alloc, typename... _Args>
    struct __uses_alloc<true, _Tp, _Alloc, _Args...>
    : __conditional_t<
        is_constructible<_Tp, allocator_arg_t, const _Alloc&, _Args...>::value,
        __uses_alloc1<_Alloc>,
        __uses_alloc2<_Alloc>>
    {


      static_assert(__or_<
   is_constructible<_Tp, allocator_arg_t, const _Alloc&, _Args...>,
   is_constructible<_Tp, _Args..., const _Alloc&>>::value,
   "construction with an allocator must be possible"
   " if uses_allocator is true");
    };

  template<typename _Tp, typename _Alloc, typename... _Args>
    struct __uses_alloc<false, _Tp, _Alloc, _Args...>
    : __uses_alloc0 { };

  template<typename _Tp, typename _Alloc, typename... _Args>
    using __uses_alloc_t =
      __uses_alloc<uses_allocator<_Tp, _Alloc>::value, _Tp, _Alloc, _Args...>;

  template<typename _Tp, typename _Alloc, typename... _Args>
    constexpr
    inline __uses_alloc_t<_Tp, _Alloc, _Args...>
    __use_alloc(const _Alloc& __a)
    {
      __uses_alloc_t<_Tp, _Alloc, _Args...> __ret;
      __ret._M_a = std::__addressof(__a);
      return __ret;
    }

  template<typename _Tp, typename _Alloc, typename... _Args>
    void
    __use_alloc(const _Alloc&&) = delete;


  template <typename _Tp, typename _Alloc>
    inline constexpr bool uses_allocator_v =
      uses_allocator<_Tp, _Alloc>::value;


  template<template<typename...> class _Predicate,
    typename _Tp, typename _Alloc, typename... _Args>
    struct __is_uses_allocator_predicate
    : __conditional_t<uses_allocator<_Tp, _Alloc>::value,
      __or_<_Predicate<_Tp, allocator_arg_t, _Alloc, _Args...>,
     _Predicate<_Tp, _Args..., _Alloc>>,
      _Predicate<_Tp, _Args...>> { };

  template<typename _Tp, typename _Alloc, typename... _Args>
    struct __is_uses_allocator_constructible
    : __is_uses_allocator_predicate<is_constructible, _Tp, _Alloc, _Args...>
    { };


  template<typename _Tp, typename _Alloc, typename... _Args>
    inline constexpr bool __is_uses_allocator_constructible_v =
      __is_uses_allocator_constructible<_Tp, _Alloc, _Args...>::value;


  template<typename _Tp, typename _Alloc, typename... _Args>
    struct __is_nothrow_uses_allocator_constructible
    : __is_uses_allocator_predicate<is_nothrow_constructible,
        _Tp, _Alloc, _Args...>
    { };



  template<typename _Tp, typename _Alloc, typename... _Args>
    inline constexpr bool
    __is_nothrow_uses_allocator_constructible_v =
      __is_nothrow_uses_allocator_constructible<_Tp, _Alloc, _Args...>::value;


  template<typename _Tp, typename... _Args>
    void __uses_allocator_construct_impl(__uses_alloc0, _Tp* __ptr,
      _Args&&... __args)
    { ::new ((void*)__ptr) _Tp(std::forward<_Args>(__args)...); }

  template<typename _Tp, typename _Alloc, typename... _Args>
    void __uses_allocator_construct_impl(__uses_alloc1<_Alloc> __a, _Tp* __ptr,
      _Args&&... __args)
    {
      ::new ((void*)__ptr) _Tp(allocator_arg, *__a._M_a,
          std::forward<_Args>(__args)...);
    }

  template<typename _Tp, typename _Alloc, typename... _Args>
    void __uses_allocator_construct_impl(__uses_alloc2<_Alloc> __a, _Tp* __ptr,
      _Args&&... __args)
    { ::new ((void*)__ptr) _Tp(std::forward<_Args>(__args)..., *__a._M_a); }

  template<typename _Tp, typename _Alloc, typename... _Args>
    void __uses_allocator_construct(const _Alloc& __a, _Tp* __ptr,
        _Args&&... __args)
    {
      std::__uses_allocator_construct_impl(
   std::__use_alloc<_Tp, _Alloc, _Args...>(__a), __ptr,
   std::forward<_Args>(__args)...);
    }



}
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tuple" 2 3

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/invoke.h" 1 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/invoke.h" 3








namespace std __attribute__ ((__visibility__ ("default")))
{
# 53 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/invoke.h" 3
  template<typename _Tp, typename _Up = typename __inv_unwrap<_Tp>::type>
    constexpr _Up&&
    __invfwd(typename remove_reference<_Tp>::type& __t) noexcept
    { return static_cast<_Up&&>(__t); }

  template<typename _Res, typename _Fn, typename... _Args>
    constexpr _Res
    __invoke_impl(__invoke_other, _Fn&& __f, _Args&&... __args)
    { return std::forward<_Fn>(__f)(std::forward<_Args>(__args)...); }

  template<typename _Res, typename _MemFun, typename _Tp, typename... _Args>
    constexpr _Res
    __invoke_impl(__invoke_memfun_ref, _MemFun&& __f, _Tp&& __t,
    _Args&&... __args)
    { return (__invfwd<_Tp>(__t).*__f)(std::forward<_Args>(__args)...); }

  template<typename _Res, typename _MemFun, typename _Tp, typename... _Args>
    constexpr _Res
    __invoke_impl(__invoke_memfun_deref, _MemFun&& __f, _Tp&& __t,
    _Args&&... __args)
    {
      return ((*std::forward<_Tp>(__t)).*__f)(std::forward<_Args>(__args)...);
    }

  template<typename _Res, typename _MemPtr, typename _Tp>
    constexpr _Res
    __invoke_impl(__invoke_memobj_ref, _MemPtr&& __f, _Tp&& __t)
    { return __invfwd<_Tp>(__t).*__f; }

  template<typename _Res, typename _MemPtr, typename _Tp>
    constexpr _Res
    __invoke_impl(__invoke_memobj_deref, _MemPtr&& __f, _Tp&& __t)
    { return (*std::forward<_Tp>(__t)).*__f; }


  template<typename _Callable, typename... _Args>
    constexpr typename __invoke_result<_Callable, _Args...>::type
    __invoke(_Callable&& __fn, _Args&&... __args)
    noexcept(__is_nothrow_invocable<_Callable, _Args...>::value)
    {
      using __result = __invoke_result<_Callable, _Args...>;
      using __type = typename __result::type;
      using __tag = typename __result::__invoke_type;
      return std::__invoke_impl<__type>(__tag{}, std::forward<_Callable>(__fn),
     std::forward<_Args>(__args)...);
    }



  template<typename _Res, typename _Callable, typename... _Args>
    constexpr enable_if_t<is_invocable_r_v<_Res, _Callable, _Args...>, _Res>
    __invoke_r(_Callable&& __fn, _Args&&... __args)
    noexcept(is_nothrow_invocable_r_v<_Res, _Callable, _Args...>)
    {
      using __result = __invoke_result<_Callable, _Args...>;
      using __type = typename __result::type;
      using __tag = typename __result::__invoke_type;
      if constexpr (is_void_v<_Res>)
 std::__invoke_impl<__type>(__tag{}, std::forward<_Callable>(__fn),
     std::forward<_Args>(__args)...);
      else
 return std::__invoke_impl<__type>(__tag{},
       std::forward<_Callable>(__fn),
       std::forward<_Args>(__args)...);
    }
# 156 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/invoke.h" 3
}
# 42 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tuple" 2 3


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ranges_util.h" 1 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ranges_util.h" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ranges_base.h" 1 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ranges_base.h" 3



# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_iterator.h" 1 3
# 63 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_iterator.h" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/cpp_type_traits.h" 1 3
# 36 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/cpp_type_traits.h" 3
# 67 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/cpp_type_traits.h" 3
extern "C++" {

namespace std __attribute__ ((__visibility__ ("default")))
{


  struct __true_type { };
  struct __false_type { };

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

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



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


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

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


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

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




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





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

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

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

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


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



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



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

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


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

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

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

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

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

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

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

  template<>
    struct __is_integer<unsigned long long>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };
# 272 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/cpp_type_traits.h" 3
__extension__ template<> struct __is_integer<__int128> { enum { __value = 1 }; typedef __true_type __type; }; __extension__ template<> struct __is_integer<unsigned __int128> { enum { __value = 1 }; typedef __true_type __type; };
# 289 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/cpp_type_traits.h" 3
  template<typename _Tp>
    struct __is_floating
    {
      enum { __value = 0 };
      typedef __false_type __type;
    };


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

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

  template<>
    struct __is_floating<long double>
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };
# 366 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/cpp_type_traits.h" 3
  template<typename _Tp>
    struct __is_pointer
    {
      enum { __value = 0 };
      typedef __false_type __type;
    };

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




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




  template<typename _Tp>
    struct __is_scalar
    : public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> >
    { };




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

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


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


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

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

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

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


  enum class byte : unsigned char;

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



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


  template<typename> struct iterator_traits;


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




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


  template<typename _OutputIter, typename _InputIter>
    struct __memcpyable
    {
      enum { __value = 0 };
    };

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

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






  template<typename _Iter1, typename _Iter2>
    struct __memcmpable
    {
      enum { __value = 0 };
    };


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

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

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







  template<typename _Tp, bool _TreatAsBytes =



 __is_byte<_Tp>::__value

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

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


  template<typename _Tp, typename _Up, bool = sizeof(_Tp) == sizeof(_Up)>
    struct __is_memcmp_ordered_with
    {
      static const bool __value = __is_memcmp_ordered<_Tp>::__value
 && __is_memcmp_ordered<_Up>::__value;
    };

  template<typename _Tp, typename _Up>
    struct __is_memcmp_ordered_with<_Tp, _Up, false>
    {
      static const bool __value = false;
    };
# 579 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/cpp_type_traits.h" 3
  template<>
    struct __is_memcmp_ordered_with<std::byte, std::byte, true>
    { static constexpr bool __value = true; };

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

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





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



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


}
}
# 64 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_iterator.h" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_iterator_base_types.h" 1 3
# 63 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_iterator_base_types.h" 3








# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/iterator_concepts.h" 1 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/iterator_concepts.h" 3



# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ptr_traits.h" 1 3
# 39 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ptr_traits.h" 3
namespace __gnu_debug { struct _Safe_iterator_base; }


namespace std __attribute__ ((__visibility__ ("default")))
{




  class __undefined;



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

  template<template<typename, typename...> class _SomeTemplate, typename _Tp,
           typename... _Types>
    struct __get_first_arg<_SomeTemplate<_Tp, _Types...>>
    { using type = _Tp; };



  template<typename _Tp, typename _Up>
    struct __replace_first_arg
    { };

  template<template<typename, typename...> class _SomeTemplate, typename _Up,
           typename _Tp, typename... _Types>
    struct __replace_first_arg<_SomeTemplate<_Tp, _Types...>, _Up>
    { using type = _SomeTemplate<_Up, _Types...>; };


  template<typename _Ptr, typename = void>
    struct __ptr_traits_elem : __get_first_arg<_Ptr>
    { };



  template<typename _Ptr> requires requires { typename _Ptr::element_type; }
    struct __ptr_traits_elem<_Ptr, void>
    { using type = typename _Ptr::element_type; };






  template<typename _Ptr>
    using __ptr_traits_elem_t = typename __ptr_traits_elem<_Ptr>::type;




  template<typename _Ptr, typename _Elt, bool = is_void<_Elt>::value>
    struct __ptr_traits_ptr_to
    {
      using pointer = _Ptr;
      using element_type = _Elt;







      static pointer
      pointer_to(element_type& __r)

      requires requires {
 { pointer::pointer_to(__r) } -> convertible_to<pointer>;
      }

      { return pointer::pointer_to(__r); }
    };


  template<typename _Ptr, typename _Elt>
    struct __ptr_traits_ptr_to<_Ptr, _Elt, true>
    { };


  template<typename _Tp>
    struct __ptr_traits_ptr_to<_Tp*, _Tp, false>
    {
      using pointer = _Tp*;
      using element_type = _Tp;






      static constexpr pointer
      pointer_to(element_type& __r) noexcept
      { return std::addressof(__r); }
    };

  template<typename _Ptr, typename _Elt>
    struct __ptr_traits_impl : __ptr_traits_ptr_to<_Ptr, _Elt>
    {
    private:
      template<typename _Tp>
 using __diff_t = typename _Tp::difference_type;

      template<typename _Tp, typename _Up>
 using __rebind = __type_identity<typename _Tp::template rebind<_Up>>;

    public:

      using pointer = _Ptr;


      using element_type = _Elt;


      using difference_type = __detected_or_t<ptrdiff_t, __diff_t, _Ptr>;


      template<typename _Up>
 using rebind = typename __detected_or_t<__replace_first_arg<_Ptr, _Up>,
      __rebind, _Ptr, _Up>::type;
    };



  template<typename _Ptr>
    struct __ptr_traits_impl<_Ptr, __undefined>
    { };







  template<typename _Ptr>
    struct pointer_traits : __ptr_traits_impl<_Ptr, __ptr_traits_elem_t<_Ptr>>
    { };







  template<typename _Tp>
    struct pointer_traits<_Tp*> : __ptr_traits_ptr_to<_Tp*, _Tp>
    {

      typedef _Tp* pointer;

      typedef _Tp element_type;

      typedef ptrdiff_t difference_type;

      template<typename _Up> using rebind = _Up*;
    };


  template<typename _Ptr, typename _Tp>
    using __ptr_rebind = typename pointer_traits<_Ptr>::template rebind<_Tp>;

  template<typename _Tp>
    constexpr _Tp*
    __to_address(_Tp* __ptr) noexcept
    {
      static_assert(!std::is_function<_Tp>::value, "not a function pointer");
      return __ptr;
    }







  template<typename _Ptr>
    constexpr auto
    __to_address(const _Ptr& __ptr) noexcept
    -> decltype(std::pointer_traits<_Ptr>::to_address(__ptr))
    { return std::pointer_traits<_Ptr>::to_address(__ptr); }

  template<typename _Ptr, typename... _None>
    constexpr auto
    __to_address(const _Ptr& __ptr, _None...) noexcept
    {
      if constexpr (is_base_of_v<__gnu_debug::_Safe_iterator_base, _Ptr>)
 return std::__to_address(__ptr.base().operator->());
      else
 return std::__to_address(__ptr.operator->());
    }







  template<typename _Tp>
    constexpr _Tp*
    to_address(_Tp* __ptr) noexcept
    { return std::__to_address(__ptr); }
# 251 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ptr_traits.h" 3
  template<typename _Ptr>
    constexpr auto
    to_address(const _Ptr& __ptr) noexcept
    { return std::__to_address(__ptr); }



}
# 38 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/iterator_concepts.h" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ranges_cmp.h" 1 3
# 37 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ranges_cmp.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{


  struct __is_transparent;





  struct identity
  {
    template<typename _Tp>
      [[nodiscard]]
      constexpr _Tp&&
      operator()(_Tp&& __t) const noexcept
      { return std::forward<_Tp>(__t); }

    using is_transparent = __is_transparent;
  };


namespace ranges
{
  namespace __detail
  {



    template<typename _Tp, typename _Up>
      concept __less_builtin_ptr_cmp
 = requires (_Tp&& __t, _Up&& __u) { { __t < __u } -> same_as<bool>; }
   && convertible_to<_Tp, const volatile void*>
   && convertible_to<_Up, const volatile void*>
   && (! requires(_Tp&& __t, _Up&& __u)
       { operator<(std::forward<_Tp>(__t), std::forward<_Up>(__u)); }
       && ! requires(_Tp&& __t, _Up&& __u)
       { std::forward<_Tp>(__t).operator<(std::forward<_Up>(__u)); });
  }







  struct equal_to
  {
    template<typename _Tp, typename _Up>
      requires equality_comparable_with<_Tp, _Up>
      constexpr bool
      operator()(_Tp&& __t, _Up&& __u) const
      noexcept(noexcept(std::declval<_Tp>() == std::declval<_Up>()))
      { return std::forward<_Tp>(__t) == std::forward<_Up>(__u); }

    using is_transparent = __is_transparent;
  };


  struct not_equal_to
  {
    template<typename _Tp, typename _Up>
      requires equality_comparable_with<_Tp, _Up>
      constexpr bool
      operator()(_Tp&& __t, _Up&& __u) const
      noexcept(noexcept(std::declval<_Up>() == std::declval<_Tp>()))
      { return !equal_to{}(std::forward<_Tp>(__t), std::forward<_Up>(__u)); }

    using is_transparent = __is_transparent;
  };


  struct less
  {
    template<typename _Tp, typename _Up>
      requires totally_ordered_with<_Tp, _Up>
      constexpr bool
      operator()(_Tp&& __t, _Up&& __u) const
      noexcept(noexcept(std::declval<_Tp>() < std::declval<_Up>()))
      {
 if constexpr (__detail::__less_builtin_ptr_cmp<_Tp, _Up>)
   {
     if (std::__is_constant_evaluated())
       return __t < __u;

     auto __x = reinterpret_cast<long unsigned int>(
       static_cast<const volatile void*>(std::forward<_Tp>(__t)));
     auto __y = reinterpret_cast<long unsigned int>(
       static_cast<const volatile void*>(std::forward<_Up>(__u)));
     return __x < __y;
   }
 else
   return std::forward<_Tp>(__t) < std::forward<_Up>(__u);
      }

    using is_transparent = __is_transparent;
  };


  struct greater
  {
    template<typename _Tp, typename _Up>
      requires totally_ordered_with<_Tp, _Up>
      constexpr bool
      operator()(_Tp&& __t, _Up&& __u) const
      noexcept(noexcept(std::declval<_Up>() < std::declval<_Tp>()))
      { return less{}(std::forward<_Up>(__u), std::forward<_Tp>(__t)); }

    using is_transparent = __is_transparent;
  };


  struct greater_equal
  {
    template<typename _Tp, typename _Up>
      requires totally_ordered_with<_Tp, _Up>
      constexpr bool
      operator()(_Tp&& __t, _Up&& __u) const
      noexcept(noexcept(std::declval<_Tp>() < std::declval<_Up>()))
      { return !less{}(std::forward<_Tp>(__t), std::forward<_Up>(__u)); }

    using is_transparent = __is_transparent;
  };


  struct less_equal
  {
    template<typename _Tp, typename _Up>
      requires totally_ordered_with<_Tp, _Up>
      constexpr bool
      operator()(_Tp&& __t, _Up&& __u) const
      noexcept(noexcept(std::declval<_Up>() < std::declval<_Tp>()))
      { return !less{}(std::forward<_Up>(__u), std::forward<_Tp>(__t)); }

    using is_transparent = __is_transparent;
  };

}


}
# 39 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/iterator_concepts.h" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{
# 58 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/iterator_concepts.h" 3
  struct default_sentinel_t { };


  inline constexpr default_sentinel_t default_sentinel{};


  struct input_iterator_tag;
  struct output_iterator_tag;
  struct forward_iterator_tag;
  struct bidirectional_iterator_tag;
  struct random_access_iterator_tag;
  struct contiguous_iterator_tag;

  template<typename _Iterator>
    struct iterator_traits;

  template<typename _Tp> requires is_object_v<_Tp>
    struct iterator_traits<_Tp*>;

  template<typename _Iterator, typename>
    struct __iterator_traits;

  namespace __detail
  {
    template<typename _Tp>
      using __with_ref = _Tp&;

    template<typename _Tp>
      concept __can_reference = requires { typename __with_ref<_Tp>; };

    template<typename _Tp>
      concept __dereferenceable = requires(_Tp& __t)
 {
   { *__t } -> __can_reference;
 };
  }

  template<__detail::__dereferenceable _Tp>
    using iter_reference_t = decltype(*std::declval<_Tp&>());

  namespace ranges
  {

    namespace __imove
    {
      void iter_move() = delete;

      template<typename _Tp>
 concept __adl_imove
   = (std::__detail::__class_or_enum<remove_reference_t<_Tp>>)
   && requires(_Tp&& __t) { iter_move(static_cast<_Tp&&>(__t)); };

      struct _IterMove
      {
      private:
 template<typename _Tp>
   struct __result
   { using type = iter_reference_t<_Tp>; };

 template<typename _Tp>
   requires __adl_imove<_Tp>
   struct __result<_Tp>
   { using type = decltype(iter_move(std::declval<_Tp>())); };

 template<typename _Tp>
   requires (!__adl_imove<_Tp>)
   && is_lvalue_reference_v<iter_reference_t<_Tp>>
   struct __result<_Tp>
   { using type = remove_reference_t<iter_reference_t<_Tp>>&&; };

 template<typename _Tp>
   static constexpr bool
   _S_noexcept()
   {
     if constexpr (__adl_imove<_Tp>)
       return noexcept(iter_move(std::declval<_Tp>()));
     else
       return noexcept(*std::declval<_Tp>());
   }

      public:

 template<std::__detail::__dereferenceable _Tp>
   using __type = typename __result<_Tp>::type;

 template<std::__detail::__dereferenceable _Tp>
   [[nodiscard]]
   constexpr __type<_Tp>
   operator()(_Tp&& __e) const
   noexcept(_S_noexcept<_Tp>())
   {
     if constexpr (__adl_imove<_Tp>)
       return iter_move(static_cast<_Tp&&>(__e));
     else if constexpr (is_lvalue_reference_v<iter_reference_t<_Tp>>)
       return static_cast<__type<_Tp>>(*__e);
     else
       return *__e;
   }
      };
    }


    inline namespace _Cpo {
      inline constexpr __imove::_IterMove iter_move{};
    }
  }

  template<__detail::__dereferenceable _Tp>
    requires __detail::__can_reference<ranges::__imove::_IterMove::__type<_Tp&>>
    using iter_rvalue_reference_t = ranges::__imove::_IterMove::__type<_Tp&>;

  template<typename> struct incrementable_traits { };

  template<typename _Tp> requires is_object_v<_Tp>
    struct incrementable_traits<_Tp*>
    { using difference_type = ptrdiff_t; };

  template<typename _Iter>
    struct incrementable_traits<const _Iter>
    : incrementable_traits<_Iter> { };

  template<typename _Tp> requires requires { typename _Tp::difference_type; }
    struct incrementable_traits<_Tp>
    { using difference_type = typename _Tp::difference_type; };

  template<typename _Tp>
    requires (!requires { typename _Tp::difference_type; }
       && requires(const _Tp& __a, const _Tp& __b)
       { { __a - __b } -> integral; })
    struct incrementable_traits<_Tp>
    {
      using difference_type
 = make_signed_t<decltype(std::declval<_Tp>() - std::declval<_Tp>())>;
    };
# 204 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/iterator_concepts.h" 3
  namespace __detail
  {


    template<typename _Iter>
      concept __primary_traits_iter
 = __is_base_of(__iterator_traits<_Iter, void>, iterator_traits<_Iter>);

    template<typename _Iter, typename _Tp>
      struct __iter_traits_impl
      { using type = iterator_traits<_Iter>; };

    template<typename _Iter, typename _Tp>
      requires __primary_traits_iter<_Iter>
      struct __iter_traits_impl<_Iter, _Tp>
      { using type = _Tp; };


    template<typename _Iter, typename _Tp = _Iter>
      using __iter_traits = typename __iter_traits_impl<_Iter, _Tp>::type;

    template<typename _Tp>
      using __iter_diff_t = typename
 __iter_traits<_Tp, incrementable_traits<_Tp>>::difference_type;
  }

  template<typename _Tp>
    using iter_difference_t = __detail::__iter_diff_t<remove_cvref_t<_Tp>>;

  namespace __detail
  {
    template<typename> struct __cond_value_type { };

    template<typename _Tp> requires is_object_v<_Tp>
      struct __cond_value_type<_Tp>
      { using value_type = remove_cv_t<_Tp>; };

    template<typename _Tp>
      concept __has_member_value_type
 = requires { typename _Tp::value_type; };

    template<typename _Tp>
      concept __has_member_element_type
 = requires { typename _Tp::element_type; };

  }

  template<typename> struct indirectly_readable_traits { };

  template<typename _Tp>
    struct indirectly_readable_traits<_Tp*>
    : __detail::__cond_value_type<_Tp>
    { };

  template<typename _Iter> requires is_array_v<_Iter>
    struct indirectly_readable_traits<_Iter>
    { using value_type = remove_cv_t<remove_extent_t<_Iter>>; };

  template<typename _Iter>
    struct indirectly_readable_traits<const _Iter>
    : indirectly_readable_traits<_Iter>
    { };

  template<__detail::__has_member_value_type _Tp>
    struct indirectly_readable_traits<_Tp>
    : __detail::__cond_value_type<typename _Tp::value_type>
    { };

  template<__detail::__has_member_element_type _Tp>
    struct indirectly_readable_traits<_Tp>
    : __detail::__cond_value_type<typename _Tp::element_type>
    { };



  template<__detail::__has_member_value_type _Tp>
    requires __detail::__has_member_element_type<_Tp>
    && same_as<remove_cv_t<typename _Tp::element_type>,
        remove_cv_t<typename _Tp::value_type>>
    struct indirectly_readable_traits<_Tp>
    : __detail::__cond_value_type<typename _Tp::value_type>
    { };



  template<__detail::__has_member_value_type _Tp>
    requires __detail::__has_member_element_type<_Tp>
    struct indirectly_readable_traits<_Tp>
    { };

  namespace __detail
  {
    template<typename _Tp>
      using __iter_value_t = typename
 __iter_traits<_Tp, indirectly_readable_traits<_Tp>>::value_type;
  }

  template<typename _Tp>
    using iter_value_t = __detail::__iter_value_t<remove_cvref_t<_Tp>>;

  namespace __detail
  {


    template<typename _Iter>
      concept __cpp17_iterator = requires(_Iter __it)
 {
   { *__it } -> __can_reference;
   { ++__it } -> same_as<_Iter&>;
   { *__it++ } -> __can_reference;
 } && copyable<_Iter>;

    template<typename _Iter>
      concept __cpp17_input_iterator = __cpp17_iterator<_Iter>
 && equality_comparable<_Iter>
 && requires(_Iter __it)
 {
   typename incrementable_traits<_Iter>::difference_type;
   typename indirectly_readable_traits<_Iter>::value_type;
   typename common_reference_t<iter_reference_t<_Iter>&&,
     typename indirectly_readable_traits<_Iter>::value_type&>;
   typename common_reference_t<decltype(*__it++)&&,
     typename indirectly_readable_traits<_Iter>::value_type&>;
   requires signed_integral<
     typename incrementable_traits<_Iter>::difference_type>;
 };

    template<typename _Iter>
      concept __cpp17_fwd_iterator = __cpp17_input_iterator<_Iter>
 && constructible_from<_Iter>
 && is_lvalue_reference_v<iter_reference_t<_Iter>>
 && same_as<remove_cvref_t<iter_reference_t<_Iter>>,
     typename indirectly_readable_traits<_Iter>::value_type>
 && requires(_Iter __it)
 {
   { __it++ } -> convertible_to<const _Iter&>;
   { *__it++ } -> same_as<iter_reference_t<_Iter>>;
 };

    template<typename _Iter>
      concept __cpp17_bidi_iterator = __cpp17_fwd_iterator<_Iter>
 && requires(_Iter __it)
 {
   { --__it } -> same_as<_Iter&>;
   { __it-- } -> convertible_to<const _Iter&>;
   { *__it-- } -> same_as<iter_reference_t<_Iter>>;
 };

    template<typename _Iter>
      concept __cpp17_randacc_iterator = __cpp17_bidi_iterator<_Iter>
 && totally_ordered<_Iter>
 && requires(_Iter __it,
      typename incrementable_traits<_Iter>::difference_type __n)
 {
   { __it += __n } -> same_as<_Iter&>;
   { __it -= __n } -> same_as<_Iter&>;
   { __it + __n } -> same_as<_Iter>;
   { __n + __it } -> same_as<_Iter>;
   { __it - __n } -> same_as<_Iter>;
   { __it - __it } -> same_as<decltype(__n)>;
   { __it[__n] } -> convertible_to<iter_reference_t<_Iter>>;
 };

    template<typename _Iter>
      concept __iter_with_nested_types = requires {
 typename _Iter::iterator_category;
 typename _Iter::value_type;
 typename _Iter::difference_type;
 typename _Iter::reference;
      };

    template<typename _Iter>
      concept __iter_without_nested_types = !__iter_with_nested_types<_Iter>;

    template<typename _Iter>
      concept __iter_without_category
 = !requires { typename _Iter::iterator_category; };

  }

  template<typename _Iterator>
    requires __detail::__iter_with_nested_types<_Iterator>
    struct __iterator_traits<_Iterator, void>
    {
    private:
      template<typename _Iter>
 struct __ptr
 { using type = void; };

      template<typename _Iter> requires requires { typename _Iter::pointer; }
 struct __ptr<_Iter>
 { using type = typename _Iter::pointer; };

    public:
      using iterator_category = typename _Iterator::iterator_category;
      using value_type = typename _Iterator::value_type;
      using difference_type = typename _Iterator::difference_type;
      using pointer = typename __ptr<_Iterator>::type;
      using reference = typename _Iterator::reference;
    };

  template<typename _Iterator>
    requires __detail::__iter_without_nested_types<_Iterator>
       && __detail::__cpp17_input_iterator<_Iterator>
    struct __iterator_traits<_Iterator, void>
    {
    private:
      template<typename _Iter>
 struct __cat
 { using type = input_iterator_tag; };

      template<typename _Iter>
 requires requires { typename _Iter::iterator_category; }
 struct __cat<_Iter>
 { using type = typename _Iter::iterator_category; };

      template<typename _Iter>
 requires __detail::__iter_without_category<_Iter>
    && __detail::__cpp17_randacc_iterator<_Iter>
 struct __cat<_Iter>
 { using type = random_access_iterator_tag; };

      template<typename _Iter>
 requires __detail::__iter_without_category<_Iter>
    && __detail::__cpp17_bidi_iterator<_Iter>
 struct __cat<_Iter>
 { using type = bidirectional_iterator_tag; };

      template<typename _Iter>
 requires __detail::__iter_without_category<_Iter>
    && __detail::__cpp17_fwd_iterator<_Iter>
 struct __cat<_Iter>
 { using type = forward_iterator_tag; };

      template<typename _Iter>
 struct __ptr
 { using type = void; };

      template<typename _Iter> requires requires { typename _Iter::pointer; }
 struct __ptr<_Iter>
 { using type = typename _Iter::pointer; };

      template<typename _Iter>
 requires (!requires { typename _Iter::pointer; }
     && requires(_Iter& __it) { __it.operator->(); })
 struct __ptr<_Iter>
 { using type = decltype(std::declval<_Iter&>().operator->()); };

      template<typename _Iter>
 struct __ref
 { using type = iter_reference_t<_Iter>; };

      template<typename _Iter> requires requires { typename _Iter::reference; }
 struct __ref<_Iter>
 { using type = typename _Iter::reference; };

    public:
      using iterator_category = typename __cat<_Iterator>::type;
      using value_type
 = typename indirectly_readable_traits<_Iterator>::value_type;
      using difference_type
 = typename incrementable_traits<_Iterator>::difference_type;
      using pointer = typename __ptr<_Iterator>::type;
      using reference = typename __ref<_Iterator>::type;
    };

  template<typename _Iterator>
    requires __detail::__iter_without_nested_types<_Iterator>
       && __detail::__cpp17_iterator<_Iterator>
    struct __iterator_traits<_Iterator, void>
    {
    private:
      template<typename _Iter>
 struct __diff
 { using type = void; };

      template<typename _Iter>
 requires requires
 { typename incrementable_traits<_Iter>::difference_type; }
 struct __diff<_Iter>
 {
   using type = typename incrementable_traits<_Iter>::difference_type;
 };

    public:
      using iterator_category = output_iterator_tag;
      using value_type = void;
      using difference_type = typename __diff<_Iterator>::type;
      using pointer = void;
      using reference = void;
    };

  namespace __detail
  {
    template<typename _Iter>
      struct __iter_concept_impl;


    template<typename _Iter>
      requires requires { typename __iter_traits<_Iter>::iterator_concept; }
      struct __iter_concept_impl<_Iter>
      { using type = typename __iter_traits<_Iter>::iterator_concept; };


    template<typename _Iter>
      requires (!requires { typename __iter_traits<_Iter>::iterator_concept; }
   && requires { typename __iter_traits<_Iter>::iterator_category; })
      struct __iter_concept_impl<_Iter>
      { using type = typename __iter_traits<_Iter>::iterator_category; };


    template<typename _Iter>
      requires (!requires { typename __iter_traits<_Iter>::iterator_concept; }
   && !requires { typename __iter_traits<_Iter>::iterator_category; }
   && __primary_traits_iter<_Iter>)
      struct __iter_concept_impl<_Iter>
      { using type = random_access_iterator_tag; };


    template<typename _Iter>
      struct __iter_concept_impl
      { };


    template<typename _Iter>
      using __iter_concept = typename __iter_concept_impl<_Iter>::type;

  template<typename _In>
    concept __indirectly_readable_impl = requires
      {
 typename iter_value_t<_In>;
 typename iter_reference_t<_In>;
 typename iter_rvalue_reference_t<_In>;
 requires same_as<iter_reference_t<const _In>,
    iter_reference_t<_In>>;
 requires same_as<iter_rvalue_reference_t<const _In>,
    iter_rvalue_reference_t<_In>>;
      }
      && common_reference_with<iter_reference_t<_In>&&, iter_value_t<_In>&>
      && common_reference_with<iter_reference_t<_In>&&,
         iter_rvalue_reference_t<_In>&&>
      && common_reference_with<iter_rvalue_reference_t<_In>&&,
          const iter_value_t<_In>&>;

  }


  template<typename _In>
    concept indirectly_readable
      = __detail::__indirectly_readable_impl<remove_cvref_t<_In>>;

  template<indirectly_readable _Tp>
    using iter_common_reference_t
      = common_reference_t<iter_reference_t<_Tp>, iter_value_t<_Tp>&>;


  template<typename _Out, typename _Tp>
    concept indirectly_writable = requires(_Out&& __o, _Tp&& __t)
      {
 *__o = std::forward<_Tp>(__t);
 *std::forward<_Out>(__o) = std::forward<_Tp>(__t);
 const_cast<const iter_reference_t<_Out>&&>(*__o)
   = std::forward<_Tp>(__t);
 const_cast<const iter_reference_t<_Out>&&>(*std::forward<_Out>(__o))
   = std::forward<_Tp>(__t);
      };

  namespace ranges::__detail
  {
    class __max_diff_type;
    class __max_size_type;

    __extension__
    template<typename _Tp>
      concept __is_signed_int128

 = same_as<_Tp, __int128>;




    __extension__
    template<typename _Tp>
      concept __is_unsigned_int128

 = same_as<_Tp, unsigned __int128>;




    template<typename _Tp>
      concept __cv_bool = same_as<const volatile _Tp, const volatile bool>;

    template<typename _Tp>
      concept __integral_nonbool = integral<_Tp> && !__cv_bool<_Tp>;

    template<typename _Tp>
      concept __is_int128 = __is_signed_int128<_Tp> || __is_unsigned_int128<_Tp>;

    template<typename _Tp>
      concept __is_integer_like = __integral_nonbool<_Tp>
 || __is_int128<_Tp>
 || same_as<_Tp, __max_diff_type> || same_as<_Tp, __max_size_type>;

    template<typename _Tp>
      concept __is_signed_integer_like = signed_integral<_Tp>
 || __is_signed_int128<_Tp>
 || same_as<_Tp, __max_diff_type>;

  }

  namespace __detail { using ranges::__detail::__is_signed_integer_like; }


  template<typename _Iter>
    concept weakly_incrementable = movable<_Iter>
      && requires(_Iter __i)
      {
 typename iter_difference_t<_Iter>;
 requires __detail::__is_signed_integer_like<iter_difference_t<_Iter>>;
 { ++__i } -> same_as<_Iter&>;
 __i++;
      };

  template<typename _Iter>
    concept incrementable = regular<_Iter> && weakly_incrementable<_Iter>
      && requires(_Iter __i) { { __i++ } -> same_as<_Iter>; };

  template<typename _Iter>
    concept input_or_output_iterator
      = requires(_Iter __i) { { *__i } -> __detail::__can_reference; }
 && weakly_incrementable<_Iter>;

  template<typename _Sent, typename _Iter>
    concept sentinel_for = semiregular<_Sent>
      && input_or_output_iterator<_Iter>
      && __detail::__weakly_eq_cmp_with<_Sent, _Iter>;

  template<typename _Sent, typename _Iter>
    inline constexpr bool disable_sized_sentinel_for = false;

  template<typename _Sent, typename _Iter>
    concept sized_sentinel_for = sentinel_for<_Sent, _Iter>
    && !disable_sized_sentinel_for<remove_cv_t<_Sent>, remove_cv_t<_Iter>>
    && requires(const _Iter& __i, const _Sent& __s)
    {
      { __s - __i } -> same_as<iter_difference_t<_Iter>>;
      { __i - __s } -> same_as<iter_difference_t<_Iter>>;
    };

  template<typename _Iter>
    concept input_iterator = input_or_output_iterator<_Iter>
      && indirectly_readable<_Iter>
      && requires { typename __detail::__iter_concept<_Iter>; }
      && derived_from<__detail::__iter_concept<_Iter>, input_iterator_tag>;

  template<typename _Iter, typename _Tp>
    concept output_iterator = input_or_output_iterator<_Iter>
      && indirectly_writable<_Iter, _Tp>
      && requires(_Iter __i, _Tp&& __t) { *__i++ = std::forward<_Tp>(__t); };

  template<typename _Iter>
    concept forward_iterator = input_iterator<_Iter>
      && derived_from<__detail::__iter_concept<_Iter>, forward_iterator_tag>
      && incrementable<_Iter> && sentinel_for<_Iter, _Iter>;

  template<typename _Iter>
    concept bidirectional_iterator = forward_iterator<_Iter>
      && derived_from<__detail::__iter_concept<_Iter>,
        bidirectional_iterator_tag>
      && requires(_Iter __i)
      {
 { --__i } -> same_as<_Iter&>;
 { __i-- } -> same_as<_Iter>;
      };

  template<typename _Iter>
    concept random_access_iterator = bidirectional_iterator<_Iter>
      && derived_from<__detail::__iter_concept<_Iter>,
        random_access_iterator_tag>
      && totally_ordered<_Iter> && sized_sentinel_for<_Iter, _Iter>
      && requires(_Iter __i, const _Iter __j,
    const iter_difference_t<_Iter> __n)
      {
 { __i += __n } -> same_as<_Iter&>;
 { __j + __n } -> same_as<_Iter>;
 { __n + __j } -> same_as<_Iter>;
 { __i -= __n } -> same_as<_Iter&>;
 { __j - __n } -> same_as<_Iter>;
 { __j[__n] } -> same_as<iter_reference_t<_Iter>>;
      };

  template<typename _Iter>
    concept contiguous_iterator = random_access_iterator<_Iter>
      && derived_from<__detail::__iter_concept<_Iter>, contiguous_iterator_tag>
      && is_lvalue_reference_v<iter_reference_t<_Iter>>
      && same_as<iter_value_t<_Iter>, remove_cvref_t<iter_reference_t<_Iter>>>
      && requires(const _Iter& __i)
      {
 { std::to_address(__i) }
   -> same_as<add_pointer_t<iter_reference_t<_Iter>>>;
      };





  template<typename _Fn, typename _Iter>
    concept indirectly_unary_invocable = indirectly_readable<_Iter>
      && copy_constructible<_Fn> && invocable<_Fn&, iter_value_t<_Iter>&>
      && invocable<_Fn&, iter_reference_t<_Iter>>
      && invocable<_Fn&, iter_common_reference_t<_Iter>>
      && common_reference_with<invoke_result_t<_Fn&, iter_value_t<_Iter>&>,
          invoke_result_t<_Fn&, iter_reference_t<_Iter>>>;

  template<typename _Fn, typename _Iter>
    concept indirectly_regular_unary_invocable = indirectly_readable<_Iter>
      && copy_constructible<_Fn>
      && regular_invocable<_Fn&, iter_value_t<_Iter>&>
      && regular_invocable<_Fn&, iter_reference_t<_Iter>>
      && regular_invocable<_Fn&, iter_common_reference_t<_Iter>>
      && common_reference_with<invoke_result_t<_Fn&, iter_value_t<_Iter>&>,
          invoke_result_t<_Fn&, iter_reference_t<_Iter>>>;

  template<typename _Fn, typename _Iter>
    concept indirect_unary_predicate = indirectly_readable<_Iter>
      && copy_constructible<_Fn> && predicate<_Fn&, iter_value_t<_Iter>&>
      && predicate<_Fn&, iter_reference_t<_Iter>>
      && predicate<_Fn&, iter_common_reference_t<_Iter>>;

  template<typename _Fn, typename _I1, typename _I2>
    concept indirect_binary_predicate
      = indirectly_readable<_I1> && indirectly_readable<_I2>
      && copy_constructible<_Fn>
      && predicate<_Fn&, iter_value_t<_I1>&, iter_value_t<_I2>&>
      && predicate<_Fn&, iter_value_t<_I1>&, iter_reference_t<_I2>>
      && predicate<_Fn&, iter_reference_t<_I1>, iter_value_t<_I2>&>
      && predicate<_Fn&, iter_reference_t<_I1>, iter_reference_t<_I2>>
      && predicate<_Fn&, iter_common_reference_t<_I1>,
     iter_common_reference_t<_I2>>;

  template<typename _Fn, typename _I1, typename _I2 = _I1>
    concept indirect_equivalence_relation
      = indirectly_readable<_I1> && indirectly_readable<_I2>
      && copy_constructible<_Fn>
      && equivalence_relation<_Fn&, iter_value_t<_I1>&, iter_value_t<_I2>&>
      && equivalence_relation<_Fn&, iter_value_t<_I1>&, iter_reference_t<_I2>>
      && equivalence_relation<_Fn&, iter_reference_t<_I1>, iter_value_t<_I2>&>
      && equivalence_relation<_Fn&, iter_reference_t<_I1>,
         iter_reference_t<_I2>>
      && equivalence_relation<_Fn&, iter_common_reference_t<_I1>,
         iter_common_reference_t<_I2>>;

  template<typename _Fn, typename _I1, typename _I2 = _I1>
    concept indirect_strict_weak_order
      = indirectly_readable<_I1> && indirectly_readable<_I2>
      && copy_constructible<_Fn>
      && strict_weak_order<_Fn&, iter_value_t<_I1>&, iter_value_t<_I2>&>
      && strict_weak_order<_Fn&, iter_value_t<_I1>&, iter_reference_t<_I2>>
      && strict_weak_order<_Fn&, iter_reference_t<_I1>, iter_value_t<_I2>&>
      && strict_weak_order<_Fn&, iter_reference_t<_I1>, iter_reference_t<_I2>>
      && strict_weak_order<_Fn&, iter_common_reference_t<_I1>,
      iter_common_reference_t<_I2>>;

  template<typename _Fn, typename... _Is>
    requires (indirectly_readable<_Is> && ...)
      && invocable<_Fn, iter_reference_t<_Is>...>
    using indirect_result_t = invoke_result_t<_Fn, iter_reference_t<_Is>...>;

  namespace __detail
  {
    template<typename _Iter, typename _Proj>
      struct __projected
      {
 struct __type
 {
   using value_type = remove_cvref_t<indirect_result_t<_Proj&, _Iter>>;
   indirect_result_t<_Proj&, _Iter> operator*() const;
 };
      };

    template<weakly_incrementable _Iter, typename _Proj>
      struct __projected<_Iter, _Proj>
      {
 struct __type
 {
   using value_type = remove_cvref_t<indirect_result_t<_Proj&, _Iter>>;
   using difference_type = iter_difference_t<_Iter>;
   indirect_result_t<_Proj&, _Iter> operator*() const;
 };
      };
  }


  template<indirectly_readable _Iter,
    indirectly_regular_unary_invocable<_Iter> _Proj>
    using projected = typename __detail::__projected<_Iter, _Proj>::__type;





  template<typename _In, typename _Out>
    concept indirectly_movable = indirectly_readable<_In>
      && indirectly_writable<_Out, iter_rvalue_reference_t<_In>>;

  template<typename _In, typename _Out>
    concept indirectly_movable_storable = indirectly_movable<_In, _Out>
      && indirectly_writable<_Out, iter_value_t<_In>>
      && movable<iter_value_t<_In>>
      && constructible_from<iter_value_t<_In>, iter_rvalue_reference_t<_In>>
      && assignable_from<iter_value_t<_In>&, iter_rvalue_reference_t<_In>>;


  template<typename _In, typename _Out>
    concept indirectly_copyable = indirectly_readable<_In>
      && indirectly_writable<_Out, iter_reference_t<_In>>;

  template<typename _In, typename _Out>
    concept indirectly_copyable_storable = indirectly_copyable<_In, _Out>
      && indirectly_writable<_Out, iter_value_t<_In>&>
      && indirectly_writable<_Out, const iter_value_t<_In>&>
      && indirectly_writable<_Out, iter_value_t<_In>&&>
      && indirectly_writable<_Out, const iter_value_t<_In>&&>
      && copyable<iter_value_t<_In>>
      && constructible_from<iter_value_t<_In>, iter_reference_t<_In>>
      && assignable_from<iter_value_t<_In>&, iter_reference_t<_In>>;

namespace ranges
{

  namespace __iswap
  {
    template<typename _It1, typename _It2>
      void iter_swap(_It1, _It2) = delete;

    template<typename _Tp, typename _Up>
      concept __adl_iswap
 = (std::__detail::__class_or_enum<remove_reference_t<_Tp>>
   || std::__detail::__class_or_enum<remove_reference_t<_Up>>)
 && requires(_Tp&& __t, _Up&& __u) {
   iter_swap(static_cast<_Tp&&>(__t), static_cast<_Up&&>(__u));
 };

    template<typename _Xp, typename _Yp>
      constexpr iter_value_t<_Xp>
      __iter_exchange_move(_Xp&& __x, _Yp&& __y)
      noexcept(noexcept(iter_value_t<_Xp>(iter_move(__x)))
        && noexcept(*__x = iter_move(__y)))
      {
 iter_value_t<_Xp> __old_value(iter_move(__x));
 *__x = iter_move(__y);
 return __old_value;
      }

    struct _IterSwap
    {
    private:
      template<typename _Tp, typename _Up>
 static constexpr bool
 _S_noexcept()
 {
   if constexpr (__adl_iswap<_Tp, _Up>)
     return noexcept(iter_swap(std::declval<_Tp>(),
          std::declval<_Up>()));
   else if constexpr (indirectly_readable<_Tp>
       && indirectly_readable<_Up>
       && swappable_with<iter_reference_t<_Tp>, iter_reference_t<_Up>>)
     return noexcept(ranges::swap(*std::declval<_Tp>(),
      *std::declval<_Up>()));
   else
     return noexcept(*std::declval<_Tp>()
  = __iswap::__iter_exchange_move(std::declval<_Up>(),
          std::declval<_Tp>()));
 }

    public:
      template<typename _Tp, typename _Up>
 requires __adl_iswap<_Tp, _Up>
 || (indirectly_readable<remove_reference_t<_Tp>>
     && indirectly_readable<remove_reference_t<_Up>>
     && swappable_with<iter_reference_t<_Tp>, iter_reference_t<_Up>>)
 || (indirectly_movable_storable<_Tp, _Up>
     && indirectly_movable_storable<_Up, _Tp>)
 constexpr void
 operator()(_Tp&& __e1, _Up&& __e2) const
 noexcept(_S_noexcept<_Tp, _Up>())
 {
   if constexpr (__adl_iswap<_Tp, _Up>)
     iter_swap(static_cast<_Tp&&>(__e1), static_cast<_Up&&>(__e2));
   else if constexpr (indirectly_readable<_Tp>
       && indirectly_readable<_Up>
       && swappable_with<iter_reference_t<_Tp>, iter_reference_t<_Up>>)
     ranges::swap(*__e1, *__e2);
   else
     *__e1 = __iswap::__iter_exchange_move(__e2, __e1);
 }
    };
  }


  inline namespace _Cpo {
    inline constexpr __iswap::_IterSwap iter_swap{};
  }

}


  template<typename _I1, typename _I2 = _I1>
    concept indirectly_swappable
      = indirectly_readable<_I1> && indirectly_readable<_I2>
      && requires(const _I1 __i1, const _I2 __i2)
      {
 ranges::iter_swap(__i1, __i1);
 ranges::iter_swap(__i2, __i2);
 ranges::iter_swap(__i1, __i2);
 ranges::iter_swap(__i2, __i1);
      };


  template<typename _I1, typename _I2, typename _Rel, typename _P1 = identity,
    typename _P2 = identity>
    concept indirectly_comparable
      = indirect_binary_predicate<_Rel, projected<_I1, _P1>,
      projected<_I2, _P2>>;


  template<typename _Iter>
    concept permutable = forward_iterator<_Iter>
      && indirectly_movable_storable<_Iter, _Iter>
      && indirectly_swappable<_Iter, _Iter>;


  template<typename _I1, typename _I2, typename _Out,
    typename _Rel = ranges::less, typename _P1 = identity,
    typename _P2 = identity>
    concept mergeable = input_iterator<_I1> && input_iterator<_I2>
      && weakly_incrementable<_Out> && indirectly_copyable<_I1, _Out>
      && indirectly_copyable<_I2, _Out>
      && indirect_strict_weak_order<_Rel, projected<_I1, _P1>,
        projected<_I2, _P2>>;


  template<typename _Iter, typename _Rel = ranges::less,
    typename _Proj = identity>
    concept sortable = permutable<_Iter>
      && indirect_strict_weak_order<_Rel, projected<_Iter, _Proj>>;

  struct unreachable_sentinel_t
  {
    template<weakly_incrementable _It>
      friend constexpr bool
      operator==(unreachable_sentinel_t, const _It&) noexcept
      { return false; }
  };

  inline constexpr unreachable_sentinel_t unreachable_sentinel{};


  namespace ranges::__access
  {
    using std::__detail::__class_or_enum;

    struct _Decay_copy final
    {
      template<typename _Tp>
 constexpr decay_t<_Tp>
 operator()(_Tp&& __t) const
 noexcept(is_nothrow_convertible_v<_Tp, decay_t<_Tp>>)
 { return std::forward<_Tp>(__t); }
    } inline constexpr __decay_copy{};

    template<typename _Tp>
      concept __member_begin = requires(_Tp& __t)
 {
   { __decay_copy(__t.begin()) } -> input_or_output_iterator;
 };


    void begin() = delete;

    template<typename _Tp>
      concept __adl_begin = __class_or_enum<remove_reference_t<_Tp>>
 && requires(_Tp& __t)
 {
   { __decay_copy(begin(__t)) } -> input_or_output_iterator;
 };



    template<typename _Tp>
      requires is_array_v<_Tp> || __member_begin<_Tp&> || __adl_begin<_Tp&>
      auto
      __begin(_Tp& __t)
      {
 if constexpr (is_array_v<_Tp>)
   return __t + 0;
 else if constexpr (__member_begin<_Tp&>)
   return __t.begin();
 else
   return begin(__t);
      }
  }

  namespace __detail
  {

    template<typename _Tp>
      using __range_iter_t
 = decltype(ranges::__access::__begin(std::declval<_Tp&>()));

  }



}
# 72 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_iterator_base_types.h" 2 3


namespace std __attribute__ ((__visibility__ ("default")))
{
# 93 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_iterator_base_types.h" 3
  template<typename _Category, typename _Tp, typename _Distance = ptrdiff_t,
           typename _Pointer = _Tp*, typename _Reference = _Tp&>
    struct [[__deprecated__]] iterator
    {

      typedef _Category iterator_category;

      typedef _Tp value_type;

      typedef _Distance difference_type;

      typedef _Pointer pointer;

      typedef _Reference reference;
    };
# 149 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_iterator_base_types.h" 3
  template<typename _Iterator>
    struct iterator_traits;




  template<typename _Iterator, typename = __void_t<>>
    struct __iterator_traits { };
# 176 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_iterator_base_types.h" 3
  template<typename _Iterator>
    struct iterator_traits
    : public __iterator_traits<_Iterator> { };
# 194 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_iterator_base_types.h" 3
  template<typename _Tp>

    requires is_object_v<_Tp>

    struct iterator_traits<_Tp*>
    {
      using iterator_concept = contiguous_iterator_tag;
      using iterator_category = random_access_iterator_tag;
      using value_type = remove_cv_t<_Tp>;
      using difference_type = ptrdiff_t;
      using pointer = _Tp*;
      using reference = _Tp&;
    };
# 235 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_iterator_base_types.h" 3
  template<typename _Iter>
    __attribute__((__always_inline__))
    inline constexpr
    typename iterator_traits<_Iter>::iterator_category
    __iterator_category(const _Iter&)
    { return typename iterator_traits<_Iter>::iterator_category(); }




  template<typename _Iter>
    using __iter_category_t
      = typename iterator_traits<_Iter>::iterator_category;

  template<typename _InIter>
    using _RequireInputIter =
      __enable_if_t<is_convertible<__iter_category_t<_InIter>,
       input_iterator_tag>::value>;

  template<typename _It,
    typename _Cat = __iter_category_t<_It>>
    struct __is_random_access_iter
      : is_base_of<random_access_iterator_tag, _Cat>
    {
      typedef is_base_of<random_access_iterator_tag, _Cat> _Base;
      enum { __value = _Base::value };
    };
# 270 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_iterator_base_types.h" 3
}
# 65 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_iterator.h" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ext/type_traits.h" 1 3
# 33 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ext/type_traits.h" 3




extern "C++" {

namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{



  template<bool, typename>
    struct __enable_if
    { };

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



  template<bool _Cond, typename _Iftrue, typename _Iffalse>
    struct __conditional_type
    { typedef _Iftrue __type; };

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



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

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

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

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

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

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

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

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


  template<>
    struct __add_unsigned<bool>;

  template<>
    struct __add_unsigned<wchar_t>;



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

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

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

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

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

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

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

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


  template<>
    struct __remove_unsigned<bool>;

  template<>
    struct __remove_unsigned<wchar_t>;



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

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


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




  template<typename _Tp, bool = std::__is_integer<_Tp>::__value>
    struct __promote
    { typedef double __type; };




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

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

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

  template<>
    struct __promote<float>
    { typedef float __type; };
# 225 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ext/type_traits.h" 3
  template<typename... _Tp>
    using __promoted_t = decltype((typename __promote<_Tp>::__type(0) + ...));



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

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

  template<typename _Tp, typename _Up, typename _Vp, typename _Wp>
    using __promote_4 = __promote<__promoted_t<_Tp, _Up, _Vp, _Wp>>;
# 270 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ext/type_traits.h" 3
}
}
# 66 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_iterator.h" 2 3
# 75 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_iterator.h" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/new" 1 3
# 39 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/new" 3


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/exception.h" 1 3
# 35 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/exception.h" 3



extern "C++" {

namespace std __attribute__ ((__visibility__ ("default")))
{
# 59 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/exception.h" 3
  class exception
  {
  public:
    exception() noexcept { }
    virtual ~exception() noexcept;

    exception(const exception&) = default;
    exception& operator=(const exception&) = default;
    exception(exception&&) = default;
    exception& operator=(exception&&) = default;




    virtual const char*
    what() const noexcept;
  };



}

}
# 42 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/new" 2 3




# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 47 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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;

}
# 131 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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__));






[[__nodiscard__]] void* operator new(std::size_t, const std::nothrow_t&) noexcept
  __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__));
[[__nodiscard__]] void* operator new[](std::size_t, const std::nothrow_t&) noexcept
  __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__));
void operator delete(void*, const std::nothrow_t&) noexcept
  __attribute__((__externally_visible__));
void operator delete[](void*, const std::nothrow_t&) noexcept
  __attribute__((__externally_visible__));

[[__nodiscard__]] void* operator new(std::size_t, std::align_val_t)
  __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__));
[[__nodiscard__]] void* operator new(std::size_t, std::align_val_t, const std::nothrow_t&)
  noexcept __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__));
void operator delete(void*, std::align_val_t)
  noexcept __attribute__((__externally_visible__));
void operator delete(void*, std::align_val_t, const std::nothrow_t&)
  noexcept __attribute__((__externally_visible__));
[[__nodiscard__]] void* operator new[](std::size_t, std::align_val_t)
  __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__));
[[__nodiscard__]] void* operator new[](std::size_t, std::align_val_t, const std::nothrow_t&)
  noexcept __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__));
void operator delete[](void*, std::align_val_t)
  noexcept __attribute__((__externally_visible__));
void operator delete[](void*, std::align_val_t, const std::nothrow_t&)
  noexcept __attribute__((__externally_visible__));
# 179 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/new" 3
[[__nodiscard__]] inline void* operator new(std::size_t, void* __p) noexcept
{ return __p; }
[[__nodiscard__]] inline void* operator new[](std::size_t, void* __p) noexcept
{ return __p; }


inline void operator delete (void*, void*) noexcept { }
inline void operator delete[](void*, void*) noexcept { }

}


namespace std
{


  template<typename _Tp>
    [[nodiscard]] constexpr _Tp*
    launder(_Tp* __p) noexcept
    { return __builtin_launder(__p); }




  template<typename _Ret, typename... _Args , bool _NE>
    void launder(_Ret (*)(_Args...) noexcept (_NE)) = delete;
  template<typename _Ret, typename... _Args , bool _NE>
    void launder(_Ret (*)(_Args......) noexcept (_NE)) = delete;

  void launder(void*) = delete;
  void launder(const void*) = delete;
  void launder(volatile void*) = delete;
  void launder(const volatile void*) = delete;






}




namespace std
{


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

  inline constexpr destroying_delete_t destroying_delete{};
}


#pragma GCC visibility pop
# 76 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_iterator.h" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/exception_defines.h" 1 3
# 77 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_iterator.h" 2 3

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_construct.h" 1 3
# 62 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_construct.h" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_iterator_base_funcs.h" 1 3
# 63 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_iterator_base_funcs.h" 3

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/concept_check.h" 1 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/concept_check.h" 3
# 65 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_iterator_base_funcs.h" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/debug/assertions.h" 1 3
# 66 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_iterator_base_funcs.h" 2 3


namespace std __attribute__ ((__visibility__ ("default")))
{




  template <typename> struct _List_iterator;
  template <typename> struct _List_const_iterator;


  template<typename _InputIterator>
    inline constexpr
    typename iterator_traits<_InputIterator>::difference_type
    __distance(_InputIterator __first, _InputIterator __last,
               input_iterator_tag)
    {



      typename iterator_traits<_InputIterator>::difference_type __n = 0;
      while (__first != __last)
 {
   ++__first;
   ++__n;
 }
      return __n;
    }

  template<typename _RandomAccessIterator>
    __attribute__((__always_inline__))
    inline constexpr
    typename iterator_traits<_RandomAccessIterator>::difference_type
    __distance(_RandomAccessIterator __first, _RandomAccessIterator __last,
               random_access_iterator_tag)
    {



      return __last - __first;
    }



  template<typename _Tp>
    ptrdiff_t
    __distance(std::_List_iterator<_Tp>,
        std::_List_iterator<_Tp>,
        input_iterator_tag);

  template<typename _Tp>
    ptrdiff_t
    __distance(std::_List_const_iterator<_Tp>,
        std::_List_const_iterator<_Tp>,
        input_iterator_tag);




  template<typename _OutputIterator>
    void
    __distance(_OutputIterator, _OutputIterator, output_iterator_tag) = delete;
# 144 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_iterator_base_funcs.h" 3
  template<typename _InputIterator>
    [[__nodiscard__]] __attribute__((__always_inline__))
    inline constexpr
    typename iterator_traits<_InputIterator>::difference_type
    distance(_InputIterator __first, _InputIterator __last)
    {

      return std::__distance(__first, __last,
        std::__iterator_category(__first));
    }

  template<typename _InputIterator, typename _Distance>
    inline constexpr void
    __advance(_InputIterator& __i, _Distance __n, input_iterator_tag)
    {


      do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__n >= 0), false)) std::__glibcxx_assert_fail(); } while (false);
      while (__n--)
 ++__i;
    }

  template<typename _BidirectionalIterator, typename _Distance>
    inline constexpr void
    __advance(_BidirectionalIterator& __i, _Distance __n,
       bidirectional_iterator_tag)
    {



      if (__n > 0)
        while (__n--)
   ++__i;
      else
        while (__n++)
   --__i;
    }

  template<typename _RandomAccessIterator, typename _Distance>
    inline constexpr void
    __advance(_RandomAccessIterator& __i, _Distance __n,
              random_access_iterator_tag)
    {



      if (__builtin_constant_p(__n) && __n == 1)
 ++__i;
      else if (__builtin_constant_p(__n) && __n == -1)
 --__i;
      else
 __i += __n;
    }



  template<typename _OutputIterator, typename _Distance>
    void
    __advance(_OutputIterator&, _Distance, output_iterator_tag) = delete;
# 217 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_iterator_base_funcs.h" 3
  template<typename _InputIterator, typename _Distance>
    __attribute__((__always_inline__))
    inline constexpr void
    advance(_InputIterator& __i, _Distance __n)
    {

      typename iterator_traits<_InputIterator>::difference_type __d = __n;
      std::__advance(__i, __d, std::__iterator_category(__i));
    }



  template<typename _InputIterator>
    [[__nodiscard__]] [[__gnu__::__always_inline__]]
    inline constexpr _InputIterator
    next(_InputIterator __x, typename
  iterator_traits<_InputIterator>::difference_type __n = 1)
    {


      std::advance(__x, __n);
      return __x;
    }

  template<typename _BidirectionalIterator>
    [[__nodiscard__]] [[__gnu__::__always_inline__]]
    inline constexpr _BidirectionalIterator
    prev(_BidirectionalIterator __x, typename
  iterator_traits<_BidirectionalIterator>::difference_type __n = 1)
    {



      std::advance(__x, -__n);
      return __x;
    }




}
# 63 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_construct.h" 2 3
# 73 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_construct.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{



  template <typename _Tp>
    constexpr inline void
    destroy_at(_Tp* __location)
    {
      if constexpr (202302L > 201703L && is_array_v<_Tp>)
 {
   for (auto& __x : *__location)
     std::destroy_at(std::__addressof(__x));
 }
      else
 __location->~_Tp();
    }


  template<typename _Tp, typename... _Args>
    constexpr auto
    construct_at(_Tp* __location, _Args&&... __args)
    noexcept(noexcept(::new((void*)0) _Tp(std::declval<_Args>()...)))
    -> decltype(::new((void*)0) _Tp(std::declval<_Args>()...))
    { return ::new((void*)__location) _Tp(std::forward<_Args>(__args)...); }
# 106 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_construct.h" 3
  template<typename _Tp, typename... _Args>
    constexpr
    inline void
    _Construct(_Tp* __p, _Args&&... __args)
    {

      if (std::__is_constant_evaluated())
 {

   std::construct_at(__p, std::forward<_Args>(__args)...);
   return;
 }

      ::new((void*)__p) _Tp(std::forward<_Args>(__args)...);
    }
# 132 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_construct.h" 3
  template<typename _T1>
    inline void
    _Construct_novalue(_T1* __p)
    { ::new((void*)__p) _T1; }

  template<typename _ForwardIterator>
    constexpr void
    _Destroy(_ForwardIterator __first, _ForwardIterator __last);




  template<typename _Tp>
    constexpr inline void
    _Destroy(_Tp* __pointer)
    {

      std::destroy_at(__pointer);



    }

  template<bool>
    struct _Destroy_aux
    {
      template<typename _ForwardIterator>
 static constexpr void
 __destroy(_ForwardIterator __first, _ForwardIterator __last)
 {
   for (; __first != __last; ++__first)
     std::_Destroy(std::__addressof(*__first));
 }
    };

  template<>
    struct _Destroy_aux<true>
    {
      template<typename _ForwardIterator>
        static void
        __destroy(_ForwardIterator, _ForwardIterator) { }
    };






  template<typename _ForwardIterator>
    constexpr inline void
    _Destroy(_ForwardIterator __first, _ForwardIterator __last)
    {
      typedef typename iterator_traits<_ForwardIterator>::value_type
                       _Value_type;


      static_assert(is_destructible<_Value_type>::value,
      "value type is destructible");


      if (std::__is_constant_evaluated())
 return std::_Destroy_aux<false>::__destroy(__first, __last);

      std::_Destroy_aux<__has_trivial_destructor(_Value_type)>::
 __destroy(__first, __last);
    }

  template<bool>
    struct _Destroy_n_aux
    {
      template<typename _ForwardIterator, typename _Size>
 static constexpr _ForwardIterator
 __destroy_n(_ForwardIterator __first, _Size __count)
 {
   for (; __count > 0; (void)++__first, --__count)
     std::_Destroy(std::__addressof(*__first));
   return __first;
 }
    };

  template<>
    struct _Destroy_n_aux<true>
    {
      template<typename _ForwardIterator, typename _Size>
        static _ForwardIterator
        __destroy_n(_ForwardIterator __first, _Size __count)
 {
   std::advance(__first, __count);
   return __first;
 }
    };






  template<typename _ForwardIterator, typename _Size>
    constexpr inline _ForwardIterator
    _Destroy_n(_ForwardIterator __first, _Size __count)
    {
      typedef typename iterator_traits<_ForwardIterator>::value_type
                       _Value_type;


      static_assert(is_destructible<_Value_type>::value,
      "value type is destructible");


      if (std::__is_constant_evaluated())
 return std::_Destroy_n_aux<false>::__destroy_n(__first, __count);

      return std::_Destroy_n_aux<__has_trivial_destructor(_Value_type)>::
 __destroy_n(__first, __count);
    }


  template <typename _ForwardIterator>
    constexpr inline void
    destroy(_ForwardIterator __first, _ForwardIterator __last)
    {
      std::_Destroy(__first, __last);
    }

  template <typename _ForwardIterator, typename _Size>
    constexpr inline _ForwardIterator
    destroy_n(_ForwardIterator __first, _Size __count)
    {
      return std::_Destroy_n(__first, __count);
    }



}
# 79 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_iterator.h" 2 3






namespace std __attribute__ ((__visibility__ ("default")))
{
# 95 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_iterator.h" 3
  namespace __detail
  {


    template<typename _Cat, typename _Limit, typename _Otherwise = _Cat>
      using __clamp_iter_cat
 = __conditional_t<derived_from<_Cat, _Limit>, _Limit, _Otherwise>;
  }



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
# 128 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_iterator.h" 3
  template<typename _Iterator>
    class reverse_iterator
    : public iterator<typename iterator_traits<_Iterator>::iterator_category,
        typename iterator_traits<_Iterator>::value_type,
        typename iterator_traits<_Iterator>::difference_type,
        typename iterator_traits<_Iterator>::pointer,
                      typename iterator_traits<_Iterator>::reference>
    {
      template<typename _Iter>
 friend class reverse_iterator;




      template<typename _Iter>
 static constexpr bool __convertible = !is_same_v<_Iter, _Iterator>
     && convertible_to<const _Iter&, _Iterator>;


    protected:
      _Iterator current;

      typedef iterator_traits<_Iterator> __traits_type;

    public:
      typedef _Iterator iterator_type;
      typedef typename __traits_type::pointer pointer;




      using iterator_concept
 = __conditional_t<random_access_iterator<_Iterator>,
     random_access_iterator_tag,
     bidirectional_iterator_tag>;
      using iterator_category
 = __detail::__clamp_iter_cat<typename __traits_type::iterator_category,
         random_access_iterator_tag>;
      using value_type = iter_value_t<_Iterator>;
      using difference_type = iter_difference_t<_Iterator>;
      using reference = iter_reference_t<_Iterator>;
# 178 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_iterator.h" 3
      constexpr
      reverse_iterator()
      noexcept(noexcept(_Iterator()))
      : current()
      { }




      explicit constexpr
      reverse_iterator(iterator_type __x)
      noexcept(noexcept(_Iterator(__x)))
      : current(__x)
      { }




      constexpr
      reverse_iterator(const reverse_iterator& __x)
      noexcept(noexcept(_Iterator(__x.current)))
      : current(__x.current)
      { }


      reverse_iterator& operator=(const reverse_iterator&) = default;






      template<typename _Iter>

 requires __convertible<_Iter>

 constexpr
        reverse_iterator(const reverse_iterator<_Iter>& __x)
 noexcept(noexcept(_Iterator(__x.current)))
 : current(__x.current)
 { }


      template<typename _Iter>

 requires __convertible<_Iter>
   && assignable_from<_Iterator&, const _Iter&>

 constexpr
 reverse_iterator&
 operator=(const reverse_iterator<_Iter>& __x)
 noexcept(noexcept(current = __x.current))
 {
   current = __x.current;
   return *this;
 }





      [[__nodiscard__]]
      constexpr iterator_type
      base() const
      noexcept(noexcept(_Iterator(current)))
      { return current; }
# 255 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_iterator.h" 3
      [[__nodiscard__]]
      constexpr reference
      operator*() const
      {
 _Iterator __tmp = current;
 return *--__tmp;
      }






      [[__nodiscard__]]
      constexpr pointer
      operator->() const

      requires is_pointer_v<_Iterator>
 || requires(const _Iterator __i) { __i.operator->(); }

      {


 _Iterator __tmp = current;
 --__tmp;
 return _S_to_pointer(__tmp);
      }






      constexpr reverse_iterator&
      operator++()
      {
 --current;
 return *this;
      }






      constexpr reverse_iterator
      operator++(int)
      {
 reverse_iterator __tmp = *this;
 --current;
 return __tmp;
      }






      constexpr reverse_iterator&
      operator--()
      {
 ++current;
 return *this;
      }






      constexpr reverse_iterator
      operator--(int)
      {
 reverse_iterator __tmp = *this;
 ++current;
 return __tmp;
      }






      [[__nodiscard__]]
      constexpr reverse_iterator
      operator+(difference_type __n) const
      { return reverse_iterator(current - __n); }







      constexpr reverse_iterator&
      operator+=(difference_type __n)
      {
 current -= __n;
 return *this;
      }






      [[__nodiscard__]]
      constexpr reverse_iterator
      operator-(difference_type __n) const
      { return reverse_iterator(current + __n); }







      constexpr reverse_iterator&
      operator-=(difference_type __n)
      {
 current += __n;
 return *this;
      }






      [[__nodiscard__]]
      constexpr reference
      operator[](difference_type __n) const
      { return *(*this + __n); }


      [[nodiscard]]
      friend constexpr iter_rvalue_reference_t<_Iterator>
      iter_move(const reverse_iterator& __i)
      noexcept(is_nothrow_copy_constructible_v<_Iterator>
        && noexcept(ranges::iter_move(--std::declval<_Iterator&>())))
      {
 auto __tmp = __i.base();
 return ranges::iter_move(--__tmp);
      }

      template<indirectly_swappable<_Iterator> _Iter2>
 friend constexpr void
 iter_swap(const reverse_iterator& __x,
    const reverse_iterator<_Iter2>& __y)
 noexcept(is_nothrow_copy_constructible_v<_Iterator>
   && is_nothrow_copy_constructible_v<_Iter2>
   && noexcept(ranges::iter_swap(--std::declval<_Iterator&>(),
            --std::declval<_Iter2&>())))
 {
   auto __xtmp = __x.base();
   auto __ytmp = __y.base();
   ranges::iter_swap(--__xtmp, --__ytmp);
 }


    private:
      template<typename _Tp>
 static constexpr _Tp*
 _S_to_pointer(_Tp* __p)
        { return __p; }

      template<typename _Tp>
 static constexpr pointer
 _S_to_pointer(_Tp __t)
        { return __t.operator->(); }
    };
# 524 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_iterator.h" 3
  template<typename _IteratorL, typename _IteratorR>
    [[nodiscard]]
    constexpr bool
    operator==(const reverse_iterator<_IteratorL>& __x,
        const reverse_iterator<_IteratorR>& __y)
    requires requires { { __x.base() == __y.base() } -> convertible_to<bool>; }
    { return __x.base() == __y.base(); }

  template<typename _IteratorL, typename _IteratorR>
    [[nodiscard]]
    constexpr bool
    operator!=(const reverse_iterator<_IteratorL>& __x,
        const reverse_iterator<_IteratorR>& __y)
    requires requires { { __x.base() != __y.base() } -> convertible_to<bool>; }
    { return __x.base() != __y.base(); }

  template<typename _IteratorL, typename _IteratorR>
    [[nodiscard]]
    constexpr bool
    operator<(const reverse_iterator<_IteratorL>& __x,
       const reverse_iterator<_IteratorR>& __y)
    requires requires { { __x.base() > __y.base() } -> convertible_to<bool>; }
    { return __x.base() > __y.base(); }

  template<typename _IteratorL, typename _IteratorR>
    [[nodiscard]]
    constexpr bool
    operator>(const reverse_iterator<_IteratorL>& __x,
       const reverse_iterator<_IteratorR>& __y)
    requires requires { { __x.base() < __y.base() } -> convertible_to<bool>; }
    { return __x.base() < __y.base(); }

  template<typename _IteratorL, typename _IteratorR>
    [[nodiscard]]
    constexpr bool
    operator<=(const reverse_iterator<_IteratorL>& __x,
        const reverse_iterator<_IteratorR>& __y)
    requires requires { { __x.base() >= __y.base() } -> convertible_to<bool>; }
    { return __x.base() >= __y.base(); }

  template<typename _IteratorL, typename _IteratorR>
    [[nodiscard]]
    constexpr bool
    operator>=(const reverse_iterator<_IteratorL>& __x,
        const reverse_iterator<_IteratorR>& __y)
    requires requires { { __x.base() <= __y.base() } -> convertible_to<bool>; }
    { return __x.base() <= __y.base(); }

  template<typename _IteratorL,
    three_way_comparable_with<_IteratorL> _IteratorR>
    [[nodiscard]]
    constexpr compare_three_way_result_t<_IteratorL, _IteratorR>
    operator<=>(const reverse_iterator<_IteratorL>& __x,
  const reverse_iterator<_IteratorR>& __y)
    { return __y.base() <=> __x.base(); }




  template<typename _Iterator>
    [[nodiscard]]
    constexpr bool
    operator==(const reverse_iterator<_Iterator>& __x,
        const reverse_iterator<_Iterator>& __y)
    requires requires { { __x.base() == __y.base() } -> convertible_to<bool>; }
    { return __x.base() == __y.base(); }

  template<three_way_comparable _Iterator>
    [[nodiscard]]
    constexpr compare_three_way_result_t<_Iterator, _Iterator>
    operator<=>(const reverse_iterator<_Iterator>& __x,
  const reverse_iterator<_Iterator>& __y)
    { return __y.base() <=> __x.base(); }
# 615 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_iterator.h" 3
  template<typename _IteratorL, typename _IteratorR>
    [[__nodiscard__]]
    inline constexpr auto
    operator-(const reverse_iterator<_IteratorL>& __x,
       const reverse_iterator<_IteratorR>& __y)
    -> decltype(__y.base() - __x.base())
    { return __y.base() - __x.base(); }


  template<typename _Iterator>
    [[__nodiscard__]]
    inline constexpr reverse_iterator<_Iterator>
    operator+(typename reverse_iterator<_Iterator>::difference_type __n,
       const reverse_iterator<_Iterator>& __x)
    { return reverse_iterator<_Iterator>(__x.base() - __n); }



  template<typename _Iterator>
    inline constexpr reverse_iterator<_Iterator>
    __make_reverse_iterator(_Iterator __i)
    { return reverse_iterator<_Iterator>(__i); }





  template<typename _Iterator>
    [[__nodiscard__]]
    inline constexpr reverse_iterator<_Iterator>
    make_reverse_iterator(_Iterator __i)
    { return reverse_iterator<_Iterator>(__i); }


  template<typename _Iterator1, typename _Iterator2>
    requires (!sized_sentinel_for<_Iterator1, _Iterator2>)
    inline constexpr bool
    disable_sized_sentinel_for<reverse_iterator<_Iterator1>,
          reverse_iterator<_Iterator2>> = true;



  template<typename _Iterator>
    constexpr
    auto
    __niter_base(reverse_iterator<_Iterator> __it)
    -> decltype(__make_reverse_iterator(__niter_base(__it.base())))
    { return __make_reverse_iterator(__niter_base(__it.base())); }

  template<typename _Iterator>
    struct __is_move_iterator<reverse_iterator<_Iterator> >
      : __is_move_iterator<_Iterator>
    { };

  template<typename _Iterator>
    constexpr
    auto
    __miter_base(reverse_iterator<_Iterator> __it)
    -> decltype(__make_reverse_iterator(__miter_base(__it.base())))
    { return __make_reverse_iterator(__miter_base(__it.base())); }
# 688 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_iterator.h" 3
  template<typename _Container>
    class back_insert_iterator
    : public iterator<output_iterator_tag, void, void, void, void>
    {
    protected:
      _Container* container;

    public:

      typedef _Container container_type;

      using difference_type = ptrdiff_t;



      explicit constexpr
      back_insert_iterator(_Container& __x)
      : container(std::__addressof(__x)) { }
# 726 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_iterator.h" 3
      constexpr
      back_insert_iterator&
      operator=(const typename _Container::value_type& __value)
      {
 container->push_back(__value);
 return *this;
      }

      constexpr
      back_insert_iterator&
      operator=(typename _Container::value_type&& __value)
      {
 container->push_back(std::move(__value));
 return *this;
      }



      [[__nodiscard__]] constexpr
      back_insert_iterator&
      operator*()
      { return *this; }


      constexpr
      back_insert_iterator&
      operator++()
      { return *this; }


      constexpr
      back_insert_iterator
      operator++(int)
      { return *this; }
    };
# 773 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_iterator.h" 3
  template<typename _Container>
    [[__nodiscard__]] constexpr
    inline back_insert_iterator<_Container>
    back_inserter(_Container& __x)
    { return back_insert_iterator<_Container>(__x); }
# 789 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_iterator.h" 3
  template<typename _Container>
    class front_insert_iterator
    : public iterator<output_iterator_tag, void, void, void, void>
    {
    protected:
      _Container* container;

    public:

      typedef _Container container_type;

      using difference_type = ptrdiff_t;



      explicit constexpr
      front_insert_iterator(_Container& __x)
      : container(std::__addressof(__x)) { }
# 827 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_iterator.h" 3
      constexpr
      front_insert_iterator&
      operator=(const typename _Container::value_type& __value)
      {
 container->push_front(__value);
 return *this;
      }

      constexpr
      front_insert_iterator&
      operator=(typename _Container::value_type&& __value)
      {
 container->push_front(std::move(__value));
 return *this;
      }



      [[__nodiscard__]] constexpr
      front_insert_iterator&
      operator*()
      { return *this; }


      constexpr
      front_insert_iterator&
      operator++()
      { return *this; }


      constexpr
      front_insert_iterator
      operator++(int)
      { return *this; }
    };
# 874 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_iterator.h" 3
  template<typename _Container>
    [[__nodiscard__]] constexpr
    inline front_insert_iterator<_Container>
    front_inserter(_Container& __x)
    { return front_insert_iterator<_Container>(__x); }
# 894 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_iterator.h" 3
  template<typename _Container>
    class insert_iterator
    : public iterator<output_iterator_tag, void, void, void, void>
    {

      using _Iter = std::__detail::__range_iter_t<_Container>;



    protected:
      _Container* container;
      _Iter iter;

    public:

      typedef _Container container_type;


      using difference_type = ptrdiff_t;






      constexpr
      insert_iterator(_Container& __x, _Iter __i)
      : container(std::__addressof(__x)), iter(__i) {}
# 955 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_iterator.h" 3
      constexpr
      insert_iterator&
      operator=(const typename _Container::value_type& __value)
      {
 iter = container->insert(iter, __value);
 ++iter;
 return *this;
      }

      constexpr
      insert_iterator&
      operator=(typename _Container::value_type&& __value)
      {
 iter = container->insert(iter, std::move(__value));
 ++iter;
 return *this;
      }



      [[__nodiscard__]] constexpr
      insert_iterator&
      operator*()
      { return *this; }


      constexpr
      insert_iterator&
      operator++()
      { return *this; }


      constexpr
      insert_iterator&
      operator++(int)
      { return *this; }
    };

#pragma GCC diagnostic pop
# 1008 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_iterator.h" 3
  template<typename _Container>
    [[nodiscard]]
    constexpr insert_iterator<_Container>
    inserter(_Container& __x, std::__detail::__range_iter_t<_Container> __i)
    { return insert_iterator<_Container>(__x, __i); }
# 1024 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_iterator.h" 3
}

namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
# 1037 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_iterator.h" 3
  template<typename _Iterator, typename _Container>
    class __normal_iterator
    {
    protected:
      _Iterator _M_current;

      typedef std::iterator_traits<_Iterator> __traits_type;


      template<typename _Iter>
 using __convertible_from
   = std::__enable_if_t<std::is_convertible<_Iter, _Iterator>::value>;


    public:
      typedef _Iterator iterator_type;
      typedef typename __traits_type::iterator_category iterator_category;
      typedef typename __traits_type::value_type value_type;
      typedef typename __traits_type::difference_type difference_type;
      typedef typename __traits_type::reference reference;
      typedef typename __traits_type::pointer pointer;


      using iterator_concept = std::__detail::__iter_concept<_Iterator>;


      constexpr __normal_iterator() noexcept
      : _M_current(_Iterator()) { }

      explicit constexpr
      __normal_iterator(const _Iterator& __i) noexcept
      : _M_current(__i) { }



      template<typename _Iter, typename = __convertible_from<_Iter>>
 constexpr
 __normal_iterator(const __normal_iterator<_Iter, _Container>& __i)
 noexcept
# 1085 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_iterator.h" 3
        : _M_current(__i.base()) { }


      constexpr
      reference
      operator*() const noexcept
      { return *_M_current; }

      constexpr
      pointer
      operator->() const noexcept
      { return _M_current; }

      constexpr
      __normal_iterator&
      operator++() noexcept
      {
 ++_M_current;
 return *this;
      }

      constexpr
      __normal_iterator
      operator++(int) noexcept
      { return __normal_iterator(_M_current++); }


      constexpr
      __normal_iterator&
      operator--() noexcept
      {
 --_M_current;
 return *this;
      }

      constexpr
      __normal_iterator
      operator--(int) noexcept
      { return __normal_iterator(_M_current--); }


      constexpr
      reference
      operator[](difference_type __n) const noexcept
      { return _M_current[__n]; }

      constexpr
      __normal_iterator&
      operator+=(difference_type __n) noexcept
      { _M_current += __n; return *this; }

      constexpr
      __normal_iterator
      operator+(difference_type __n) const noexcept
      { return __normal_iterator(_M_current + __n); }

      constexpr
      __normal_iterator&
      operator-=(difference_type __n) noexcept
      { _M_current -= __n; return *this; }

      constexpr
      __normal_iterator
      operator-(difference_type __n) const noexcept
      { return __normal_iterator(_M_current - __n); }

      constexpr
      const _Iterator&
      base() const noexcept
      { return _M_current; }
    };
# 1166 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_iterator.h" 3
  template<typename _IteratorL, typename _IteratorR, typename _Container>
    [[nodiscard]]
    constexpr bool
    operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
        const __normal_iterator<_IteratorR, _Container>& __rhs)
    noexcept(noexcept(__lhs.base() == __rhs.base()))
    requires requires {
      { __lhs.base() == __rhs.base() } -> std::convertible_to<bool>;
    }
    { return __lhs.base() == __rhs.base(); }

  template<typename _IteratorL, typename _IteratorR, typename _Container>
    [[nodiscard]]
    constexpr std::__detail::__synth3way_t<_IteratorR, _IteratorL>
    operator<=>(const __normal_iterator<_IteratorL, _Container>& __lhs,
  const __normal_iterator<_IteratorR, _Container>& __rhs)
    noexcept(noexcept(std::__detail::__synth3way(__lhs.base(), __rhs.base())))
    { return std::__detail::__synth3way(__lhs.base(), __rhs.base()); }

  template<typename _Iterator, typename _Container>
    [[nodiscard]]
    constexpr bool
    operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
        const __normal_iterator<_Iterator, _Container>& __rhs)
    noexcept(noexcept(__lhs.base() == __rhs.base()))
    requires requires {
      { __lhs.base() == __rhs.base() } -> std::convertible_to<bool>;
    }
    { return __lhs.base() == __rhs.base(); }

  template<typename _Iterator, typename _Container>
    [[nodiscard]]
    constexpr std::__detail::__synth3way_t<_Iterator>
    operator<=>(const __normal_iterator<_Iterator, _Container>& __lhs,
  const __normal_iterator<_Iterator, _Container>& __rhs)
    noexcept(noexcept(std::__detail::__synth3way(__lhs.base(), __rhs.base())))
    { return std::__detail::__synth3way(__lhs.base(), __rhs.base()); }
# 1307 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_iterator.h" 3
  template<typename _IteratorL, typename _IteratorR, typename _Container>


    [[__nodiscard__]] constexpr
    inline auto
    operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
       const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept
    -> decltype(__lhs.base() - __rhs.base())





    { return __lhs.base() - __rhs.base(); }

  template<typename _Iterator, typename _Container>
    [[__nodiscard__]] constexpr
    inline typename __normal_iterator<_Iterator, _Container>::difference_type
    operator-(const __normal_iterator<_Iterator, _Container>& __lhs,
       const __normal_iterator<_Iterator, _Container>& __rhs)
    noexcept
    { return __lhs.base() - __rhs.base(); }

  template<typename _Iterator, typename _Container>
    [[__nodiscard__]] constexpr
    inline __normal_iterator<_Iterator, _Container>
    operator+(typename __normal_iterator<_Iterator, _Container>::difference_type
       __n, const __normal_iterator<_Iterator, _Container>& __i)
    noexcept
    { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }


}

namespace std __attribute__ ((__visibility__ ("default")))
{


  template<typename _Iterator, typename _Container>
    constexpr
    _Iterator
    __niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it)
    noexcept(std::is_nothrow_copy_constructible<_Iterator>::value)
    { return __it.base(); }
# 1371 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_iterator.h" 3
  template<semiregular _Sent>
    class move_sentinel
    {
    public:
      constexpr
      move_sentinel()
      noexcept(is_nothrow_default_constructible_v<_Sent>)
      : _M_last() { }

      constexpr explicit
      move_sentinel(_Sent __s)
      noexcept(is_nothrow_move_constructible_v<_Sent>)
      : _M_last(std::move(__s)) { }

      template<typename _S2> requires convertible_to<const _S2&, _Sent>
 constexpr
 move_sentinel(const move_sentinel<_S2>& __s)
 noexcept(is_nothrow_constructible_v<_Sent, const _S2&>)
 : _M_last(__s.base())
 { }

      template<typename _S2> requires assignable_from<_Sent&, const _S2&>
 constexpr move_sentinel&
 operator=(const move_sentinel<_S2>& __s)
 noexcept(is_nothrow_assignable_v<_Sent, const _S2&>)
 {
   _M_last = __s.base();
   return *this;
 }

      [[nodiscard]]
      constexpr _Sent
      base() const
      noexcept(is_nothrow_copy_constructible_v<_Sent>)
      { return _M_last; }

    private:
      _Sent _M_last;
    };


  namespace __detail
  {

    template<typename _Iterator>
      struct __move_iter_cat
      { };

    template<typename _Iterator>
      requires requires { typename __iter_category_t<_Iterator>; }
      struct __move_iter_cat<_Iterator>
      {
 using iterator_category
   = __clamp_iter_cat<__iter_category_t<_Iterator>,
        random_access_iterator_tag>;
      };

  }
# 1439 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_iterator.h" 3
  template<typename _Iterator>
    class move_iterator

      : public __detail::__move_iter_cat<_Iterator>

    {
      _Iterator _M_current;

      using __traits_type = iterator_traits<_Iterator>;




      template<typename _Iter2>
 friend class move_iterator;




      template<typename _Iter2>
 static constexpr bool __convertible = !is_same_v<_Iter2, _Iterator>
     && convertible_to<const _Iter2&, _Iterator>;



      static auto
      _S_iter_concept()
      {
 if constexpr (random_access_iterator<_Iterator>)
   return random_access_iterator_tag{};
 else if constexpr (bidirectional_iterator<_Iterator>)
   return bidirectional_iterator_tag{};
 else if constexpr (forward_iterator<_Iterator>)
   return forward_iterator_tag{};
 else
   return input_iterator_tag{};
      }


    public:
      using iterator_type = _Iterator;


      using iterator_concept = decltype(_S_iter_concept());


      using value_type = iter_value_t<_Iterator>;
      using difference_type = iter_difference_t<_Iterator>;
      using pointer = _Iterator;
      using reference = iter_rvalue_reference_t<_Iterator>;
# 1503 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_iterator.h" 3
      constexpr
      move_iterator()
      : _M_current() { }

      explicit constexpr
      move_iterator(iterator_type __i)
      : _M_current(std::move(__i)) { }

      template<typename _Iter>

 requires __convertible<_Iter>

 constexpr
 move_iterator(const move_iterator<_Iter>& __i)
 : _M_current(__i._M_current) { }

      template<typename _Iter>

 requires __convertible<_Iter>
   && assignable_from<_Iterator&, const _Iter&>

 constexpr
 move_iterator& operator=(const move_iterator<_Iter>& __i)
 {
   _M_current = __i._M_current;
   return *this;
 }







      [[nodiscard]]
      constexpr const iterator_type&
      base() const & noexcept
      { return _M_current; }

      [[nodiscard]]
      constexpr iterator_type
      base() &&
      { return std::move(_M_current); }


      [[__nodiscard__]]
      constexpr reference
      operator*() const

      { return ranges::iter_move(_M_current); }




      [[__nodiscard__]]
      constexpr pointer
      operator->() const
      { return _M_current; }

      constexpr move_iterator&
      operator++()
      {
 ++_M_current;
 return *this;
      }

      constexpr move_iterator
      operator++(int)
      {
 move_iterator __tmp = *this;
 ++_M_current;
 return __tmp;
      }


      constexpr void
      operator++(int) requires (!forward_iterator<_Iterator>)
      { ++_M_current; }


      constexpr move_iterator&
      operator--()
      {
 --_M_current;
 return *this;
      }

      constexpr move_iterator
      operator--(int)
      {
 move_iterator __tmp = *this;
 --_M_current;
 return __tmp;
      }

      [[__nodiscard__]]
      constexpr move_iterator
      operator+(difference_type __n) const
      { return move_iterator(_M_current + __n); }

      constexpr move_iterator&
      operator+=(difference_type __n)
      {
 _M_current += __n;
 return *this;
      }

      [[__nodiscard__]]
      constexpr move_iterator
      operator-(difference_type __n) const
      { return move_iterator(_M_current - __n); }

      constexpr move_iterator&
      operator-=(difference_type __n)
      {
 _M_current -= __n;
 return *this;
      }

      [[__nodiscard__]]
      constexpr reference
      operator[](difference_type __n) const

      { return ranges::iter_move(_M_current + __n); }





      template<sentinel_for<_Iterator> _Sent>
 [[nodiscard]]
 friend constexpr bool
 operator==(const move_iterator& __x, const move_sentinel<_Sent>& __y)
 { return __x.base() == __y.base(); }

      template<sized_sentinel_for<_Iterator> _Sent>
 [[nodiscard]]
 friend constexpr iter_difference_t<_Iterator>
 operator-(const move_sentinel<_Sent>& __x, const move_iterator& __y)
 { return __x.base() - __y.base(); }

      template<sized_sentinel_for<_Iterator> _Sent>
 [[nodiscard]]
 friend constexpr iter_difference_t<_Iterator>
 operator-(const move_iterator& __x, const move_sentinel<_Sent>& __y)
 { return __x.base() - __y.base(); }

      [[nodiscard]]
      friend constexpr iter_rvalue_reference_t<_Iterator>
      iter_move(const move_iterator& __i)
      noexcept(noexcept(ranges::iter_move(__i._M_current)))
      { return ranges::iter_move(__i._M_current); }

      template<indirectly_swappable<_Iterator> _Iter2>
 friend constexpr void
 iter_swap(const move_iterator& __x, const move_iterator<_Iter2>& __y)
 noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
 { return ranges::iter_swap(__x._M_current, __y._M_current); }

    };

  template<typename _IteratorL, typename _IteratorR>
    [[__nodiscard__]]
    inline constexpr bool
    operator==(const move_iterator<_IteratorL>& __x,
        const move_iterator<_IteratorR>& __y)

    requires requires { { __x.base() == __y.base() } -> convertible_to<bool>; }

    { return __x.base() == __y.base(); }


  template<typename _IteratorL,
    three_way_comparable_with<_IteratorL> _IteratorR>
    [[__nodiscard__]]
    constexpr compare_three_way_result_t<_IteratorL, _IteratorR>
    operator<=>(const move_iterator<_IteratorL>& __x,
  const move_iterator<_IteratorR>& __y)
    { return __x.base() <=> __y.base(); }
# 1691 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_iterator.h" 3
  template<typename _IteratorL, typename _IteratorR>
    [[__nodiscard__]]
    inline constexpr bool
    operator<(const move_iterator<_IteratorL>& __x,
       const move_iterator<_IteratorR>& __y)

    requires requires { { __x.base() < __y.base() } -> convertible_to<bool>; }

    { return __x.base() < __y.base(); }

  template<typename _IteratorL, typename _IteratorR>
    [[__nodiscard__]]
    inline constexpr bool
    operator<=(const move_iterator<_IteratorL>& __x,
        const move_iterator<_IteratorR>& __y)

    requires requires { { __y.base() < __x.base() } -> convertible_to<bool>; }

    { return !(__y < __x); }

  template<typename _IteratorL, typename _IteratorR>
    [[__nodiscard__]]
    inline constexpr bool
    operator>(const move_iterator<_IteratorL>& __x,
       const move_iterator<_IteratorR>& __y)

    requires requires { { __y.base() < __x.base() } -> convertible_to<bool>; }

    { return __y < __x; }

  template<typename _IteratorL, typename _IteratorR>
    [[__nodiscard__]]
    inline constexpr bool
    operator>=(const move_iterator<_IteratorL>& __x,
        const move_iterator<_IteratorR>& __y)

    requires requires { { __x.base() < __y.base() } -> convertible_to<bool>; }

    { return !(__x < __y); }




  template<typename _Iterator>
    [[__nodiscard__]]
    inline constexpr bool
    operator==(const move_iterator<_Iterator>& __x,
        const move_iterator<_Iterator>& __y)
    { return __x.base() == __y.base(); }


  template<three_way_comparable _Iterator>
    [[__nodiscard__]]
    constexpr compare_three_way_result_t<_Iterator>
    operator<=>(const move_iterator<_Iterator>& __x,
  const move_iterator<_Iterator>& __y)
    { return __x.base() <=> __y.base(); }
# 1786 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_iterator.h" 3
  template<typename _IteratorL, typename _IteratorR>
    [[__nodiscard__]]
    inline constexpr auto
    operator-(const move_iterator<_IteratorL>& __x,
       const move_iterator<_IteratorR>& __y)
    -> decltype(__x.base() - __y.base())
    { return __x.base() - __y.base(); }

  template<typename _Iterator>
    [[__nodiscard__]]
    inline constexpr move_iterator<_Iterator>
    operator+(typename move_iterator<_Iterator>::difference_type __n,
       const move_iterator<_Iterator>& __x)
    { return __x + __n; }

  template<typename _Iterator>
    [[__nodiscard__]]
    inline constexpr move_iterator<_Iterator>
    make_move_iterator(_Iterator __i)
    { return move_iterator<_Iterator>(std::move(__i)); }

  template<typename _Iterator, typename _ReturnType
    = __conditional_t<__move_if_noexcept_cond
      <typename iterator_traits<_Iterator>::value_type>::value,
  _Iterator, move_iterator<_Iterator>>>
    inline constexpr _ReturnType
    __make_move_if_noexcept_iterator(_Iterator __i)
    { return _ReturnType(__i); }



  template<typename _Tp, typename _ReturnType
    = __conditional_t<__move_if_noexcept_cond<_Tp>::value,
        const _Tp*, move_iterator<_Tp*>>>
    inline constexpr _ReturnType
    __make_move_if_noexcept_iterator(_Tp* __i)
    { return _ReturnType(__i); }




  namespace __detail
  {
    template<typename _It>
      concept __common_iter_has_arrow = indirectly_readable<const _It>
 && (requires(const _It& __it) { __it.operator->(); }
     || is_reference_v<iter_reference_t<_It>>
     || constructible_from<iter_value_t<_It>, iter_reference_t<_It>>);

    template<typename _It>
      concept __common_iter_use_postfix_proxy
 = (!requires (_It& __i) { { *__i++ } -> __can_reference; })
   && constructible_from<iter_value_t<_It>, iter_reference_t<_It>>
   && move_constructible<iter_value_t<_It>>;
  }


  template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
    requires (!same_as<_It, _Sent>) && copyable<_It>
  class common_iterator
  {
    template<typename _Tp, typename _Up>
      static constexpr bool
      _S_noexcept1()
      {
 if constexpr (is_trivially_default_constructible_v<_Tp>)
   return is_nothrow_assignable_v<_Tp&, _Up>;
 else
   return is_nothrow_constructible_v<_Tp, _Up>;
      }

    template<typename _It2, typename _Sent2>
      static constexpr bool
      _S_noexcept()
      { return _S_noexcept1<_It, _It2>() && _S_noexcept1<_Sent, _Sent2>(); }

    class __arrow_proxy
    {
      iter_value_t<_It> _M_keep;

      constexpr
      __arrow_proxy(iter_reference_t<_It>&& __x)
      : _M_keep(std::move(__x)) { }

      friend class common_iterator;

    public:
      constexpr const iter_value_t<_It>*
      operator->() const noexcept
      { return std::__addressof(_M_keep); }
    };

    class __postfix_proxy
    {
      iter_value_t<_It> _M_keep;

      constexpr
      __postfix_proxy(iter_reference_t<_It>&& __x)
      : _M_keep(std::forward<iter_reference_t<_It>>(__x)) { }

      friend class common_iterator;

    public:
      constexpr const iter_value_t<_It>&
      operator*() const noexcept
      { return _M_keep; }
    };

  public:
    constexpr
    common_iterator()
    noexcept(is_nothrow_default_constructible_v<_It>)
    requires default_initializable<_It>
    : _M_it(), _M_index(0)
    { }

    constexpr
    common_iterator(_It __i)
    noexcept(is_nothrow_move_constructible_v<_It>)
    : _M_it(std::move(__i)), _M_index(0)
    { }

    constexpr
    common_iterator(_Sent __s)
    noexcept(is_nothrow_move_constructible_v<_Sent>)
    : _M_sent(std::move(__s)), _M_index(1)
    { }

    template<typename _It2, typename _Sent2>
      requires convertible_to<const _It2&, _It>
 && convertible_to<const _Sent2&, _Sent>
      constexpr
      common_iterator(const common_iterator<_It2, _Sent2>& __x)
      noexcept(_S_noexcept<const _It2&, const _Sent2&>())
      : _M_valueless(), _M_index(__x._M_index)
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__x._M_has_value()), false)) std::__glibcxx_assert_fail(); } while (false);
 if (_M_index == 0)
   {
     if constexpr (is_trivially_default_constructible_v<_It>)
       _M_it = std::move(__x._M_it);
     else
       std::construct_at(std::__addressof(_M_it), __x._M_it);
   }
 else if (_M_index == 1)
   {
     if constexpr (is_trivially_default_constructible_v<_Sent>)
       _M_sent = std::move(__x._M_sent);
     else
       std::construct_at(std::__addressof(_M_sent), __x._M_sent);
   }
      }

    common_iterator(const common_iterator&) = default;

    constexpr
    common_iterator(const common_iterator& __x)
    noexcept(_S_noexcept<const _It&, const _Sent&>())
    requires (!is_trivially_copyable_v<_It> || !is_trivially_copyable_v<_Sent>)
    : _M_valueless(), _M_index(__x._M_index)
    {
      if (_M_index == 0)
 {
   if constexpr (is_trivially_default_constructible_v<_It>)
     _M_it = __x._M_it;
   else
     std::construct_at(std::__addressof(_M_it), __x._M_it);
 }
      else if (_M_index == 1)
 {
   if constexpr (is_trivially_default_constructible_v<_Sent>)
     _M_sent = __x._M_sent;
   else
     std::construct_at(std::__addressof(_M_sent), __x._M_sent);
 }
    }

    common_iterator(common_iterator&&) = default;

    constexpr
    common_iterator(common_iterator&& __x)
    noexcept(_S_noexcept<_It, _Sent>())
    requires (!is_trivially_copyable_v<_It> || !is_trivially_copyable_v<_Sent>)
    : _M_valueless(), _M_index(__x._M_index)
    {
      if (_M_index == 0)
 {
   if constexpr (is_trivially_default_constructible_v<_It>)
     _M_it = std::move(__x._M_it);
   else
     std::construct_at(std::__addressof(_M_it), std::move(__x._M_it));
 }
      else if (_M_index == 1)
 {
   if constexpr (is_trivially_default_constructible_v<_Sent>)
     _M_sent = std::move(__x._M_sent);
   else
     std::construct_at(std::__addressof(_M_sent),
         std::move(__x._M_sent));
 }
    }

    constexpr common_iterator&
    operator=(const common_iterator&) = default;

    constexpr common_iterator&
    operator=(const common_iterator& __x)
    noexcept(is_nothrow_copy_assignable_v<_It>
      && is_nothrow_copy_assignable_v<_Sent>
      && is_nothrow_copy_constructible_v<_It>
      && is_nothrow_copy_constructible_v<_Sent>)
    requires (!is_trivially_copy_assignable_v<_It>
  || !is_trivially_copy_assignable_v<_Sent>)
    {
      _M_assign(__x);
      return *this;
    }

    constexpr common_iterator&
    operator=(common_iterator&&) = default;

    constexpr common_iterator&
    operator=(common_iterator&& __x)
    noexcept(is_nothrow_move_assignable_v<_It>
      && is_nothrow_move_assignable_v<_Sent>
      && is_nothrow_move_constructible_v<_It>
      && is_nothrow_move_constructible_v<_Sent>)
    requires (!is_trivially_move_assignable_v<_It>
  || !is_trivially_move_assignable_v<_Sent>)
    {
      _M_assign(std::move(__x));
      return *this;
    }

    template<typename _It2, typename _Sent2>
      requires convertible_to<const _It2&, _It>
 && convertible_to<const _Sent2&, _Sent>
 && assignable_from<_It&, const _It2&>
 && assignable_from<_Sent&, const _Sent2&>
      constexpr common_iterator&
      operator=(const common_iterator<_It2, _Sent2>& __x)
      noexcept(is_nothrow_constructible_v<_It, const _It2&>
        && is_nothrow_constructible_v<_Sent, const _Sent2&>
        && is_nothrow_assignable_v<_It&, const _It2&>
        && is_nothrow_assignable_v<_Sent&, const _Sent2&>)
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__x._M_has_value()), false)) std::__glibcxx_assert_fail(); } while (false);
 _M_assign(__x);
 return *this;
      }
# 2045 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_iterator.h" 3
    constexpr
    ~common_iterator()

    {
      if (_M_index == 0)
 _M_it.~_It();
      else if (_M_index == 1)
 _M_sent.~_Sent();
    }

    [[nodiscard]]
    constexpr decltype(auto)
    operator*()
    {
      do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(_M_index == 0), false)) std::__glibcxx_assert_fail(); } while (false);
      return *_M_it;
    }

    [[nodiscard]]
    constexpr decltype(auto)
    operator*() const requires __detail::__dereferenceable<const _It>
    {
      do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(_M_index == 0), false)) std::__glibcxx_assert_fail(); } while (false);
      return *_M_it;
    }

    [[nodiscard]]
    constexpr auto
    operator->() const requires __detail::__common_iter_has_arrow<_It>
    {
      do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(_M_index == 0), false)) std::__glibcxx_assert_fail(); } while (false);
      if constexpr (is_pointer_v<_It> || requires { _M_it.operator->(); })
 return _M_it;
      else if constexpr (is_reference_v<iter_reference_t<_It>>)
 {
   auto&& __tmp = *_M_it;
   return std::__addressof(__tmp);
 }
      else
 return __arrow_proxy{*_M_it};
    }

    constexpr common_iterator&
    operator++()
    {
      do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(_M_index == 0), false)) std::__glibcxx_assert_fail(); } while (false);
      ++_M_it;
      return *this;
    }

    constexpr decltype(auto)
    operator++(int)
    {
      do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(_M_index == 0), false)) std::__glibcxx_assert_fail(); } while (false);
      if constexpr (forward_iterator<_It>)
 {
   common_iterator __tmp = *this;
   ++*this;
   return __tmp;
 }
      else if constexpr (!__detail::__common_iter_use_postfix_proxy<_It>)
 return _M_it++;
      else
 {
   __postfix_proxy __p(**this);
   ++*this;
   return __p;
 }
    }

    template<typename _It2, sentinel_for<_It> _Sent2>
      requires sentinel_for<_Sent, _It2>
      friend constexpr bool
      operator== [[nodiscard]] (const common_iterator& __x,
    const common_iterator<_It2, _Sent2>& __y)
      {
 switch(__x._M_index << 2 | __y._M_index)
   {
   case 0b0000:
   case 0b0101:
     return true;
   case 0b0001:
     return __x._M_it == __y._M_sent;
   case 0b0100:
     return __x._M_sent == __y._M_it;
   default:
     do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__x._M_has_value()), false)) std::__glibcxx_assert_fail(); } while (false);
     do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__y._M_has_value()), false)) std::__glibcxx_assert_fail(); } while (false);
     __builtin_unreachable();
   }
      }

    template<typename _It2, sentinel_for<_It> _Sent2>
      requires sentinel_for<_Sent, _It2> && equality_comparable_with<_It, _It2>
      friend constexpr bool
      operator== [[nodiscard]] (const common_iterator& __x,
    const common_iterator<_It2, _Sent2>& __y)
      {
 switch(__x._M_index << 2 | __y._M_index)
   {
   case 0b0101:
     return true;
   case 0b0000:
     return __x._M_it == __y._M_it;
   case 0b0001:
     return __x._M_it == __y._M_sent;
   case 0b0100:
     return __x._M_sent == __y._M_it;
   default:
     do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__x._M_has_value()), false)) std::__glibcxx_assert_fail(); } while (false);
     do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__y._M_has_value()), false)) std::__glibcxx_assert_fail(); } while (false);
     __builtin_unreachable();
   }
      }

    template<sized_sentinel_for<_It> _It2, sized_sentinel_for<_It> _Sent2>
      requires sized_sentinel_for<_Sent, _It2>
      friend constexpr iter_difference_t<_It2>
      operator- [[nodiscard]] (const common_iterator& __x,
          const common_iterator<_It2, _Sent2>& __y)
      {
 switch(__x._M_index << 2 | __y._M_index)
   {
   case 0b0101:
     return 0;
   case 0b0000:
     return __x._M_it - __y._M_it;
   case 0b0001:
     return __x._M_it - __y._M_sent;
   case 0b0100:
     return __x._M_sent - __y._M_it;
   default:
     do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__x._M_has_value()), false)) std::__glibcxx_assert_fail(); } while (false);
     do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__y._M_has_value()), false)) std::__glibcxx_assert_fail(); } while (false);
     __builtin_unreachable();
   }
      }

    [[nodiscard]]
    friend constexpr iter_rvalue_reference_t<_It>
    iter_move(const common_iterator& __i)
    noexcept(noexcept(ranges::iter_move(std::declval<const _It&>())))
    requires input_iterator<_It>
    {
      do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__i._M_index == 0), false)) std::__glibcxx_assert_fail(); } while (false);
      return ranges::iter_move(__i._M_it);
    }

    template<indirectly_swappable<_It> _It2, typename _Sent2>
      friend constexpr void
      iter_swap(const common_iterator& __x,
  const common_iterator<_It2, _Sent2>& __y)
      noexcept(noexcept(ranges::iter_swap(std::declval<const _It&>(),
       std::declval<const _It2&>())))
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__x._M_index == 0), false)) std::__glibcxx_assert_fail(); } while (false);
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__y._M_index == 0), false)) std::__glibcxx_assert_fail(); } while (false);
 return ranges::iter_swap(__x._M_it, __y._M_it);
      }

  private:
    template<input_or_output_iterator _It2, sentinel_for<_It2> _Sent2>
      requires (!same_as<_It2, _Sent2>) && copyable<_It2>
      friend class common_iterator;

    constexpr bool
    _M_has_value() const noexcept { return _M_index != _S_valueless; }

    template<typename _CIt>
      constexpr void
      _M_assign(_CIt&& __x)
      {
 if (_M_index == __x._M_index)
   {
     if (_M_index == 0)
       _M_it = std::forward<_CIt>(__x)._M_it;
     else if (_M_index == 1)
       _M_sent = std::forward<_CIt>(__x)._M_sent;
   }
 else
   {
     if (_M_index == 0)
       _M_it.~_It();
     else if (_M_index == 1)
       _M_sent.~_Sent();
     _M_index = _S_valueless;

     if (__x._M_index == 0)
       std::construct_at(std::__addressof(_M_it),
    std::forward<_CIt>(__x)._M_it);
     else if (__x._M_index == 1)
       std::construct_at(std::__addressof(_M_sent),
    std::forward<_CIt>(__x)._M_sent);
     _M_index = __x._M_index;
   }
      }

    union
    {
      _It _M_it;
      _Sent _M_sent;
      unsigned char _M_valueless;
    };
    unsigned char _M_index;

    static constexpr unsigned char _S_valueless{2};
  };

  template<typename _It, typename _Sent>
    struct incrementable_traits<common_iterator<_It, _Sent>>
    {
      using difference_type = iter_difference_t<_It>;
    };

  template<input_iterator _It, typename _Sent>
    struct iterator_traits<common_iterator<_It, _Sent>>
    {
    private:
      template<typename _Iter>
 struct __ptr
 {
   using type = void;
 };

      template<typename _Iter>
 requires __detail::__common_iter_has_arrow<_Iter>
 struct __ptr<_Iter>
 {
   using _CIter = common_iterator<_Iter, _Sent>;
   using type = decltype(std::declval<const _CIter&>().operator->());
 };

      static auto
      _S_iter_cat()
      {
 if constexpr (requires { requires derived_from<__iter_category_t<_It>,
             forward_iterator_tag>; })
   return forward_iterator_tag{};
 else
   return input_iterator_tag{};
      }

    public:
      using iterator_concept = __conditional_t<forward_iterator<_It>,
            forward_iterator_tag,
            input_iterator_tag>;
      using iterator_category = decltype(_S_iter_cat());
      using value_type = iter_value_t<_It>;
      using difference_type = iter_difference_t<_It>;
      using pointer = typename __ptr<_It>::type;
      using reference = iter_reference_t<_It>;
    };



  namespace __detail
  {
    template<typename _It>
      struct __counted_iter_value_type
      { };

    template<indirectly_readable _It>
      struct __counted_iter_value_type<_It>
      { using value_type = iter_value_t<_It>; };

    template<typename _It>
      struct __counted_iter_concept
      { };

    template<typename _It>
      requires requires { typename _It::iterator_concept; }
      struct __counted_iter_concept<_It>
      { using iterator_concept = typename _It::iterator_concept; };

    template<typename _It>
      struct __counted_iter_cat
      { };

    template<typename _It>
      requires requires { typename _It::iterator_category; }
      struct __counted_iter_cat<_It>
      { using iterator_category = typename _It::iterator_category; };
  }


  template<input_or_output_iterator _It>
    class counted_iterator
      : public __detail::__counted_iter_value_type<_It>,
 public __detail::__counted_iter_concept<_It>,
 public __detail::__counted_iter_cat<_It>
    {
    public:
      using iterator_type = _It;

      using difference_type = iter_difference_t<_It>;



      constexpr counted_iterator() requires default_initializable<_It> = default;

      constexpr
      counted_iterator(_It __i, iter_difference_t<_It> __n)
      : _M_current(std::move(__i)), _M_length(__n)
      { do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__n >= 0), false)) std::__glibcxx_assert_fail(); } while (false); }

      template<typename _It2>
 requires convertible_to<const _It2&, _It>
 constexpr
 counted_iterator(const counted_iterator<_It2>& __x)
 : _M_current(__x._M_current), _M_length(__x._M_length)
 { }

      template<typename _It2>
 requires assignable_from<_It&, const _It2&>
 constexpr counted_iterator&
 operator=(const counted_iterator<_It2>& __x)
 {
   _M_current = __x._M_current;
   _M_length = __x._M_length;
   return *this;
 }

      [[nodiscard]]
      constexpr const _It&
      base() const & noexcept
      { return _M_current; }

      [[nodiscard]]
      constexpr _It
      base() &&
      noexcept(is_nothrow_move_constructible_v<_It>)
      { return std::move(_M_current); }

      [[nodiscard]]
      constexpr iter_difference_t<_It>
      count() const noexcept { return _M_length; }

      [[nodiscard]]
      constexpr decltype(auto)
      operator*()
      noexcept(noexcept(*_M_current))
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(_M_length > 0), false)) std::__glibcxx_assert_fail(); } while (false);
 return *_M_current;
      }

      [[nodiscard]]
      constexpr decltype(auto)
      operator*() const
      noexcept(noexcept(*_M_current))
      requires __detail::__dereferenceable<const _It>
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(_M_length > 0), false)) std::__glibcxx_assert_fail(); } while (false);
 return *_M_current;
      }

      [[nodiscard]]
      constexpr auto
      operator->() const noexcept
      requires contiguous_iterator<_It>
      { return std::to_address(_M_current); }

      constexpr counted_iterator&
      operator++()
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(_M_length > 0), false)) std::__glibcxx_assert_fail(); } while (false);
 ++_M_current;
 --_M_length;
 return *this;
      }

      constexpr decltype(auto)
      operator++(int)
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(_M_length > 0), false)) std::__glibcxx_assert_fail(); } while (false);
 --_M_length;
 try
   {
     return _M_current++;
   } catch(...) {
     ++_M_length;
     throw;
   }
      }

      constexpr counted_iterator
      operator++(int) requires forward_iterator<_It>
      {
 auto __tmp = *this;
 ++*this;
 return __tmp;
      }

      constexpr counted_iterator&
      operator--() requires bidirectional_iterator<_It>
      {
 --_M_current;
 ++_M_length;
 return *this;
      }

      constexpr counted_iterator
      operator--(int) requires bidirectional_iterator<_It>
      {
 auto __tmp = *this;
 --*this;
 return __tmp;
      }

      [[nodiscard]]
      constexpr counted_iterator
      operator+(iter_difference_t<_It> __n) const
 requires random_access_iterator<_It>
      { return counted_iterator(_M_current + __n, _M_length - __n); }

      [[nodiscard]]
      friend constexpr counted_iterator
      operator+(iter_difference_t<_It> __n, const counted_iterator& __x)
      requires random_access_iterator<_It>
      { return __x + __n; }

      constexpr counted_iterator&
      operator+=(iter_difference_t<_It> __n)
      requires random_access_iterator<_It>
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__n <= _M_length), false)) std::__glibcxx_assert_fail(); } while (false);
 _M_current += __n;
 _M_length -= __n;
 return *this;
      }

      [[nodiscard]]
      constexpr counted_iterator
      operator-(iter_difference_t<_It> __n) const
      requires random_access_iterator<_It>
      { return counted_iterator(_M_current - __n, _M_length + __n); }

      template<common_with<_It> _It2>
 [[nodiscard]]
 friend constexpr iter_difference_t<_It2>
 operator-(const counted_iterator& __x,
    const counted_iterator<_It2>& __y)
 { return __y._M_length - __x._M_length; }

      [[nodiscard]]
      friend constexpr iter_difference_t<_It>
      operator-(const counted_iterator& __x, default_sentinel_t)
      { return -__x._M_length; }

      [[nodiscard]]
      friend constexpr iter_difference_t<_It>
      operator-(default_sentinel_t, const counted_iterator& __y)
      { return __y._M_length; }

      constexpr counted_iterator&
      operator-=(iter_difference_t<_It> __n)
      requires random_access_iterator<_It>
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(-__n <= _M_length), false)) std::__glibcxx_assert_fail(); } while (false);
 _M_current -= __n;
 _M_length += __n;
 return *this;
      }

      [[nodiscard]]
      constexpr decltype(auto)
      operator[](iter_difference_t<_It> __n) const
      noexcept(noexcept(_M_current[__n]))
      requires random_access_iterator<_It>
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__n < _M_length), false)) std::__glibcxx_assert_fail(); } while (false);
 return _M_current[__n];
      }

      template<common_with<_It> _It2>
 [[nodiscard]]
 friend constexpr bool
 operator==(const counted_iterator& __x,
     const counted_iterator<_It2>& __y)
 { return __x._M_length == __y._M_length; }

      [[nodiscard]]
      friend constexpr bool
      operator==(const counted_iterator& __x, default_sentinel_t)
      { return __x._M_length == 0; }

      template<common_with<_It> _It2>
 [[nodiscard]]
 friend constexpr strong_ordering
 operator<=>(const counted_iterator& __x,
      const counted_iterator<_It2>& __y)
 { return __y._M_length <=> __x._M_length; }

      [[nodiscard]]
      friend constexpr iter_rvalue_reference_t<_It>
      iter_move(const counted_iterator& __i)
      noexcept(noexcept(ranges::iter_move(__i._M_current)))
      requires input_iterator<_It>
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__i._M_length > 0), false)) std::__glibcxx_assert_fail(); } while (false);
 return ranges::iter_move(__i._M_current);
      }

      template<indirectly_swappable<_It> _It2>
 friend constexpr void
 iter_swap(const counted_iterator& __x,
    const counted_iterator<_It2>& __y)
 noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
 {
   do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__x._M_length > 0 && __y._M_length > 0), false)) std::__glibcxx_assert_fail(); } while (false);
   ranges::iter_swap(__x._M_current, __y._M_current);
 }

    private:
      template<input_or_output_iterator _It2> friend class counted_iterator;

      _It _M_current = _It();
      iter_difference_t<_It> _M_length = 0;
    };

  template<input_iterator _It>
    requires same_as<__detail::__iter_traits<_It>, iterator_traits<_It>>
    struct iterator_traits<counted_iterator<_It>> : iterator_traits<_It>
    {
      using pointer = __conditional_t<contiguous_iterator<_It>,
          add_pointer_t<iter_reference_t<_It>>,
          void>;
    };


  template<indirectly_readable _It>
    using iter_const_reference_t
      = common_reference_t<const iter_value_t<_It>&&, iter_reference_t<_It>>;

  template<input_iterator _It> class basic_const_iterator;

  namespace __detail
  {
    template<typename _It>
      concept __constant_iterator = input_iterator<_It>
 && same_as<iter_const_reference_t<_It>, iter_reference_t<_It>>;

    template<typename _Tp>
      inline constexpr bool __is_const_iterator = false;

    template<typename _It>
      inline constexpr bool __is_const_iterator<basic_const_iterator<_It>> = true;

    template<typename _Tp>
      concept __not_a_const_iterator = !__is_const_iterator<_Tp>;

    template<indirectly_readable _It>
      using __iter_const_rvalue_reference_t
 = common_reference_t<const iter_value_t<_It>&&, iter_rvalue_reference_t<_It>>;

    template<typename _It>
      struct __basic_const_iterator_iter_cat
      { };

    template<forward_iterator _It>
      struct __basic_const_iterator_iter_cat<_It>
      { using iterator_category = __iter_category_t<_It>; };
  }

  template<input_iterator _It>
    using const_iterator
      = __conditional_t<__detail::__constant_iterator<_It>, _It, basic_const_iterator<_It>>;

  namespace __detail
  {
    template<typename _Sent>
      struct __const_sentinel
      { using type = _Sent; };

    template<input_iterator _Sent>
      struct __const_sentinel<_Sent>
      { using type = const_iterator<_Sent>; };
  }

  template<semiregular _Sent>
    using const_sentinel = typename __detail::__const_sentinel<_Sent>::type;

  template<input_iterator _It>
  class basic_const_iterator
  : public __detail::__basic_const_iterator_iter_cat<_It>
  {
    _It _M_current = _It();
    using __reference = iter_const_reference_t<_It>;
    using __rvalue_reference = __detail::__iter_const_rvalue_reference_t<_It>;

    static auto
    _S_iter_concept()
    {
      if constexpr (contiguous_iterator<_It>)
 return contiguous_iterator_tag{};
      else if constexpr (random_access_iterator<_It>)
 return random_access_iterator_tag{};
      else if constexpr (bidirectional_iterator<_It>)
 return bidirectional_iterator_tag{};
      else if constexpr (forward_iterator<_It>)
 return forward_iterator_tag{};
      else
 return input_iterator_tag{};
    }

    template<input_iterator _It2> friend class basic_const_iterator;

  public:
    using iterator_concept = decltype(_S_iter_concept());
    using value_type = iter_value_t<_It>;
    using difference_type = iter_difference_t<_It>;

    basic_const_iterator() requires default_initializable<_It> = default;

    constexpr
    basic_const_iterator(_It __current)
    noexcept(is_nothrow_move_constructible_v<_It>)
    : _M_current(std::move(__current))
    { }

    template<convertible_to<_It> _It2>
      constexpr
      basic_const_iterator(basic_const_iterator<_It2> __current)
      noexcept(is_nothrow_constructible_v<_It, _It2>)
      : _M_current(std::move(__current._M_current))
      { }

    template<__detail::__different_from<basic_const_iterator> _Tp>
      requires convertible_to<_Tp, _It>
      constexpr
      basic_const_iterator(_Tp&& __current)
      noexcept(is_nothrow_constructible_v<_It, _Tp>)
      : _M_current(std::forward<_Tp>(__current))
      { }

    constexpr const _It&
    base() const & noexcept
    { return _M_current; }

    constexpr _It
    base() &&
    noexcept(is_nothrow_move_constructible_v<_It>)
    { return std::move(_M_current); }

    constexpr __reference
    operator*() const
    noexcept(noexcept(static_cast<__reference>(*_M_current)))
    { return static_cast<__reference>(*_M_current); }

    constexpr const auto*
    operator->() const
    noexcept(contiguous_iterator<_It> || noexcept(*_M_current))
    requires is_lvalue_reference_v<iter_reference_t<_It>>
      && same_as<remove_cvref_t<iter_reference_t<_It>>, value_type>
    {
      if constexpr (contiguous_iterator<_It>)
 return std::to_address(_M_current);
      else
 return std::__addressof(*_M_current);
    }

    constexpr basic_const_iterator&
    operator++()
    noexcept(noexcept(++_M_current))
    {
      ++_M_current;
      return *this;
    }

    constexpr void
    operator++(int)
    noexcept(noexcept(++_M_current))
    { ++_M_current; }

    constexpr basic_const_iterator
    operator++(int)
    noexcept(noexcept(++*this) && is_nothrow_copy_constructible_v<basic_const_iterator>)
    requires forward_iterator<_It>
    {
      auto __tmp = *this;
      ++*this;
      return __tmp;
    }

    constexpr basic_const_iterator&
    operator--()
    noexcept(noexcept(--_M_current))
    requires bidirectional_iterator<_It>
    {
      --_M_current;
      return *this;
    }

    constexpr basic_const_iterator
    operator--(int)
    noexcept(noexcept(--*this) && is_nothrow_copy_constructible_v<basic_const_iterator>)
    requires bidirectional_iterator<_It>
    {
      auto __tmp = *this;
      --*this;
      return __tmp;
    }

    constexpr basic_const_iterator&
    operator+=(difference_type __n)
    noexcept(noexcept(_M_current += __n))
    requires random_access_iterator<_It>
    {
      _M_current += __n;
      return *this;
    }

    constexpr basic_const_iterator&
    operator-=(difference_type __n)
    noexcept(noexcept(_M_current -= __n))
    requires random_access_iterator<_It>
    {
      _M_current -= __n;
      return *this;
    }

    constexpr __reference
    operator[](difference_type __n) const
    noexcept(noexcept(static_cast<__reference>(_M_current[__n])))
    requires random_access_iterator<_It>
    { return static_cast<__reference>(_M_current[__n]); }

    template<sentinel_for<_It> _Sent>
      constexpr bool
      operator==(const _Sent& __s) const
      noexcept(noexcept(_M_current == __s))
      { return _M_current == __s; }

    template<__detail::__not_a_const_iterator _CIt>
      requires __detail::__constant_iterator<_CIt> && convertible_to<_It, _CIt>
    constexpr
    operator _CIt() const&
    { return _M_current; }

    template<__detail::__not_a_const_iterator _CIt>
      requires __detail::__constant_iterator<_CIt> && convertible_to<_It, _CIt>
    constexpr
    operator _CIt() &&
    { return std::move(_M_current); }

    constexpr bool
    operator<(const basic_const_iterator& __y) const
    noexcept(noexcept(_M_current < __y._M_current))
    requires random_access_iterator<_It>
    { return _M_current < __y._M_current; }

    constexpr bool
    operator>(const basic_const_iterator& __y) const
    noexcept(noexcept(_M_current > __y._M_current))
    requires random_access_iterator<_It>
    { return _M_current > __y._M_current; }

    constexpr bool
    operator<=(const basic_const_iterator& __y) const
    noexcept(noexcept(_M_current <= __y._M_current))
    requires random_access_iterator<_It>
    { return _M_current <= __y._M_current; }

    constexpr bool
    operator>=(const basic_const_iterator& __y) const
    noexcept(noexcept(_M_current >= __y._M_current))
    requires random_access_iterator<_It>
    { return _M_current >= __y._M_current; }

    constexpr auto
    operator<=>(const basic_const_iterator& __y) const
    noexcept(noexcept(_M_current <=> __y._M_current))
    requires random_access_iterator<_It> && three_way_comparable<_It>
    { return _M_current <=> __y._M_current; }

    template<__detail::__different_from<basic_const_iterator> _It2>
      constexpr bool
      operator<(const _It2& __y) const
      noexcept(noexcept(_M_current < __y))
      requires random_access_iterator<_It> && totally_ordered_with<_It, _It2>
      { return _M_current < __y; }

    template<__detail::__different_from<basic_const_iterator> _It2>
      constexpr bool
      operator>(const _It2& __y) const
      noexcept(noexcept(_M_current > __y))
      requires random_access_iterator<_It> && totally_ordered_with<_It, _It2>
      { return _M_current > __y; }

    template<__detail::__different_from<basic_const_iterator> _It2>
      constexpr bool
      operator<=(const _It2& __y) const
      noexcept(noexcept(_M_current <= __y))
      requires random_access_iterator<_It> && totally_ordered_with<_It, _It2>
      { return _M_current <= __y; }

    template<__detail::__different_from<basic_const_iterator> _It2>
      constexpr bool
      operator>=(const _It2& __y) const
      noexcept(noexcept(_M_current >= __y))
      requires random_access_iterator<_It> && totally_ordered_with<_It, _It2>
      { return _M_current >= __y; }

    template<__detail::__different_from<basic_const_iterator> _It2>
      constexpr auto
      operator<=>(const _It2& __y) const
      noexcept(noexcept(_M_current <=> __y))
      requires random_access_iterator<_It> && totally_ordered_with<_It, _It2>
 && three_way_comparable_with<_It, _It2>
      { return _M_current <=> __y; }

    template<__detail::__not_a_const_iterator _It2>
      friend constexpr bool
      operator<(const _It2& __x, const basic_const_iterator& __y)
      noexcept(noexcept(__x < __y._M_current))
      requires random_access_iterator<_It> && totally_ordered_with<_It, _It2>
      { return __x < __y._M_current; }

    template<__detail::__not_a_const_iterator _It2>
      friend constexpr bool
      operator>(const _It2& __x, const basic_const_iterator& __y)
      noexcept(noexcept(__x > __y._M_current))
      requires random_access_iterator<_It> && totally_ordered_with<_It, _It2>
      { return __x > __y._M_current; }

    template<__detail::__not_a_const_iterator _It2>
      friend constexpr bool
      operator<=(const _It2& __x, const basic_const_iterator& __y)
      noexcept(noexcept(__x <= __y._M_current))
      requires random_access_iterator<_It> && totally_ordered_with<_It, _It2>
      { return __x <= __y._M_current; }

    template<__detail::__not_a_const_iterator _It2>
      friend constexpr bool
      operator>=(const _It2& __x, const basic_const_iterator& __y)
      noexcept(noexcept(__x >= __y._M_current))
      requires random_access_iterator<_It> && totally_ordered_with<_It, _It2>
      { return __x >= __y._M_current; }

    friend constexpr basic_const_iterator
    operator+(const basic_const_iterator& __i, difference_type __n)
    noexcept(noexcept(basic_const_iterator(__i._M_current + __n)))
    requires random_access_iterator<_It>
    { return basic_const_iterator(__i._M_current + __n); }

    friend constexpr basic_const_iterator
    operator+(difference_type __n, const basic_const_iterator& __i)
    noexcept(noexcept(basic_const_iterator(__i._M_current + __n)))
    requires random_access_iterator<_It>
    { return basic_const_iterator(__i._M_current + __n); }

    friend constexpr basic_const_iterator
    operator-(const basic_const_iterator& __i, difference_type __n)
    noexcept(noexcept(basic_const_iterator(__i._M_current - __n)))
    requires random_access_iterator<_It>
    { return basic_const_iterator(__i._M_current - __n); }

    template<sized_sentinel_for<_It> _Sent>
      constexpr difference_type
      operator-(const _Sent& __y) const
      noexcept(noexcept(_M_current - __y))
      { return _M_current - __y; }

    template<__detail::__not_a_const_iterator _Sent>
      requires sized_sentinel_for<_Sent, _It>
      friend constexpr difference_type
      operator-(const _Sent& __x, const basic_const_iterator& __y)
      noexcept(noexcept(__x - __y._M_current))
      { return __x - __y._M_current; }

    friend constexpr __rvalue_reference
    iter_move(const basic_const_iterator& __i)
    noexcept(noexcept(static_cast<__rvalue_reference>(ranges::iter_move(__i._M_current))))
    { return static_cast<__rvalue_reference>(ranges::iter_move(__i._M_current)); }
  };

  template<typename _Tp, common_with<_Tp> _Up>
    requires input_iterator<common_type_t<_Tp, _Up>>
    struct common_type<basic_const_iterator<_Tp>, _Up>
    { using type = basic_const_iterator<common_type_t<_Tp, _Up>>; };

  template<typename _Tp, common_with<_Tp> _Up>
    requires input_iterator<common_type_t<_Tp, _Up>>
    struct common_type<_Up, basic_const_iterator<_Tp>>
    { using type = basic_const_iterator<common_type_t<_Tp, _Up>>; };

  template<typename _Tp, common_with<_Tp> _Up>
    requires input_iterator<common_type_t<_Tp, _Up>>
    struct common_type<basic_const_iterator<_Tp>, basic_const_iterator<_Up>>
    { using type = basic_const_iterator<common_type_t<_Tp, _Up>>; };

  template<input_iterator _It>
    constexpr const_iterator<_It>
    make_const_iterator(_It __it)
    noexcept(is_nothrow_convertible_v<_It, const_iterator<_It>>)
    { return __it; }

  template<semiregular _Sent>
    constexpr const_sentinel<_Sent>
    make_const_sentinel(_Sent __s)
    noexcept(is_nothrow_convertible_v<_Sent, const_sentinel<_Sent>>)
    { return __s; }





  template<typename _Iterator>
    constexpr
    auto
    __niter_base(move_iterator<_Iterator> __it)
    -> decltype(make_move_iterator(__niter_base(__it.base())))
    { return make_move_iterator(__niter_base(__it.base())); }

  template<typename _Iterator>
    struct __is_move_iterator<move_iterator<_Iterator> >
    {
      enum { __value = 1 };
      typedef __true_type __type;
    };

  template<typename _Iterator>
    constexpr
    auto
    __miter_base(move_iterator<_Iterator> __it)
    -> decltype(__miter_base(__it.base()))
    { return __miter_base(__it.base()); }
# 2984 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_iterator.h" 3
  template<typename _InputIterator>
    using __iter_key_t = remove_const_t<

      tuple_element_t<0, typename iterator_traits<_InputIterator>::value_type>>;




  template<typename _InputIterator>
    using __iter_val_t

      = tuple_element_t<1, typename iterator_traits<_InputIterator>::value_type>;




  template<typename _T1, typename _T2>
    struct pair;

  template<typename _InputIterator>
    using __iter_to_alloc_t
      = pair<const __iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>>;



}
# 38 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ranges_base.h" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ext/numeric_traits.h" 1 3
# 33 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ext/numeric_traits.h" 3




namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
# 50 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ext/numeric_traits.h" 3
  template<typename _Tp>
    struct __is_integer_nonstrict
    : public std::__is_integer<_Tp>
    {
      using std::__is_integer<_Tp>::__value;


      enum { __width = __value ? sizeof(_Tp) * 8 : 0 };
    };

  template<typename _Value>
    struct __numeric_traits_integer
    {

      static_assert(__is_integer_nonstrict<_Value>::__value,
      "invalid specialization");




      static const bool __is_signed = (_Value)(-1) < 0;
      static const int __digits
 = __is_integer_nonstrict<_Value>::__width - __is_signed;


      static const _Value __max = __is_signed
 ? (((((_Value)1 << (__digits - 1)) - 1) << 1) + 1)
 : ~(_Value)0;
      static const _Value __min = __is_signed ? -__max - 1 : (_Value)0;
    };

  template<typename _Value>
    const _Value __numeric_traits_integer<_Value>::__min;

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

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

  template<typename _Value>
    const int __numeric_traits_integer<_Value>::__digits;
# 137 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ext/numeric_traits.h" 3
  template<typename _Tp>
    using __int_traits = __numeric_traits_integer<_Tp>;
# 157 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ext/numeric_traits.h" 3
  template<typename _Value>
    struct __numeric_traits_floating
    {

      static const int __max_digits10 = (2 + (std::__are_same<_Value, float>::__value ? 24 : std::__are_same<_Value, double>::__value ? 53 : 64) * 643L / 2136);


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

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

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

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

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






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

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

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

  template<>
    struct __numeric_traits<long double>
    : public __numeric_traits_floating<long double>
    { };
# 239 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ext/numeric_traits.h" 3
}
# 39 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ranges_base.h" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/max_size_type.h" 1 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/max_size_type.h" 3



# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/numbers" 1 3
# 33 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/numbers" 3


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 36 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/numbers" 2 3





namespace std __attribute__ ((__visibility__ ("default")))
{
# 51 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/numbers" 3
namespace numbers
{


  template<typename _Tp>
    using _Enable_if_floating = enable_if_t<is_floating_point_v<_Tp>, _Tp>;



  template<typename _Tp>
    inline constexpr _Tp e_v
      = _Enable_if_floating<_Tp>(2.718281828459045235360287471352662498L);


  template<typename _Tp>
    inline constexpr _Tp log2e_v
      = _Enable_if_floating<_Tp>(1.442695040888963407359924681001892137L);


  template<typename _Tp>
    inline constexpr _Tp log10e_v
      = _Enable_if_floating<_Tp>(0.434294481903251827651128918916605082L);


  template<typename _Tp>
    inline constexpr _Tp pi_v
      = _Enable_if_floating<_Tp>(3.141592653589793238462643383279502884L);


  template<typename _Tp>
    inline constexpr _Tp inv_pi_v
      = _Enable_if_floating<_Tp>(0.318309886183790671537767526745028724L);


  template<typename _Tp>
    inline constexpr _Tp inv_sqrtpi_v
      = _Enable_if_floating<_Tp>(0.564189583547756286948079451560772586L);


  template<typename _Tp>
    inline constexpr _Tp ln2_v
      = _Enable_if_floating<_Tp>(0.693147180559945309417232121458176568L);


  template<typename _Tp>
    inline constexpr _Tp ln10_v
      = _Enable_if_floating<_Tp>(2.302585092994045684017991454684364208L);


  template<typename _Tp>
    inline constexpr _Tp sqrt2_v
      = _Enable_if_floating<_Tp>(1.414213562373095048801688724209698079L);


  template<typename _Tp>
    inline constexpr _Tp sqrt3_v
      = _Enable_if_floating<_Tp>(1.732050807568877293527446341505872367L);


  template<typename _Tp>
    inline constexpr _Tp inv_sqrt3_v
      = _Enable_if_floating<_Tp>(0.577350269189625764509148780501957456L);


  template<typename _Tp>
    inline constexpr _Tp egamma_v
      = _Enable_if_floating<_Tp>(0.577215664901532860606512090082402431L);


  template<typename _Tp>
    inline constexpr _Tp phi_v
      = _Enable_if_floating<_Tp>(1.618033988749894848204586834365638118L);

  inline constexpr double e = e_v<double>;
  inline constexpr double log2e = log2e_v<double>;
  inline constexpr double log10e = log10e_v<double>;
  inline constexpr double pi = pi_v<double>;
  inline constexpr double inv_pi = inv_pi_v<double>;
  inline constexpr double inv_sqrtpi = inv_sqrtpi_v<double>;
  inline constexpr double ln2 = ln2_v<double>;
  inline constexpr double ln10 = ln10_v<double>;
  inline constexpr double sqrt2 = sqrt2_v<double>;
  inline constexpr double sqrt3 = sqrt3_v<double>;
  inline constexpr double inv_sqrt3 = inv_sqrt3_v<double>;
  inline constexpr double egamma = egamma_v<double>;
  inline constexpr double phi = phi_v<double>;
# 225 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/numbers" 3
template<> inline constexpr __float128 e_v<__float128> = 2.718281828459045235360287471352662498Q; template<> inline constexpr __float128 log2e_v<__float128> = 1.442695040888963407359924681001892137Q; template<> inline constexpr __float128 log10e_v<__float128> = 0.434294481903251827651128918916605082Q; template<> inline constexpr __float128 pi_v<__float128> = 3.141592653589793238462643383279502884Q; template<> inline constexpr __float128 inv_pi_v<__float128> = 0.318309886183790671537767526745028724Q; template<> inline constexpr __float128 inv_sqrtpi_v<__float128> = 0.564189583547756286948079451560772586Q; template<> inline constexpr __float128 ln2_v<__float128> = 0.693147180559945309417232121458176568Q; template<> inline constexpr __float128 ln10_v<__float128> = 2.302585092994045684017991454684364208Q; template<> inline constexpr __float128 sqrt2_v<__float128> = 1.414213562373095048801688724209698079Q; template<> inline constexpr __float128 sqrt3_v<__float128> = 1.732050807568877293527446341505872367Q; template<> inline constexpr __float128 inv_sqrt3_v<__float128> = 0.577350269189625764509148780501957456Q; template<> inline constexpr __float128 egamma_v<__float128> = 0.577215664901532860606512090082402431Q; template<> inline constexpr __float128 phi_v<__float128> = 1.618033988749894848204586834365638118Q;




}


}
# 38 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/max_size_type.h" 2 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/max_size_type.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{


template<typename _Tp>
  struct numeric_limits;

namespace ranges
{
  namespace __detail
  {
    class __max_size_type
    {
    public:
      __max_size_type() = default;

      template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>
 constexpr
 __max_size_type(_Tp __i) noexcept
   : _M_val(__i), _M_msb(__i < 0)
 { }

      constexpr explicit
      __max_size_type(const __max_diff_type& __d) noexcept;

      template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>
 constexpr explicit
 operator _Tp() const noexcept
 { return _M_val; }

      constexpr explicit
      operator bool() const noexcept
      { return _M_val != 0 || _M_msb != 0; }

      constexpr __max_size_type
      operator+() const noexcept
      { return *this; }

      constexpr __max_size_type
      operator~() const noexcept
      { return __max_size_type{~_M_val, !_M_msb}; }

      constexpr __max_size_type
      operator-() const noexcept
      { return operator~() + 1; }

      constexpr __max_size_type&
      operator++() noexcept
      { return *this += 1; }

      constexpr __max_size_type
      operator++(int) noexcept
      {
 auto __tmp = *this;
 ++*this;
 return __tmp;
      }

      constexpr __max_size_type&
      operator--() noexcept
      { return *this -= 1; }

      constexpr __max_size_type
      operator--(int) noexcept
      {
 auto __tmp = *this;
 --*this;
 return __tmp;
      }

      constexpr __max_size_type&
      operator+=(const __max_size_type& __r) noexcept
      {
 const auto __sum = _M_val + __r._M_val;
 const bool __overflow = (__sum < _M_val);
 _M_msb = _M_msb ^ __r._M_msb ^ __overflow;
 _M_val = __sum;
 return *this;
      }

      constexpr __max_size_type&
      operator-=(const __max_size_type& __r) noexcept
      { return *this += -__r; }

      constexpr __max_size_type&
      operator*=(__max_size_type __r) noexcept
      {
 constexpr __max_size_type __threshold
   = __rep(1) << (_S_rep_bits / 2 - 1);
 if (_M_val < __threshold && __r < __threshold)


   _M_val = _M_val * __r._M_val;
 else
   {



     const bool __lsb = _M_val & 1;
     const bool __rlsb = __r._M_val & 1;
     *this >>= 1;
     __r >>= 1;
     _M_val = (2 * _M_val * __r._M_val
        + _M_val * __rlsb + __r._M_val * __lsb);
     *this <<= 1;
     *this += __rlsb * __lsb;
   }

 return *this;
      }

      constexpr __max_size_type&
      operator/=(const __max_size_type& __r) noexcept
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__r != 0), false)) std::__glibcxx_assert_fail(); } while (false);

 if (!_M_msb && !__r._M_msb) [[likely]]
   _M_val /= __r._M_val;
 else if (_M_msb && __r._M_msb)
   {
     _M_val = (_M_val >= __r._M_val);
     _M_msb = 0;
   }
 else if (!_M_msb && __r._M_msb)
   _M_val = 0;
 else if (_M_msb && !__r._M_msb)
   {




     const auto __orig = *this;
     *this >>= 1;
     _M_val /= __r._M_val;
     *this <<= 1;
     if (__orig - *this * __r >= __r)
       ++_M_val;
   }
 return *this;
      }

      constexpr __max_size_type&
      operator%=(const __max_size_type& __r) noexcept
      {
 if (!_M_msb && !__r._M_msb) [[likely]]
   _M_val %= __r._M_val;
 else
   *this -= (*this / __r) * __r;
 return *this;
      }

      constexpr __max_size_type&
      operator<<=(const __max_size_type& __r) noexcept
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__r <= _S_rep_bits), false)) std::__glibcxx_assert_fail(); } while (false);
 if (__r != 0)
   {
     _M_msb = (_M_val >> (_S_rep_bits - __r._M_val)) & 1;

     if (__r._M_val == _S_rep_bits) [[unlikely]]
       _M_val = 0;
     else
       _M_val <<= __r._M_val;
   }
 return *this;
      }

      constexpr __max_size_type&
      operator>>=(const __max_size_type& __r) noexcept
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__r <= _S_rep_bits), false)) std::__glibcxx_assert_fail(); } while (false);
 if (__r != 0)
   {
     if (__r._M_val == _S_rep_bits) [[unlikely]]
       _M_val = 0;
     else
       _M_val >>= __r._M_val;

     if (_M_msb) [[unlikely]]
       {
  _M_val |= __rep(1) << (_S_rep_bits - __r._M_val);
  _M_msb = 0;
       }
   }
 return *this;
      }

      constexpr __max_size_type&
      operator&=(const __max_size_type& __r) noexcept
      {
 _M_val &= __r._M_val;
 _M_msb &= __r._M_msb;
 return *this;
      }

      constexpr __max_size_type&
      operator|=(const __max_size_type& __r) noexcept
      {
 _M_val |= __r._M_val;
 _M_msb |= __r._M_msb;
 return *this;
      }

      constexpr __max_size_type&
      operator^=(const __max_size_type& __r) noexcept
      {
 _M_val ^= __r._M_val;
 _M_msb ^= __r._M_msb;
 return *this;
      }

      template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>
 friend constexpr _Tp&
 operator+=(_Tp& __a, const __max_size_type& __b) noexcept
 { return (__a = static_cast<_Tp>(__a + __b)); }

      template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>
 friend constexpr _Tp&
 operator-=(_Tp& __a, const __max_size_type& __b) noexcept
 { return (__a = static_cast<_Tp>(__a - __b)); }

      template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>
 friend constexpr _Tp&
 operator*=(_Tp& __a, const __max_size_type& __b) noexcept
 { return (__a = static_cast<_Tp>(__a * __b)); }

      template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>
 friend constexpr _Tp&
 operator/=(_Tp& __a, const __max_size_type& __b) noexcept
 { return (__a = static_cast<_Tp>(__a / __b)); }

      template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>
 friend constexpr _Tp&
 operator%=(_Tp& __a, const __max_size_type& __b) noexcept
 { return (__a = static_cast<_Tp>(__a % __b)); }

      template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>
 friend constexpr _Tp&
 operator&=(_Tp& __a, const __max_size_type& __b) noexcept
 { return (__a = static_cast<_Tp>(__a & __b)); }

      template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>
 friend constexpr _Tp&
 operator|=(_Tp& __a, const __max_size_type& __b) noexcept
 { return (__a = static_cast<_Tp>(__a | __b)); }

      template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>
 friend constexpr _Tp&
 operator^=(_Tp& __a, const __max_size_type& __b) noexcept
 { return (__a = static_cast<_Tp>(__a ^ __b)); }

      template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>
 friend constexpr _Tp&
 operator<<=(_Tp& __a, const __max_size_type& __b) noexcept
 { return (__a = static_cast<_Tp>(__a << __b)); }

      template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>
 friend constexpr _Tp&
 operator>>=(_Tp& __a, const __max_size_type& __b) noexcept
 { return (__a = static_cast<_Tp>(__a >> __b)); }

      friend constexpr __max_size_type
      operator+(__max_size_type __l, const __max_size_type& __r) noexcept
      {
 __l += __r;
 return __l;
      }

      friend constexpr __max_size_type
      operator-(__max_size_type __l, const __max_size_type& __r) noexcept
      {
 __l -= __r;
 return __l;
      }

      friend constexpr __max_size_type
      operator*(__max_size_type __l, const __max_size_type& __r) noexcept
      {
 __l *= __r;
 return __l;
      }

      friend constexpr __max_size_type
      operator/(__max_size_type __l, const __max_size_type& __r) noexcept
      {
 __l /= __r;
 return __l;
      }

      friend constexpr __max_size_type
      operator%(__max_size_type __l, const __max_size_type& __r) noexcept
      {
 __l %= __r;
 return __l;
      }

      friend constexpr __max_size_type
      operator<<(__max_size_type __l, const __max_size_type& __r) noexcept
      {
 __l <<= __r;
 return __l;
      }

      friend constexpr __max_size_type
      operator>>(__max_size_type __l, const __max_size_type& __r) noexcept
      {
 __l >>= __r;
 return __l;
      }

      friend constexpr __max_size_type
      operator&(__max_size_type __l, const __max_size_type& __r) noexcept
      {
 __l &= __r;
 return __l;
      }

      friend constexpr __max_size_type
      operator|(__max_size_type __l, const __max_size_type& __r) noexcept
      {
 __l |= __r;
 return __l;
      }

      friend constexpr __max_size_type
      operator^(__max_size_type __l, const __max_size_type& __r) noexcept
      {
 __l ^= __r;
 return __l;
      }

      friend constexpr bool
      operator==(const __max_size_type& __l, const __max_size_type& __r) noexcept
      { return __l._M_val == __r._M_val && __l._M_msb == __r._M_msb; }


      friend constexpr strong_ordering
      operator<=>(const __max_size_type& __l, const __max_size_type& __r) noexcept
      {
 if (__l._M_msb ^ __r._M_msb)
   return __l._M_msb ? strong_ordering::greater : strong_ordering::less;
 else
   return __l._M_val <=> __r._M_val;
      }
# 420 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/max_size_type.h" 3
      __extension__
      using __rep = unsigned __int128;



      static constexpr size_t _S_rep_bits = sizeof(__rep) * 8;
    private:
      __rep _M_val = 0;
      unsigned _M_msb:1 = 0;

      constexpr explicit
      __max_size_type(__rep __val, int __msb) noexcept
 : _M_val(__val), _M_msb(__msb)
      { }

      friend __max_diff_type;
      friend std::numeric_limits<__max_size_type>;
      friend std::numeric_limits<__max_diff_type>;
    };

    class __max_diff_type
    {
    public:
      __max_diff_type() = default;

      template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>
 constexpr
 __max_diff_type(_Tp __i) noexcept
   : _M_rep(__i)
 { }

      constexpr explicit
      __max_diff_type(const __max_size_type& __d) noexcept
 : _M_rep(__d)
      { }

      template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>
 constexpr explicit
 operator _Tp() const noexcept
 { return static_cast<_Tp>(_M_rep); }

      constexpr explicit
      operator bool() const noexcept
      { return _M_rep != 0; }

      constexpr __max_diff_type
      operator+() const noexcept
      { return *this; }

      constexpr __max_diff_type
      operator-() const noexcept
      { return __max_diff_type(-_M_rep); }

      constexpr __max_diff_type
      operator~() const noexcept
      { return __max_diff_type(~_M_rep); }

      constexpr __max_diff_type&
      operator++() noexcept
      { return *this += 1; }

      constexpr __max_diff_type
      operator++(int) noexcept
      {
 auto __tmp = *this;
 ++*this;
 return __tmp;
      }

      constexpr __max_diff_type&
      operator--() noexcept
      { return *this -= 1; }

      constexpr __max_diff_type
      operator--(int) noexcept
      {
 auto __tmp = *this;
 --*this;
 return __tmp;
      }

      constexpr __max_diff_type&
      operator+=(const __max_diff_type& __r) noexcept
      {
 _M_rep += __r._M_rep;
 return *this;
      }

      constexpr __max_diff_type&
      operator-=(const __max_diff_type& __r) noexcept
      {
 _M_rep -= __r._M_rep;
 return *this;
      }

      constexpr __max_diff_type&
      operator*=(const __max_diff_type& __r) noexcept
      {
 _M_rep *= __r._M_rep;
 return *this;
      }

      constexpr __max_diff_type&
      operator/=(const __max_diff_type& __r) noexcept
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__r != 0), false)) std::__glibcxx_assert_fail(); } while (false);
 const bool __neg = *this < 0;
 const bool __rneg = __r < 0;
 if (!__neg && !__rneg)
   _M_rep = _M_rep / __r._M_rep;
 else if (__neg && __rneg)
   _M_rep = -_M_rep / -__r._M_rep;
 else if (__neg && !__rneg)
   _M_rep = -(-_M_rep / __r._M_rep);
 else
   _M_rep = -(_M_rep / -__r._M_rep);
 return *this ;
      }

      constexpr __max_diff_type&
      operator%=(const __max_diff_type& __r) noexcept
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__r != 0), false)) std::__glibcxx_assert_fail(); } while (false);
 if (*this >= 0 && __r > 0)
   _M_rep %= __r._M_rep;
 else
   *this -= (*this / __r) * __r;
 return *this;
      }

      constexpr __max_diff_type&
      operator<<=(const __max_diff_type& __r) noexcept
      {
 _M_rep.operator<<=(__r._M_rep);
 return *this;
      }

      constexpr __max_diff_type&
      operator>>=(const __max_diff_type& __r) noexcept
      {

 const auto __msb = _M_rep._M_msb;
 _M_rep >>= __r._M_rep;
 if (__msb)
   _M_rep |= ~(__max_size_type(-1) >> __r._M_rep);
 return *this;
      }

      constexpr __max_diff_type&
      operator&=(const __max_diff_type& __r) noexcept
      {
 _M_rep &= __r._M_rep;
 return *this;
      }

      constexpr __max_diff_type&
      operator|=(const __max_diff_type& __r) noexcept
      {
 _M_rep |= __r._M_rep;
 return *this;
      }

      constexpr __max_diff_type&
      operator^=(const __max_diff_type& __r) noexcept
      {
 _M_rep ^= __r._M_rep;
 return *this;
      }

      template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>
 friend constexpr _Tp&
 operator+=(_Tp& __a, const __max_diff_type& __b) noexcept
 { return (__a = static_cast<_Tp>(__a + __b)); }

      template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>
 friend constexpr _Tp&
 operator-=(_Tp& __a, const __max_diff_type& __b) noexcept
 { return (__a = static_cast<_Tp>(__a - __b)); }

      template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>
 friend constexpr _Tp&
 operator*=(_Tp& __a, const __max_diff_type& __b) noexcept
 { return (__a = static_cast<_Tp>(__a * __b)); }

      template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>
 friend constexpr _Tp&
 operator/=(_Tp& __a, const __max_diff_type& __b) noexcept
 { return (__a = static_cast<_Tp>(__a / __b)); }

      template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>
 friend constexpr _Tp&
 operator%=(_Tp& __a, const __max_diff_type& __b) noexcept
 { return (__a = static_cast<_Tp>(__a % __b)); }

      template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>
 friend constexpr _Tp&
 operator&=(_Tp& __a, const __max_diff_type& __b) noexcept
 { return (__a = static_cast<_Tp>(__a & __b)); }

      template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>
 friend constexpr _Tp&
 operator|=(_Tp& __a, const __max_diff_type& __b) noexcept
 { return (__a = static_cast<_Tp>(__a | __b)); }

      template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>
 friend constexpr _Tp&
 operator^=(_Tp& __a, const __max_diff_type& __b) noexcept
 { return (__a = static_cast<_Tp>(__a ^ __b)); }

      template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>
 friend constexpr _Tp&
 operator<<=(_Tp& __a, const __max_diff_type& __b) noexcept
 { return (__a = static_cast<_Tp>(__a << __b)); }

      template<typename _Tp> requires integral<_Tp> || __is_int128<_Tp>
 friend constexpr _Tp&
 operator>>=(_Tp& __a, const __max_diff_type& __b) noexcept
 { return (__a = static_cast<_Tp>(__a >> __b)); }

      friend constexpr __max_diff_type
      operator+(__max_diff_type __l, const __max_diff_type& __r) noexcept
      {
 __l += __r;
 return __l;
      }

      friend constexpr __max_diff_type
      operator-(__max_diff_type __l, const __max_diff_type& __r) noexcept
      {
 __l -= __r;
 return __l;
      }

      friend constexpr __max_diff_type
      operator*(__max_diff_type __l, const __max_diff_type& __r) noexcept
      {
 __l *= __r;
 return __l;
      }

      friend constexpr __max_diff_type
      operator/(__max_diff_type __l, const __max_diff_type& __r) noexcept
      {
 __l /= __r;
 return __l;
      }

      friend constexpr __max_diff_type
      operator%(__max_diff_type __l, const __max_diff_type& __r) noexcept
      {
 __l %= __r;
 return __l;
      }

      friend constexpr __max_diff_type
      operator<<(__max_diff_type __l, const __max_diff_type& __r) noexcept
      {
 __l <<= __r;
 return __l;
      }

      friend constexpr __max_diff_type
      operator>>(__max_diff_type __l, const __max_diff_type& __r) noexcept
      {
 __l >>= __r;
 return __l;
      }

      friend constexpr __max_diff_type
      operator&(__max_diff_type __l, const __max_diff_type& __r) noexcept
      {
 __l &= __r;
 return __l;
      }

      friend constexpr __max_diff_type
      operator|(__max_diff_type __l, const __max_diff_type& __r) noexcept
      {
 __l |= __r;
 return __l;
      }

      friend constexpr __max_diff_type
      operator^(__max_diff_type __l, const __max_diff_type& __r) noexcept
      {
 __l ^= __r;
 return __l;
      }

      friend constexpr bool
      operator==(const __max_diff_type& __l, const __max_diff_type& __r) noexcept
      { return __l._M_rep == __r._M_rep; }


      constexpr strong_ordering
      operator<=>(const __max_diff_type& __r) const noexcept
      {
 const auto __lsign = _M_rep._M_msb;
 const auto __rsign = __r._M_rep._M_msb;
 if (__lsign ^ __rsign)
   return __lsign ? strong_ordering::less : strong_ordering::greater;
 else
   return _M_rep <=> __r._M_rep;
      }
# 753 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/max_size_type.h" 3
    private:
      __max_size_type _M_rep = 0;

      friend class __max_size_type;
    };

    constexpr
    __max_size_type::__max_size_type(const __max_diff_type& __d) noexcept
      : __max_size_type(__d._M_rep)
    { }

  }
}

  template<>
    struct numeric_limits<ranges::__detail::__max_size_type>
    {
      using _Sp = ranges::__detail::__max_size_type;
      static constexpr bool is_specialized = true;
      static constexpr bool is_signed = false;
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int digits
 = __gnu_cxx::__int_traits<_Sp::__rep>::__digits + 1;
      static constexpr int digits10
 = static_cast<int>(digits * numbers::ln2 / numbers::ln10);

      static constexpr _Sp
      min() noexcept
      { return 0; }

      static constexpr _Sp
      max() noexcept
      { return _Sp(static_cast<_Sp::__rep>(-1), 1); }

      static constexpr _Sp
      lowest() noexcept
      { return min(); }
    };

  template<>
    struct numeric_limits<ranges::__detail::__max_diff_type>
    {
      using _Dp = ranges::__detail::__max_diff_type;
      using _Sp = ranges::__detail::__max_size_type;
      static constexpr bool is_specialized = true;
      static constexpr bool is_signed = true;
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int digits = numeric_limits<_Sp>::digits - 1;
      static constexpr int digits10
 = static_cast<int>(digits * numbers::ln2 / numbers::ln10);

      static constexpr _Dp
      min() noexcept
      { return _Dp(_Sp(0, 1)); }

      static constexpr _Dp
      max() noexcept
      { return _Dp(_Sp(static_cast<_Sp::__rep>(-1), 0)); }

      static constexpr _Dp
      lowest() noexcept
      { return min(); }
    };


}
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ranges_base.h" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 41 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ranges_base.h" 2 3


namespace std __attribute__ ((__visibility__ ("default")))
{

namespace ranges
{
  template<typename>
    inline constexpr bool disable_sized_range = false;

  template<typename _Tp>
    inline constexpr bool enable_borrowed_range = false;

  namespace __detail
  {
    constexpr __max_size_type
    __to_unsigned_like(__max_size_type __t) noexcept
    { return __t; }

    constexpr __max_size_type
    __to_unsigned_like(__max_diff_type __t) noexcept
    { return __max_size_type(__t); }

    template<integral _Tp>
      constexpr auto
      __to_unsigned_like(_Tp __t) noexcept
      { return static_cast<make_unsigned_t<_Tp>>(__t); }
# 79 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ranges_base.h" 3
    template<typename _Tp>
      using __make_unsigned_like_t
 = decltype(__detail::__to_unsigned_like(std::declval<_Tp>()));


    template<typename _Tp>
      concept __maybe_borrowed_range
 = is_lvalue_reference_v<_Tp>
   || enable_borrowed_range<remove_cvref_t<_Tp>>;

  }


  namespace __access
  {
    using std::ranges::__detail::__maybe_borrowed_range;
    using std::__detail::__range_iter_t;

    struct _Begin
    {
    private:
      template<typename _Tp>
 static constexpr bool
 _S_noexcept()
 {
   if constexpr (is_array_v<remove_reference_t<_Tp>>)
     return true;
   else if constexpr (__member_begin<_Tp>)
     return noexcept(__decay_copy(std::declval<_Tp&>().begin()));
   else
     return noexcept(__decay_copy(begin(std::declval<_Tp&>())));
 }

    public:
      template<__maybe_borrowed_range _Tp>
 requires is_array_v<remove_reference_t<_Tp>> || __member_begin<_Tp>
   || __adl_begin<_Tp>
 constexpr auto
 operator()[[nodiscard]](_Tp&& __t) const noexcept(_S_noexcept<_Tp&>())
 {
   if constexpr (is_array_v<remove_reference_t<_Tp>>)
     {
       static_assert(is_lvalue_reference_v<_Tp>);
       return __t + 0;
     }
   else if constexpr (__member_begin<_Tp>)
     return __t.begin();
   else
     return begin(__t);
 }
    };

    template<typename _Tp>
      concept __member_end = requires(_Tp& __t)
 {
   { __decay_copy(__t.end()) } -> sentinel_for<__range_iter_t<_Tp>>;
 };


    void end() = delete;

    template<typename _Tp>
      concept __adl_end = __class_or_enum<remove_reference_t<_Tp>>
 && requires(_Tp& __t)
 {
   { __decay_copy(end(__t)) } -> sentinel_for<__range_iter_t<_Tp>>;
 };

    struct _End
    {
    private:
      template<typename _Tp>
 static constexpr bool
 _S_noexcept()
 {
   if constexpr (is_bounded_array_v<remove_reference_t<_Tp>>)
     return true;
   else if constexpr (__member_end<_Tp>)
     return noexcept(__decay_copy(std::declval<_Tp&>().end()));
   else
     return noexcept(__decay_copy(end(std::declval<_Tp&>())));
 }

    public:
      template<__maybe_borrowed_range _Tp>
 requires is_bounded_array_v<remove_reference_t<_Tp>>
   || __member_end<_Tp> || __adl_end<_Tp>
 constexpr auto
 operator()[[nodiscard]](_Tp&& __t) const noexcept(_S_noexcept<_Tp&>())
 {
   if constexpr (is_bounded_array_v<remove_reference_t<_Tp>>)
     {
       static_assert(is_lvalue_reference_v<_Tp>);
       return __t + extent_v<remove_reference_t<_Tp>>;
     }
   else if constexpr (__member_end<_Tp>)
     return __t.end();
   else
     return end(__t);
 }
    };

    template<typename _Tp>
      concept __member_rbegin = requires(_Tp& __t)
 {
   { __decay_copy(__t.rbegin()) } -> input_or_output_iterator;
 };

    void rbegin() = delete;

    template<typename _Tp>
      concept __adl_rbegin = __class_or_enum<remove_reference_t<_Tp>>
 && requires(_Tp& __t)
 {
   { __decay_copy(rbegin(__t)) } -> input_or_output_iterator;
 };

    template<typename _Tp>
      concept __reversable = requires(_Tp& __t)
 {
   { _Begin{}(__t) } -> bidirectional_iterator;
   { _End{}(__t) } -> same_as<decltype(_Begin{}(__t))>;
 };

    struct _RBegin
    {
    private:
      template<typename _Tp>
 static constexpr bool
 _S_noexcept()
 {
   if constexpr (__member_rbegin<_Tp>)
     return noexcept(__decay_copy(std::declval<_Tp&>().rbegin()));
   else if constexpr (__adl_rbegin<_Tp>)
     return noexcept(__decay_copy(rbegin(std::declval<_Tp&>())));
   else
     {
       if constexpr (noexcept(_End{}(std::declval<_Tp&>())))
  {
    using _It = decltype(_End{}(std::declval<_Tp&>()));

    return is_nothrow_copy_constructible_v<_It>;
  }
       else
  return false;
     }
 }

    public:
      template<__maybe_borrowed_range _Tp>
 requires __member_rbegin<_Tp> || __adl_rbegin<_Tp> || __reversable<_Tp>
 constexpr auto
 operator()[[nodiscard]](_Tp&& __t) const
 noexcept(_S_noexcept<_Tp&>())
 {
   if constexpr (__member_rbegin<_Tp>)
     return __t.rbegin();
   else if constexpr (__adl_rbegin<_Tp>)
     return rbegin(__t);
   else
     return std::make_reverse_iterator(_End{}(__t));
 }
    };

    template<typename _Tp>
      concept __member_rend = requires(_Tp& __t)
 {
   { __decay_copy(__t.rend()) }
     -> sentinel_for<decltype(_RBegin{}(std::forward<_Tp>(__t)))>;
 };

    void rend() = delete;

    template<typename _Tp>
      concept __adl_rend = __class_or_enum<remove_reference_t<_Tp>>
 && requires(_Tp& __t)
 {
   { __decay_copy(rend(__t)) }
     -> sentinel_for<decltype(_RBegin{}(std::forward<_Tp>(__t)))>;
 };

    struct _REnd
    {
    private:
      template<typename _Tp>
 static constexpr bool
 _S_noexcept()
 {
   if constexpr (__member_rend<_Tp>)
     return noexcept(__decay_copy(std::declval<_Tp&>().rend()));
   else if constexpr (__adl_rend<_Tp>)
     return noexcept(__decay_copy(rend(std::declval<_Tp&>())));
   else
     {
       if constexpr (noexcept(_Begin{}(std::declval<_Tp&>())))
  {
    using _It = decltype(_Begin{}(std::declval<_Tp&>()));

    return is_nothrow_copy_constructible_v<_It>;
  }
       else
  return false;
     }
 }

    public:
      template<__maybe_borrowed_range _Tp>
 requires __member_rend<_Tp> || __adl_rend<_Tp> || __reversable<_Tp>
 constexpr auto
 operator()[[nodiscard]](_Tp&& __t) const
 noexcept(_S_noexcept<_Tp&>())
 {
   if constexpr (__member_rend<_Tp>)
     return __t.rend();
   else if constexpr (__adl_rend<_Tp>)
     return rend(__t);
   else
     return std::make_reverse_iterator(_Begin{}(__t));
 }
    };

    template<typename _Tp>
      concept __member_size = !disable_sized_range<remove_cvref_t<_Tp>>
 && requires(_Tp& __t)
 {
   { __decay_copy(__t.size()) } -> __detail::__is_integer_like;
 };

    void size() = delete;

    template<typename _Tp>
      concept __adl_size = __class_or_enum<remove_reference_t<_Tp>>
 && !disable_sized_range<remove_cvref_t<_Tp>>
 && requires(_Tp& __t)
 {
   { __decay_copy(size(__t)) } -> __detail::__is_integer_like;
 };

    template<typename _Tp>
      concept __sentinel_size = requires(_Tp& __t)
 {
   requires (!is_unbounded_array_v<remove_reference_t<_Tp>>);

   { _Begin{}(__t) } -> forward_iterator;

   { _End{}(__t) } -> sized_sentinel_for<decltype(_Begin{}(__t))>;

   __detail::__to_unsigned_like(_End{}(__t) - _Begin{}(__t));
 };

    struct _Size
    {
    private:
      template<typename _Tp>
 static constexpr bool
 _S_noexcept()
 {
   if constexpr (is_bounded_array_v<remove_reference_t<_Tp>>)
     return true;
   else if constexpr (__member_size<_Tp>)
     return noexcept(__decay_copy(std::declval<_Tp&>().size()));
   else if constexpr (__adl_size<_Tp>)
     return noexcept(__decay_copy(size(std::declval<_Tp&>())));
   else if constexpr (__sentinel_size<_Tp>)
     return noexcept(_End{}(std::declval<_Tp&>())
       - _Begin{}(std::declval<_Tp&>()));
 }

    public:
      template<typename _Tp>
 requires is_bounded_array_v<remove_reference_t<_Tp>>
   || __member_size<_Tp> || __adl_size<_Tp> || __sentinel_size<_Tp>
 constexpr auto
 operator()[[nodiscard]](_Tp&& __t) const noexcept(_S_noexcept<_Tp&>())
 {
   if constexpr (is_bounded_array_v<remove_reference_t<_Tp>>)
     return extent_v<remove_reference_t<_Tp>>;
   else if constexpr (__member_size<_Tp>)
     return __t.size();
   else if constexpr (__adl_size<_Tp>)
     return size(__t);
   else if constexpr (__sentinel_size<_Tp>)
     return __detail::__to_unsigned_like(_End{}(__t) - _Begin{}(__t));
 }
    };

    struct _SSize
    {


      template<typename _Tp>
 requires requires (_Tp& __t) { _Size{}(__t); }
 constexpr auto
 operator()[[nodiscard]](_Tp&& __t) const noexcept(noexcept(_Size{}(__t)))
 {
   auto __size = _Size{}(__t);
   using __size_type = decltype(__size);

   if constexpr (integral<__size_type>)
     {
       using __gnu_cxx::__int_traits;
       if constexpr (__int_traits<__size_type>::__digits
       < __int_traits<ptrdiff_t>::__digits)
  return static_cast<ptrdiff_t>(__size);
       else
  return static_cast<make_signed_t<__size_type>>(__size);
     }





   else
     return __detail::__max_diff_type(__size);
 }
    };

    template<typename _Tp>
      concept __member_empty = requires(_Tp& __t) { bool(__t.empty()); };

    template<typename _Tp>
      concept __size0_empty = requires(_Tp& __t) { _Size{}(__t) == 0; };

    template<typename _Tp>
      concept __eq_iter_empty = requires(_Tp& __t)
 {
   requires (!is_unbounded_array_v<remove_reference_t<_Tp>>);

   { _Begin{}(__t) } -> forward_iterator;

   bool(_Begin{}(__t) == _End{}(__t));
 };

    struct _Empty
    {
    private:
      template<typename _Tp>
 static constexpr bool
 _S_noexcept()
 {
   if constexpr (__member_empty<_Tp>)
     return noexcept(bool(std::declval<_Tp&>().empty()));
   else if constexpr (__size0_empty<_Tp>)
     return noexcept(_Size{}(std::declval<_Tp&>()) == 0);
   else
     return noexcept(bool(_Begin{}(std::declval<_Tp&>())
  == _End{}(std::declval<_Tp&>())));
 }

    public:
      template<typename _Tp>
 requires __member_empty<_Tp> || __size0_empty<_Tp>
   || __eq_iter_empty<_Tp>
 constexpr bool
 operator()[[nodiscard]](_Tp&& __t) const noexcept(_S_noexcept<_Tp&>())
 {
   if constexpr (__member_empty<_Tp>)
     return bool(__t.empty());
   else if constexpr (__size0_empty<_Tp>)
     return _Size{}(__t) == 0;
   else
     return bool(_Begin{}(__t) == _End{}(__t));
 }
    };

    template<typename _Tp>
      concept __pointer_to_object = is_pointer_v<_Tp>
        && is_object_v<remove_pointer_t<_Tp>>;

    template<typename _Tp>
      concept __member_data = requires(_Tp& __t)
 {
   { __decay_copy(__t.data()) } -> __pointer_to_object;
 };

    template<typename _Tp>
      concept __begin_data = contiguous_iterator<__range_iter_t<_Tp>>;

    struct _Data
    {
    private:
      template<typename _Tp>
 static constexpr bool
 _S_noexcept()
 {
   if constexpr (__member_data<_Tp>)
     return noexcept(__decay_copy(std::declval<_Tp&>().data()));
   else
     return noexcept(_Begin{}(std::declval<_Tp&>()));
 }

    public:
      template<__maybe_borrowed_range _Tp>
 requires __member_data<_Tp> || __begin_data<_Tp>
 constexpr auto
 operator()[[nodiscard]](_Tp&& __t) const noexcept(_S_noexcept<_Tp>())
 {
   if constexpr (__member_data<_Tp>)
     return __t.data();
   else
     return std::to_address(_Begin{}(__t));
 }
    };

  }

  inline namespace _Cpo
  {
    inline constexpr ranges::__access::_Begin begin{};
    inline constexpr ranges::__access::_End end{};
    inline constexpr ranges::__access::_RBegin rbegin{};
    inline constexpr ranges::__access::_REnd rend{};
    inline constexpr ranges::__access::_Size size{};
    inline constexpr ranges::__access::_SSize ssize{};
    inline constexpr ranges::__access::_Empty empty{};
    inline constexpr ranges::__access::_Data data{};
  }


  template<typename _Tp>
    concept range = requires(_Tp& __t)
      {
 ranges::begin(__t);
 ranges::end(__t);
      };


  template<typename _Tp>
    concept borrowed_range
      = range<_Tp> && __detail::__maybe_borrowed_range<_Tp>;

  template<typename _Tp>
    using iterator_t = std::__detail::__range_iter_t<_Tp>;

  template<range _Range>
    using sentinel_t = decltype(ranges::end(std::declval<_Range&>()));


  template<range _Range>
    using const_iterator_t = const_iterator<iterator_t<_Range>>;

  template<range _Range>
    using const_sentinel_t = const_sentinel<sentinel_t<_Range>>;

  template<range _Range>
    using range_const_reference_t = iter_const_reference_t<iterator_t<_Range>>;


  template<range _Range>
    using range_difference_t = iter_difference_t<iterator_t<_Range>>;

  template<range _Range>
    using range_value_t = iter_value_t<iterator_t<_Range>>;

  template<range _Range>
    using range_reference_t = iter_reference_t<iterator_t<_Range>>;

  template<range _Range>
    using range_rvalue_reference_t
      = iter_rvalue_reference_t<iterator_t<_Range>>;


  template<typename _Tp>
    concept sized_range = range<_Tp>
      && requires(_Tp& __t) { ranges::size(__t); };

  template<sized_range _Range>
    using range_size_t = decltype(ranges::size(std::declval<_Range&>()));

  template<typename _Derived>
    requires is_class_v<_Derived> && same_as<_Derived, remove_cv_t<_Derived>>
    class view_interface;

  namespace __detail
  {
    template<typename _Tp, typename _Up>
      requires (!same_as<_Tp, view_interface<_Up>>)
      void __is_derived_from_view_interface_fn(const _Tp&,
            const view_interface<_Up>&);



    template<typename _Tp>
      concept __is_derived_from_view_interface
 = requires (_Tp __t) { __is_derived_from_view_interface_fn(__t, __t); };
  }


  struct view_base { };


  template<typename _Tp>
    inline constexpr bool enable_view = derived_from<_Tp, view_base>
      || __detail::__is_derived_from_view_interface<_Tp>;


  template<typename _Tp>
    concept view
      = range<_Tp> && movable<_Tp> && enable_view<_Tp>;




  template<typename _Range, typename _Tp>
    concept output_range
      = range<_Range> && output_iterator<iterator_t<_Range>, _Tp>;


  template<typename _Tp>
    concept input_range = range<_Tp> && input_iterator<iterator_t<_Tp>>;


  template<typename _Tp>
    concept forward_range
      = input_range<_Tp> && forward_iterator<iterator_t<_Tp>>;


  template<typename _Tp>
    concept bidirectional_range
      = forward_range<_Tp> && bidirectional_iterator<iterator_t<_Tp>>;


  template<typename _Tp>
    concept random_access_range
      = bidirectional_range<_Tp> && random_access_iterator<iterator_t<_Tp>>;


  template<typename _Tp>
    concept contiguous_range
      = random_access_range<_Tp> && contiguous_iterator<iterator_t<_Tp>>
      && requires(_Tp& __t)
      {
 { ranges::data(__t) } -> same_as<add_pointer_t<range_reference_t<_Tp>>>;
      };


  template<typename _Tp>
    concept common_range
      = range<_Tp> && same_as<iterator_t<_Tp>, sentinel_t<_Tp>>;


  template<typename _Tp>
    concept constant_range
      = input_range<_Tp> && std::__detail::__constant_iterator<iterator_t<_Tp>>;


  namespace __access
  {

    template<typename _Range>
      constexpr auto&
      __possibly_const_range(_Range& __r) noexcept
      {
 if constexpr (constant_range<const _Range> && !constant_range<_Range>)
   return const_cast<const _Range&>(__r);
 else
   return __r;
      }
# 652 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ranges_base.h" 3
    struct _CBegin
    {

      template<__maybe_borrowed_range _Tp>
 [[nodiscard]]
 constexpr auto
 operator()(_Tp&& __t) const
 noexcept(noexcept(std::make_const_iterator
     (ranges::begin(__access::__possibly_const_range(__t)))))
 requires requires { std::make_const_iterator
       (ranges::begin(__access::__possibly_const_range(__t))); }
 {
   auto& __r = __access::__possibly_const_range(__t);
   return const_iterator_t<decltype(__r)>(ranges::begin(__r));
 }
# 678 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ranges_base.h" 3
    };

    struct _CEnd final
    {

      template<__maybe_borrowed_range _Tp>
 [[nodiscard]]
 constexpr auto
 operator()(_Tp&& __t) const
 noexcept(noexcept(std::make_const_sentinel
     (ranges::end(__access::__possibly_const_range(__t)))))
 requires requires { std::make_const_sentinel
       (ranges::end(__access::__possibly_const_range(__t))); }
 {
   auto& __r = __access::__possibly_const_range(__t);
   return const_sentinel_t<decltype(__r)>(ranges::end(__r));
 }
# 706 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ranges_base.h" 3
    };

    struct _CRBegin
    {

      template<__maybe_borrowed_range _Tp>
 [[nodiscard]]
 constexpr auto
 operator()(_Tp&& __t) const
 noexcept(noexcept(std::make_const_iterator
     (ranges::rbegin(__access::__possibly_const_range(__t)))))
 requires requires { std::make_const_iterator
       (ranges::rbegin(__access::__possibly_const_range(__t))); }
 {
   auto& __r = __access::__possibly_const_range(__t);
   return const_iterator<decltype(ranges::rbegin(__r))>(ranges::rbegin(__r));
 }
# 734 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ranges_base.h" 3
    };

    struct _CREnd
    {

      template<__maybe_borrowed_range _Tp>
 [[nodiscard]]
 constexpr auto
 operator()(_Tp&& __t) const
 noexcept(noexcept(std::make_const_sentinel
     (ranges::rend(__access::__possibly_const_range(__t)))))
 requires requires { std::make_const_sentinel
       (ranges::rend(__access::__possibly_const_range(__t))); }
 {
   auto& __r = __access::__possibly_const_range(__t);
   return const_sentinel<decltype(ranges::rend(__r))>(ranges::rend(__r));
 }
# 762 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ranges_base.h" 3
    };

    struct _CData
    {

      template<__maybe_borrowed_range _Tp>
 [[nodiscard]]
 constexpr const auto*
 operator()(_Tp&& __t) const
 noexcept(noexcept(ranges::data(__access::__possibly_const_range(__t))))
 requires requires { ranges::data(__access::__possibly_const_range(__t)); }
 { return ranges::data(__access::__possibly_const_range(__t)); }
# 785 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ranges_base.h" 3
    };
  }

  inline namespace _Cpo
  {
    inline constexpr ranges::__access::_CBegin cbegin{};
    inline constexpr ranges::__access::_CEnd cend{};
    inline constexpr ranges::__access::_CRBegin crbegin{};
    inline constexpr ranges::__access::_CREnd crend{};
    inline constexpr ranges::__access::_CData cdata{};
  }

  namespace __detail
  {
    template<typename _Tp>
      inline constexpr bool __is_initializer_list = false;

    template<typename _Tp>
      inline constexpr bool __is_initializer_list<initializer_list<_Tp>> = true;
  }


  template<typename _Tp>
    concept viewable_range = range<_Tp>
      && ((view<remove_cvref_t<_Tp>> && constructible_from<remove_cvref_t<_Tp>, _Tp>)
   || (!view<remove_cvref_t<_Tp>>
       && (is_lvalue_reference_v<_Tp>
    || (movable<remove_reference_t<_Tp>>
        && !__detail::__is_initializer_list<remove_cvref_t<_Tp>>))));



  struct __advance_fn final
  {
    template<input_or_output_iterator _It>
      constexpr void
      operator()(_It& __it, iter_difference_t<_It> __n) const
      {
 if constexpr (random_access_iterator<_It>)
   __it += __n;
 else if constexpr (bidirectional_iterator<_It>)
   {
     if (__n > 0)
       {
  do
    {
      ++__it;
    }
  while (--__n);
       }
     else if (__n < 0)
       {
  do
    {
      --__it;
    }
  while (++__n);
       }
   }
 else
   {

     do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__n >= 0), false)) std::__glibcxx_assert_fail(); } while (false);
     while (__n-- > 0)
       ++__it;
   }
      }

    template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
      constexpr void
      operator()(_It& __it, _Sent __bound) const
      {
 if constexpr (assignable_from<_It&, _Sent>)
   __it = std::move(__bound);
 else if constexpr (sized_sentinel_for<_Sent, _It>)
   (*this)(__it, __bound - __it);
 else
   {
     while (__it != __bound)
       ++__it;
   }
      }

    template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
      constexpr iter_difference_t<_It>
      operator()(_It& __it, iter_difference_t<_It> __n, _Sent __bound) const
      {
 if constexpr (sized_sentinel_for<_Sent, _It>)
   {
     const auto __diff = __bound - __it;

     if (__diff == 0)
       return __n;
     else if (__diff > 0 ? __n >= __diff : __n <= __diff)
       {
  (*this)(__it, __bound);
  return __n - __diff;
       }
     else if (__n != 0) [[likely]]
       {

  do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool((__n < 0) == (__diff < 0)), false)) std::__glibcxx_assert_fail(); } while (false);

  (*this)(__it, __n);
  return 0;
       }
     else
       return 0;
   }
 else if (__it == __bound || __n == 0)
   return __n;
 else if (__n > 0)
   {
     iter_difference_t<_It> __m = 0;
     do
       {
  ++__it;
  ++__m;
       }
     while (__m != __n && __it != __bound);
     return __n - __m;
   }
 else if constexpr (bidirectional_iterator<_It> && same_as<_It, _Sent>)
   {
     iter_difference_t<_It> __m = 0;
     do
       {
  --__it;
  --__m;
       }
     while (__m != __n && __it != __bound);
     return __n - __m;
   }
 else
   {

     do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__n >= 0), false)) std::__glibcxx_assert_fail(); } while (false);
     return __n;
   }
      }

    void operator&() const = delete;
  };

  inline constexpr __advance_fn advance{};

  struct __distance_fn final
  {
    template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
      requires (!sized_sentinel_for<_Sent, _It>)
      constexpr iter_difference_t<_It>
      operator()[[nodiscard]](_It __first, _Sent __last) const
      {
 iter_difference_t<_It> __n = 0;
 while (__first != __last)
   {
     ++__first;
     ++__n;
   }
 return __n;
      }

    template<input_or_output_iterator _It, sized_sentinel_for<_It> _Sent>
      [[nodiscard]]
      constexpr iter_difference_t<_It>
      operator()(const _It& __first, const _Sent& __last) const
      {
 return __last - __first;
      }

    template<range _Range>
      [[nodiscard]]
      constexpr range_difference_t<_Range>
      operator()(_Range&& __r) const
      {
 if constexpr (sized_range<_Range>)
   return static_cast<range_difference_t<_Range>>(ranges::size(__r));
 else
   return (*this)(ranges::begin(__r), ranges::end(__r));
      }

    void operator&() const = delete;
  };

  inline constexpr __distance_fn distance{};

  struct __next_fn final
  {
    template<input_or_output_iterator _It>
      [[nodiscard]]
      constexpr _It
      operator()(_It __x) const
      {
 ++__x;
 return __x;
      }

    template<input_or_output_iterator _It>
      [[nodiscard]]
      constexpr _It
      operator()(_It __x, iter_difference_t<_It> __n) const
      {
 ranges::advance(__x, __n);
 return __x;
      }

    template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
      [[nodiscard]]
      constexpr _It
      operator()(_It __x, _Sent __bound) const
      {
 ranges::advance(__x, __bound);
 return __x;
      }

    template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
      [[nodiscard]]
      constexpr _It
      operator()(_It __x, iter_difference_t<_It> __n, _Sent __bound) const
      {
 ranges::advance(__x, __n, __bound);
 return __x;
      }

    void operator&() const = delete;
  };

  inline constexpr __next_fn next{};

  struct __prev_fn final
  {
    template<bidirectional_iterator _It>
      [[nodiscard]]
      constexpr _It
      operator()(_It __x) const
      {
 --__x;
 return __x;
      }

    template<bidirectional_iterator _It>
      [[nodiscard]]
      constexpr _It
      operator()(_It __x, iter_difference_t<_It> __n) const
      {
 ranges::advance(__x, -__n);
 return __x;
      }

    template<bidirectional_iterator _It>
      [[nodiscard]]
      constexpr _It
      operator()(_It __x, iter_difference_t<_It> __n, _It __bound) const
      {
 ranges::advance(__x, -__n, __bound);
 return __x;
      }

    void operator&() const = delete;
  };

  inline constexpr __prev_fn prev{};


  struct dangling
  {
    constexpr dangling() noexcept = default;
    template<typename... _Args>
      constexpr dangling(_Args&&...) noexcept { }
  };

  template<range _Range>
    using borrowed_iterator_t = __conditional_t<borrowed_range<_Range>,
      iterator_t<_Range>,
      dangling>;
}


  struct from_range_t { explicit from_range_t() = default; };
  inline constexpr from_range_t from_range{};



}
# 35 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ranges_util.h" 2 3




namespace std __attribute__ ((__visibility__ ("default")))
{

namespace ranges
{


  namespace __detail
  {
    template<typename _Range>
      concept __simple_view = view<_Range> && range<const _Range>
 && same_as<iterator_t<_Range>, iterator_t<const _Range>>
 && same_as<sentinel_t<_Range>, sentinel_t<const _Range>>;

    template<typename _It>
      concept __has_arrow = input_iterator<_It>
 && (is_pointer_v<_It> || requires(_It __it) { __it.operator->(); });

    using std::__detail::__different_from;
  }


  template<typename _Derived>
    requires is_class_v<_Derived> && same_as<_Derived, remove_cv_t<_Derived>>
    class view_interface
    {
    private:
      constexpr _Derived& _M_derived() noexcept
      {
 static_assert(derived_from<_Derived, view_interface<_Derived>>);
 static_assert(view<_Derived>);
 return static_cast<_Derived&>(*this);
      }

      constexpr const _Derived& _M_derived() const noexcept
      {
 static_assert(derived_from<_Derived, view_interface<_Derived>>);
 static_assert(view<_Derived>);
 return static_cast<const _Derived&>(*this);
      }

      static constexpr bool
      _S_bool(bool) noexcept;

      template<typename _Tp>
 static constexpr bool
 _S_empty(_Tp& __t)
 noexcept(noexcept(_S_bool(ranges::begin(__t) == ranges::end(__t))))
 { return ranges::begin(__t) == ranges::end(__t); }

      template<typename _Tp>
 static constexpr auto
 _S_size(_Tp& __t)
 noexcept(noexcept(ranges::end(__t) - ranges::begin(__t)))
 { return ranges::end(__t) - ranges::begin(__t); }

    public:
      constexpr bool
      empty()
      noexcept(noexcept(_S_empty(_M_derived())))
      requires forward_range<_Derived> && (!sized_range<_Derived>)
      { return _S_empty(_M_derived()); }

      constexpr bool
      empty()
      noexcept(noexcept(ranges::size(_M_derived()) == 0))
      requires sized_range<_Derived>
      { return ranges::size(_M_derived()) == 0; }

      constexpr bool
      empty() const
      noexcept(noexcept(_S_empty(_M_derived())))
      requires forward_range<const _Derived> && (!sized_range<const _Derived>)
      { return _S_empty(_M_derived()); }

      constexpr bool
      empty() const
      noexcept(noexcept(ranges::size(_M_derived()) == 0))
      requires sized_range<const _Derived>
      { return ranges::size(_M_derived()) == 0; }

      constexpr explicit
      operator bool() noexcept(noexcept(ranges::empty(_M_derived())))
      requires requires { ranges::empty(_M_derived()); }
      { return !ranges::empty(_M_derived()); }

      constexpr explicit
      operator bool() const noexcept(noexcept(ranges::empty(_M_derived())))
      requires requires { ranges::empty(_M_derived()); }
      { return !ranges::empty(_M_derived()); }

      constexpr auto
      data() noexcept(noexcept(ranges::begin(_M_derived())))
      requires contiguous_iterator<iterator_t<_Derived>>
      { return std::to_address(ranges::begin(_M_derived())); }

      constexpr auto
      data() const noexcept(noexcept(ranges::begin(_M_derived())))
      requires range<const _Derived>
 && contiguous_iterator<iterator_t<const _Derived>>
      { return std::to_address(ranges::begin(_M_derived())); }

      constexpr auto
      size() noexcept(noexcept(_S_size(_M_derived())))
      requires forward_range<_Derived>
 && sized_sentinel_for<sentinel_t<_Derived>, iterator_t<_Derived>>
      { return _S_size(_M_derived()); }

      constexpr auto
      size() const noexcept(noexcept(_S_size(_M_derived())))
      requires forward_range<const _Derived>
 && sized_sentinel_for<sentinel_t<const _Derived>,
         iterator_t<const _Derived>>
      { return _S_size(_M_derived()); }

      constexpr decltype(auto)
      front() requires forward_range<_Derived>
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(!empty()), false)) std::__glibcxx_assert_fail(); } while (false);
 return *ranges::begin(_M_derived());
      }

      constexpr decltype(auto)
      front() const requires forward_range<const _Derived>
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(!empty()), false)) std::__glibcxx_assert_fail(); } while (false);
 return *ranges::begin(_M_derived());
      }

      constexpr decltype(auto)
      back()
      requires bidirectional_range<_Derived> && common_range<_Derived>
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(!empty()), false)) std::__glibcxx_assert_fail(); } while (false);
 return *ranges::prev(ranges::end(_M_derived()));
      }

      constexpr decltype(auto)
      back() const
      requires bidirectional_range<const _Derived>
 && common_range<const _Derived>
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(!empty()), false)) std::__glibcxx_assert_fail(); } while (false);
 return *ranges::prev(ranges::end(_M_derived()));
      }

      template<random_access_range _Range = _Derived>
 constexpr decltype(auto)
 operator[](range_difference_t<_Range> __n)
 { return ranges::begin(_M_derived())[__n]; }

      template<random_access_range _Range = const _Derived>
 constexpr decltype(auto)
 operator[](range_difference_t<_Range> __n) const
 { return ranges::begin(_M_derived())[__n]; }


      constexpr auto
      cbegin() requires input_range<_Derived>
      { return ranges::cbegin(_M_derived()); }

      constexpr auto
      cbegin() const requires input_range<const _Derived>
      { return ranges::cbegin(_M_derived()); }

      constexpr auto
      cend() requires input_range<_Derived>
      { return ranges::cend(_M_derived()); }

      constexpr auto
      cend() const requires input_range<const _Derived>
      { return ranges::cend(_M_derived()); }

    };

  namespace __detail
  {
    template<typename _From, typename _To>
      concept __uses_nonqualification_pointer_conversion
 = is_pointer_v<_From> && is_pointer_v<_To>
   && !convertible_to<remove_pointer_t<_From>(*)[],
        remove_pointer_t<_To>(*)[]>;

    template<typename _From, typename _To>
      concept __convertible_to_non_slicing = convertible_to<_From, _To>
 && !__uses_nonqualification_pointer_conversion<decay_t<_From>,
             decay_t<_To>>;
# 244 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ranges_util.h" 3
    template<typename _Tp, typename _Up, typename _Vp>
      concept __pair_like_convertible_from
 = !range<_Tp> && !is_reference_v<_Vp> && __pair_like<_Tp>
 && constructible_from<_Tp, _Up, _Vp>
 && __convertible_to_non_slicing<_Up, tuple_element_t<0, _Tp>>
 && convertible_to<_Vp, tuple_element_t<1, _Tp>>;

  }

  namespace views { struct _Drop; }

  enum class subrange_kind : bool { unsized, sized };


  template<input_or_output_iterator _It, sentinel_for<_It> _Sent = _It,
    subrange_kind _Kind = sized_sentinel_for<_Sent, _It>
      ? subrange_kind::sized : subrange_kind::unsized>
    requires (_Kind == subrange_kind::sized || !sized_sentinel_for<_Sent, _It>)
    class subrange : public view_interface<subrange<_It, _Sent, _Kind>>
    {
    private:
      static constexpr bool _S_store_size
 = _Kind == subrange_kind::sized && !sized_sentinel_for<_Sent, _It>;

      friend struct views::_Drop;

      _It _M_begin = _It();
      [[no_unique_address]] _Sent _M_end = _Sent();

      using __size_type
 = __detail::__make_unsigned_like_t<iter_difference_t<_It>>;

      template<typename _Tp, bool = _S_store_size>
 struct _Size
 {
   [[__gnu__::__always_inline__]]
   constexpr _Size(_Tp = {}) { }
 };

      template<typename _Tp>
 struct _Size<_Tp, true>
 {
   [[__gnu__::__always_inline__]]
   constexpr _Size(_Tp __s = {}) : _M_size(__s) { }

   _Tp _M_size;
 };

      [[no_unique_address]] _Size<__size_type> _M_size = {};

    public:
      subrange() requires default_initializable<_It> = default;

      constexpr
      subrange(__detail::__convertible_to_non_slicing<_It> auto __i, _Sent __s)
      noexcept(is_nothrow_constructible_v<_It, decltype(__i)>
        && is_nothrow_constructible_v<_Sent, _Sent&>)
 requires (!_S_store_size)
      : _M_begin(std::move(__i)), _M_end(__s)
      { }

      constexpr
      subrange(__detail::__convertible_to_non_slicing<_It> auto __i, _Sent __s,
        __size_type __n)
      noexcept(is_nothrow_constructible_v<_It, decltype(__i)>
        && is_nothrow_constructible_v<_Sent, _Sent&>)
 requires (_Kind == subrange_kind::sized)
      : _M_begin(std::move(__i)), _M_end(__s), _M_size(__n)
      { }

      template<__detail::__different_from<subrange> _Rng>
 requires borrowed_range<_Rng>
   && __detail::__convertible_to_non_slicing<iterator_t<_Rng>, _It>
   && convertible_to<sentinel_t<_Rng>, _Sent>
 constexpr
 subrange(_Rng&& __r)
 noexcept(noexcept(subrange(__r, ranges::size(__r))))
 requires _S_store_size && sized_range<_Rng>
 : subrange(__r, ranges::size(__r))
 { }

      template<__detail::__different_from<subrange> _Rng>
 requires borrowed_range<_Rng>
   && __detail::__convertible_to_non_slicing<iterator_t<_Rng>, _It>
   && convertible_to<sentinel_t<_Rng>, _Sent>
 constexpr
 subrange(_Rng&& __r)
 noexcept(noexcept(subrange(ranges::begin(__r), ranges::end(__r))))
 requires (!_S_store_size)
 : subrange(ranges::begin(__r), ranges::end(__r))
 { }

      template<borrowed_range _Rng>
 requires __detail::__convertible_to_non_slicing<iterator_t<_Rng>, _It>
   && convertible_to<sentinel_t<_Rng>, _Sent>
 constexpr
 subrange(_Rng&& __r, __size_type __n)
 noexcept(noexcept(subrange(ranges::begin(__r), ranges::end(__r), __n)))
 requires (_Kind == subrange_kind::sized)
 : subrange{ranges::begin(__r), ranges::end(__r), __n}
 { }

      template<__detail::__different_from<subrange> _PairLike>
 requires __detail::__pair_like_convertible_from<_PairLike, const _It&,
       const _Sent&>
 constexpr
 operator _PairLike() const
 { return _PairLike(_M_begin, _M_end); }

      constexpr _It
      begin() const requires copyable<_It>
      { return _M_begin; }

      [[nodiscard]] constexpr _It
      begin() requires (!copyable<_It>)
      { return std::move(_M_begin); }

      constexpr _Sent end() const { return _M_end; }

      constexpr bool empty() const { return _M_begin == _M_end; }

      constexpr __size_type
      size() const requires (_Kind == subrange_kind::sized)
      {
 if constexpr (_S_store_size)
   return _M_size._M_size;
 else
   return __detail::__to_unsigned_like(_M_end - _M_begin);
      }

      [[nodiscard]] constexpr subrange
      next(iter_difference_t<_It> __n = 1) const &
 requires forward_iterator<_It>
      {
 auto __tmp = *this;
 __tmp.advance(__n);
 return __tmp;
      }

      [[nodiscard]] constexpr subrange
      next(iter_difference_t<_It> __n = 1) &&
      {
 advance(__n);
 return std::move(*this);
      }

      [[nodiscard]] constexpr subrange
      prev(iter_difference_t<_It> __n = 1) const
 requires bidirectional_iterator<_It>
      {
 auto __tmp = *this;
 __tmp.advance(-__n);
 return __tmp;
      }

      constexpr subrange&
      advance(iter_difference_t<_It> __n)
      {


 if constexpr (bidirectional_iterator<_It>)
   if (__n < 0)
     {
       ranges::advance(_M_begin, __n);
       if constexpr (_S_store_size)
  _M_size._M_size += __detail::__to_unsigned_like(-__n);
       return *this;
     }

 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__n >= 0), false)) std::__glibcxx_assert_fail(); } while (false);
 auto __d = __n - ranges::advance(_M_begin, __n, _M_end);
 if constexpr (_S_store_size)
   _M_size._M_size -= __detail::__to_unsigned_like(__d);
 return *this;
      }
    };

  template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
    subrange(_It, _Sent) -> subrange<_It, _Sent>;

  template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
    subrange(_It, _Sent,
      __detail::__make_unsigned_like_t<iter_difference_t<_It>>)
      -> subrange<_It, _Sent, subrange_kind::sized>;

  template<borrowed_range _Rng>
    subrange(_Rng&&)
      -> subrange<iterator_t<_Rng>, sentinel_t<_Rng>,
   (sized_range<_Rng>
    || sized_sentinel_for<sentinel_t<_Rng>, iterator_t<_Rng>>)
   ? subrange_kind::sized : subrange_kind::unsized>;

  template<borrowed_range _Rng>
    subrange(_Rng&&,
      __detail::__make_unsigned_like_t<range_difference_t<_Rng>>)
      -> subrange<iterator_t<_Rng>, sentinel_t<_Rng>, subrange_kind::sized>;

  template<size_t _Num, class _It, class _Sent, subrange_kind _Kind>
    requires (_Num < 2)
    constexpr auto
    get(const subrange<_It, _Sent, _Kind>& __r)
    {
      if constexpr (_Num == 0)
 return __r.begin();
      else
 return __r.end();
    }

  template<size_t _Num, class _It, class _Sent, subrange_kind _Kind>
    requires (_Num < 2)
    constexpr auto
    get(subrange<_It, _Sent, _Kind>&& __r)
    {
      if constexpr (_Num == 0)
 return __r.begin();
      else
 return __r.end();
    }

  template<typename _It, typename _Sent, subrange_kind _Kind>
    inline constexpr bool
      enable_borrowed_range<subrange<_It, _Sent, _Kind>> = true;

  template<range _Range>
    using borrowed_subrange_t = __conditional_t<borrowed_range<_Range>,
      subrange<iterator_t<_Range>>,
      dangling>;


  template<typename _Iter, typename _Sent, subrange_kind _Kind>
    inline constexpr bool __detail::__is_subrange<subrange<_Iter, _Sent, _Kind>> = true;
}



  template<typename _It, typename _Sent, ranges::subrange_kind _Kind>
    inline constexpr bool __is_tuple_like_v<ranges::subrange<_It, _Sent, _Kind>> = true;




namespace ranges
{
  struct __find_fn
  {
    template<input_iterator _Iter, sentinel_for<_Iter> _Sent, typename _Tp,
      typename _Proj = identity>
      requires indirect_binary_predicate<ranges::equal_to,
      projected<_Iter, _Proj>, const _Tp*>
      constexpr _Iter
      operator()(_Iter __first, _Sent __last,
   const _Tp& __value, _Proj __proj = {}) const
      {
 while (__first != __last
     && !(std::__invoke(__proj, *__first) == __value))
   ++__first;
 return __first;
      }

    template<input_range _Range, typename _Tp, typename _Proj = identity>
      requires indirect_binary_predicate<ranges::equal_to,
      projected<iterator_t<_Range>, _Proj>,
      const _Tp*>
      constexpr borrowed_iterator_t<_Range>
      operator()(_Range&& __r, const _Tp& __value, _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         __value, std::move(__proj));
      }
  };

  inline constexpr __find_fn find{};

  struct __find_if_fn
  {
    template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Proj = identity,
      indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
      constexpr _Iter
      operator()(_Iter __first, _Sent __last,
   _Pred __pred, _Proj __proj = {}) const
      {
 while (__first != __last
     && !(bool)std::__invoke(__pred, std::__invoke(__proj, *__first)))
   ++__first;
 return __first;
      }

    template<input_range _Range, typename _Proj = identity,
      indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>>
        _Pred>
      constexpr borrowed_iterator_t<_Range>
      operator()(_Range&& __r, _Pred __pred, _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__pred), std::move(__proj));
      }
  };

  inline constexpr __find_if_fn find_if{};

  struct __find_if_not_fn
  {
    template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Proj = identity,
      indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
      constexpr _Iter
      operator()(_Iter __first, _Sent __last,
   _Pred __pred, _Proj __proj = {}) const
      {
 while (__first != __last
     && (bool)std::__invoke(__pred, std::__invoke(__proj, *__first)))
   ++__first;
 return __first;
      }

    template<input_range _Range, typename _Proj = identity,
      indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>>
        _Pred>
      constexpr borrowed_iterator_t<_Range>
      operator()(_Range&& __r, _Pred __pred, _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__pred), std::move(__proj));
      }
  };

  inline constexpr __find_if_not_fn find_if_not{};

  template<typename _Iter1, typename _Iter2>
    struct in_in_result
    {
      [[no_unique_address]] _Iter1 in1;
      [[no_unique_address]] _Iter2 in2;

      template<typename _IIter1, typename _IIter2>
 requires convertible_to<const _Iter1&, _IIter1>
   && convertible_to<const _Iter2&, _IIter2>
 constexpr
 operator in_in_result<_IIter1, _IIter2>() const &
 { return {in1, in2}; }

      template<typename _IIter1, typename _IIter2>
 requires convertible_to<_Iter1, _IIter1>
   && convertible_to<_Iter2, _IIter2>
 constexpr
 operator in_in_result<_IIter1, _IIter2>() &&
 { return {std::move(in1), std::move(in2)}; }
    };

  template<typename _Iter1, typename _Iter2>
    using mismatch_result = in_in_result<_Iter1, _Iter2>;

  struct __mismatch_fn
  {
    template<input_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
      input_iterator _Iter2, sentinel_for<_Iter2> _Sent2,
      typename _Pred = ranges::equal_to,
      typename _Proj1 = identity, typename _Proj2 = identity>
      requires indirectly_comparable<_Iter1, _Iter2, _Pred, _Proj1, _Proj2>
      constexpr mismatch_result<_Iter1, _Iter2>
      operator()(_Iter1 __first1, _Sent1 __last1,
   _Iter2 __first2, _Sent2 __last2, _Pred __pred = {},
   _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
      {
 while (__first1 != __last1 && __first2 != __last2
        && (bool)std::__invoke(__pred,
          std::__invoke(__proj1, *__first1),
          std::__invoke(__proj2, *__first2)))
 {
   ++__first1;
   ++__first2;
 }
 return { std::move(__first1), std::move(__first2) };
      }

    template<input_range _Range1, input_range _Range2,
      typename _Pred = ranges::equal_to,
      typename _Proj1 = identity, typename _Proj2 = identity>
      requires indirectly_comparable<iterator_t<_Range1>, iterator_t<_Range2>,
         _Pred, _Proj1, _Proj2>
      constexpr mismatch_result<iterator_t<_Range1>, iterator_t<_Range2>>
      operator()(_Range1&& __r1, _Range2&& __r2, _Pred __pred = {},
   _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
      {
 return (*this)(ranges::begin(__r1), ranges::end(__r1),
         ranges::begin(__r2), ranges::end(__r2),
         std::move(__pred),
         std::move(__proj1), std::move(__proj2));
      }
  };

  inline constexpr __mismatch_fn mismatch{};

  struct __search_fn
  {
    template<forward_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
      forward_iterator _Iter2, sentinel_for<_Iter2> _Sent2,
      typename _Pred = ranges::equal_to,
      typename _Proj1 = identity, typename _Proj2 = identity>
      requires indirectly_comparable<_Iter1, _Iter2, _Pred, _Proj1, _Proj2>
      constexpr subrange<_Iter1>
      operator()(_Iter1 __first1, _Sent1 __last1,
   _Iter2 __first2, _Sent2 __last2, _Pred __pred = {},
   _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
      {
 if (__first1 == __last1 || __first2 == __last2)
   return {__first1, __first1};

 for (;;)
   {
     for (;;)
       {
  if (__first1 == __last1)
    return {__first1, __first1};
  if (std::__invoke(__pred,
      std::__invoke(__proj1, *__first1),
      std::__invoke(__proj2, *__first2)))
    break;
  ++__first1;
       }
     auto __cur1 = __first1;
     auto __cur2 = __first2;
     for (;;)
       {
  if (++__cur2 == __last2)
    return {__first1, ++__cur1};
  if (++__cur1 == __last1)
    return {__cur1, __cur1};
  if (!(bool)std::__invoke(__pred,
      std::__invoke(__proj1, *__cur1),
      std::__invoke(__proj2, *__cur2)))
    {
      ++__first1;
      break;
    }
       }
   }
      }

    template<forward_range _Range1, forward_range _Range2,
      typename _Pred = ranges::equal_to,
      typename _Proj1 = identity, typename _Proj2 = identity>
      requires indirectly_comparable<iterator_t<_Range1>, iterator_t<_Range2>,
         _Pred, _Proj1, _Proj2>
      constexpr borrowed_subrange_t<_Range1>
      operator()(_Range1&& __r1, _Range2&& __r2, _Pred __pred = {},
   _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
      {
 return (*this)(ranges::begin(__r1), ranges::end(__r1),
         ranges::begin(__r2), ranges::end(__r2),
         std::move(__pred),
         std::move(__proj1), std::move(__proj2));
      }
  };

  inline constexpr __search_fn search{};

  struct __min_fn
  {
    template<typename _Tp, typename _Proj = identity,
      indirect_strict_weak_order<projected<const _Tp*, _Proj>>
        _Comp = ranges::less>
      constexpr const _Tp&
      operator()(const _Tp& __a, const _Tp& __b,
   _Comp __comp = {}, _Proj __proj = {}) const
      {
 if (std::__invoke(__comp,
     std::__invoke(__proj, __b),
     std::__invoke(__proj, __a)))
   return __b;
 else
   return __a;
      }

    template<input_range _Range, typename _Proj = identity,
      indirect_strict_weak_order<projected<iterator_t<_Range>, _Proj>>
        _Comp = ranges::less>
      requires indirectly_copyable_storable<iterator_t<_Range>,
         range_value_t<_Range>*>
      constexpr range_value_t<_Range>
      operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const
      {
 auto __first = ranges::begin(__r);
 auto __last = ranges::end(__r);
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__first != __last), false)) std::__glibcxx_assert_fail(); } while (false);
 auto __result = *__first;
 while (++__first != __last)
   {
     auto __tmp = *__first;
     if (std::__invoke(__comp,
         std::__invoke(__proj, __tmp),
         std::__invoke(__proj, __result)))
       __result = std::move(__tmp);
   }
 return __result;
      }

    template<copyable _Tp, typename _Proj = identity,
      indirect_strict_weak_order<projected<const _Tp*, _Proj>>
        _Comp = ranges::less>
      constexpr _Tp
      operator()(initializer_list<_Tp> __r,
   _Comp __comp = {}, _Proj __proj = {}) const
      {
 return (*this)(ranges::subrange(__r),
         std::move(__comp), std::move(__proj));
      }
  };

  inline constexpr __min_fn min{};

  struct __adjacent_find_fn
  {
    template<forward_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Proj = identity,
      indirect_binary_predicate<projected<_Iter, _Proj>,
           projected<_Iter, _Proj>> _Pred
        = ranges::equal_to>
      constexpr _Iter
      operator()(_Iter __first, _Sent __last,
   _Pred __pred = {}, _Proj __proj = {}) const
      {
 if (__first == __last)
   return __first;
 auto __next = __first;
 for (; ++__next != __last; __first = __next)
   {
     if (std::__invoke(__pred,
         std::__invoke(__proj, *__first),
         std::__invoke(__proj, *__next)))
       return __first;
   }
 return __next;
      }

    template<forward_range _Range, typename _Proj = identity,
      indirect_binary_predicate<
        projected<iterator_t<_Range>, _Proj>,
        projected<iterator_t<_Range>, _Proj>> _Pred = ranges::equal_to>
      constexpr borrowed_iterator_t<_Range>
      operator()(_Range&& __r, _Pred __pred = {}, _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__pred), std::move(__proj));
      }
  };

  inline constexpr __adjacent_find_fn adjacent_find{};

}

  using ranges::get;

  template<typename _Iter, typename _Sent, ranges::subrange_kind _Kind>
    struct tuple_size<ranges::subrange<_Iter, _Sent, _Kind>>
    : integral_constant<size_t, 2>
    { };

  template<typename _Iter, typename _Sent, ranges::subrange_kind _Kind>
    struct tuple_element<0, ranges::subrange<_Iter, _Sent, _Kind>>
    { using type = _Iter; };

  template<typename _Iter, typename _Sent, ranges::subrange_kind _Kind>
    struct tuple_element<1, ranges::subrange<_Iter, _Sent, _Kind>>
    { using type = _Sent; };

  template<typename _Iter, typename _Sent, ranges::subrange_kind _Kind>
    struct tuple_element<0, const ranges::subrange<_Iter, _Sent, _Kind>>
    { using type = _Iter; };

  template<typename _Iter, typename _Sent, ranges::subrange_kind _Kind>
    struct tuple_element<1, const ranges::subrange<_Iter, _Sent, _Kind>>
    { using type = _Sent; };


}
# 45 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tuple" 2 3
# 54 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tuple" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 55 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tuple" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{







  template<typename... _Elements>
    class tuple;

  template<typename _Tp>
    struct __is_empty_non_tuple : is_empty<_Tp> { };


  template<typename _El0, typename... _El>
    struct __is_empty_non_tuple<tuple<_El0, _El...>> : false_type { };


  template<typename _Tp>
    using __empty_not_final
    = __conditional_t<__is_final(_Tp), false_type,
        __is_empty_non_tuple<_Tp>>;

  template<size_t _Idx, typename _Head,
    bool = __empty_not_final<_Head>::value>
    struct _Head_base;


  template<size_t _Idx, typename _Head>
    struct _Head_base<_Idx, _Head, true>
    {
      constexpr _Head_base()
      : _M_head_impl() { }

      constexpr _Head_base(const _Head& __h)
      : _M_head_impl(__h) { }

      constexpr _Head_base(const _Head_base&) = default;
      constexpr _Head_base(_Head_base&&) = default;

      template<typename _UHead>
 constexpr _Head_base(_UHead&& __h)
 : _M_head_impl(std::forward<_UHead>(__h)) { }

      constexpr
      _Head_base(allocator_arg_t, __uses_alloc0)
      : _M_head_impl() { }

      template<typename _Alloc>
 constexpr
 _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a)
 : _M_head_impl(allocator_arg, *__a._M_a) { }

      template<typename _Alloc>
 constexpr
 _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a)
 : _M_head_impl(*__a._M_a) { }

      template<typename _UHead>
 constexpr
 _Head_base(__uses_alloc0, _UHead&& __uhead)
 : _M_head_impl(std::forward<_UHead>(__uhead)) { }

      template<typename _Alloc, typename _UHead>
 constexpr
 _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead)
 : _M_head_impl(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead))
 { }

      template<typename _Alloc, typename _UHead>
 constexpr
 _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead)
 : _M_head_impl(std::forward<_UHead>(__uhead), *__a._M_a) { }

      static constexpr _Head&
      _M_head(_Head_base& __b) noexcept { return __b._M_head_impl; }

      static constexpr const _Head&
      _M_head(const _Head_base& __b) noexcept { return __b._M_head_impl; }

      [[__no_unique_address__]] _Head _M_head_impl;
    };
# 195 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tuple" 3
  template<size_t _Idx, typename _Head>
    struct _Head_base<_Idx, _Head, false>
    {
      constexpr _Head_base()
      : _M_head_impl() { }

      constexpr _Head_base(const _Head& __h)
      : _M_head_impl(__h) { }

      constexpr _Head_base(const _Head_base&) = default;
      constexpr _Head_base(_Head_base&&) = default;

      template<typename _UHead>
        constexpr _Head_base(_UHead&& __h)
 : _M_head_impl(std::forward<_UHead>(__h)) { }

      constexpr
      _Head_base(allocator_arg_t, __uses_alloc0)
      : _M_head_impl() { }

      template<typename _Alloc>
 constexpr
 _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a)
 : _M_head_impl(allocator_arg, *__a._M_a) { }

      template<typename _Alloc>
 constexpr
 _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a)
 : _M_head_impl(*__a._M_a) { }

      template<typename _UHead>
 constexpr
 _Head_base(__uses_alloc0, _UHead&& __uhead)
 : _M_head_impl(std::forward<_UHead>(__uhead)) { }

      template<typename _Alloc, typename _UHead>
 constexpr
 _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead)
 : _M_head_impl(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead))
 { }

      template<typename _Alloc, typename _UHead>
 constexpr
 _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead)
 : _M_head_impl(std::forward<_UHead>(__uhead), *__a._M_a) { }

      static constexpr _Head&
      _M_head(_Head_base& __b) noexcept { return __b._M_head_impl; }

      static constexpr const _Head&
      _M_head(const _Head_base& __b) noexcept { return __b._M_head_impl; }

      _Head _M_head_impl;
    };


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



  template<typename _Cat, typename _Tp, typename _Up>
    constexpr _Cat
    __tuple_cmp(const _Tp&, const _Up&, index_sequence<>);

  template<typename _Cat, typename _Tp, typename _Up,
    size_t _Idx0, size_t... _Idxs>
    constexpr _Cat
    __tuple_cmp(const _Tp& __t, const _Up& __u,
  index_sequence<_Idx0, _Idxs...>);
# 274 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tuple" 3
  template<size_t _Idx, typename... _Elements>
    struct _Tuple_impl;






  template<size_t _Idx, typename _Head, typename... _Tail>
    struct _Tuple_impl<_Idx, _Head, _Tail...>
    : public _Tuple_impl<_Idx + 1, _Tail...>,
      private _Head_base<_Idx, _Head>
    {
      template<size_t, typename...> friend struct _Tuple_impl;

      typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited;
      typedef _Head_base<_Idx, _Head> _Base;

      static constexpr _Head&
      _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }

      static constexpr const _Head&
      _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }

      static constexpr _Inherited&
      _M_tail(_Tuple_impl& __t) noexcept { return __t; }

      static constexpr const _Inherited&
      _M_tail(const _Tuple_impl& __t) noexcept { return __t; }

      constexpr _Tuple_impl()
      : _Inherited(), _Base() { }

      explicit constexpr
      _Tuple_impl(const _Head& __head, const _Tail&... __tail)
      : _Inherited(__tail...), _Base(__head)
      { }

      template<typename _UHead, typename... _UTail,
        typename = __enable_if_t<sizeof...(_Tail) == sizeof...(_UTail)>>
 explicit constexpr
 _Tuple_impl(_UHead&& __head, _UTail&&... __tail)
 : _Inherited(std::forward<_UTail>(__tail)...),
   _Base(std::forward<_UHead>(__head))
 { }

      constexpr _Tuple_impl(const _Tuple_impl&) = default;



      _Tuple_impl& operator=(const _Tuple_impl&) = delete;

      _Tuple_impl(_Tuple_impl&&) = default;

      template<typename... _UElements>
 constexpr
 _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in)
 : _Inherited(_Tuple_impl<_Idx, _UElements...>::_M_tail(__in)),
   _Base(_Tuple_impl<_Idx, _UElements...>::_M_head(__in))
 { }

      template<typename _UHead, typename... _UTails>
 constexpr
 _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
 : _Inherited(std::move
       (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
   _Base(std::forward<_UHead>
  (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in)))
 { }


      template<typename... _UElements>
 constexpr
 _Tuple_impl(_Tuple_impl<_Idx, _UElements...>& __in)
 : _Inherited(_Tuple_impl<_Idx, _UElements...>::_M_tail(__in)),
   _Base(_Tuple_impl<_Idx, _UElements...>::_M_head(__in))
 { }

      template<typename _UHead, typename... _UTails>
 constexpr
 _Tuple_impl(const _Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
 : _Inherited(std::move
       (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
   _Base(std::forward<const _UHead>
  (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in)))
 { }



      template<typename _UTuple, size_t... _Is>
 constexpr
 _Tuple_impl(__tuple_like_tag_t, _UTuple&& __u, index_sequence<_Is...>)
 : _Tuple_impl(std::get<_Is>(std::forward<_UTuple>(__u))...)
 { }


      template<typename _Alloc>
 constexpr
 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a)
 : _Inherited(__tag, __a),
   _Base(__tag, __use_alloc<_Head>(__a))
 { }

      template<typename _Alloc>
 constexpr
 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
      const _Head& __head, const _Tail&... __tail)
 : _Inherited(__tag, __a, __tail...),
   _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head)
 { }

      template<typename _Alloc, typename _UHead, typename... _UTail,
        typename = __enable_if_t<sizeof...(_Tail) == sizeof...(_UTail)>>
 constexpr
 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
      _UHead&& __head, _UTail&&... __tail)
 : _Inherited(__tag, __a, std::forward<_UTail>(__tail)...),
   _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
  std::forward<_UHead>(__head))
 { }

      template<typename _Alloc>
 constexpr
 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
      const _Tuple_impl& __in)
 : _Inherited(__tag, __a, _M_tail(__in)),
   _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in))
 { }

      template<typename _Alloc>
 constexpr
 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
      _Tuple_impl&& __in)
 : _Inherited(__tag, __a, std::move(_M_tail(__in))),
   _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
  std::forward<_Head>(_M_head(__in)))
 { }

      template<typename _Alloc, typename _UHead, typename... _UTails>
 constexpr
 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
      const _Tuple_impl<_Idx, _UHead, _UTails...>& __in)
 : _Inherited(__tag, __a,
       _Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in)),
   _Base(__use_alloc<_Head, _Alloc, const _UHead&>(__a),
  _Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))
 { }

      template<typename _Alloc, typename _UHead, typename... _UTails>
 constexpr
 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
      _Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
 : _Inherited(__tag, __a, std::move
       (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
   _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
  std::forward<_UHead>
  (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in)))
 { }


      template<typename _Alloc, typename _UHead, typename... _UTails>
 constexpr
 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
      _Tuple_impl<_Idx, _UHead, _UTails...>& __in)
 : _Inherited(__tag, __a,
       _Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in)),
   _Base(__use_alloc<_Head, _Alloc, _UHead&>(__a),
  _Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))
 { }

      template<typename _Alloc, typename _UHead, typename... _UTails>
 constexpr
 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
      const _Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
 : _Inherited(__tag, __a, std::move
       (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
   _Base(__use_alloc<_Head, _Alloc, const _UHead>(__a),
  std::forward<const _UHead>
  (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in)))
 { }



      template<typename _Alloc, typename _UTuple, size_t... _Is>
 constexpr
 _Tuple_impl(__tuple_like_tag_t, allocator_arg_t __tag, const _Alloc& __a,
      _UTuple&& __u, index_sequence<_Is...>)
 : _Tuple_impl(__tag, __a, std::get<_Is>(std::forward<_UTuple>(__u))...)
 { }


      template<typename... _UElements>
 constexpr
 void
 _M_assign(const _Tuple_impl<_Idx, _UElements...>& __in)
 {
   _M_head(*this) = _Tuple_impl<_Idx, _UElements...>::_M_head(__in);
   _M_tail(*this)._M_assign(
       _Tuple_impl<_Idx, _UElements...>::_M_tail(__in));
 }

      template<typename _UHead, typename... _UTails>
 constexpr
 void
 _M_assign(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
 {
   _M_head(*this) = std::forward<_UHead>
     (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in));
   _M_tail(*this)._M_assign(
       std::move(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in)));
 }


      template<typename... _UElements>
 constexpr void
 _M_assign(const _Tuple_impl<_Idx, _UElements...>& __in) const
 {
   _M_head(*this) = _Tuple_impl<_Idx, _UElements...>::_M_head(__in);
   _M_tail(*this)._M_assign(
       _Tuple_impl<_Idx, _UElements...>::_M_tail(__in));
 }

      template<typename _UHead, typename... _UTails>
 constexpr void
 _M_assign(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in) const
 {
   _M_head(*this) = std::forward<_UHead>
     (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in));
   _M_tail(*this)._M_assign(
       std::move(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in)));
 }



      template<typename _UTuple>
 constexpr void
 _M_assign(__tuple_like_tag_t __tag, _UTuple&& __u)
 {
   _M_head(*this) = std::get<_Idx>(std::forward<_UTuple>(__u));
   _M_tail(*this)._M_assign(__tag, std::forward<_UTuple>(__u));
 }

      template<typename _UTuple>
 constexpr void
 _M_assign(__tuple_like_tag_t __tag, _UTuple&& __u) const
 {
   _M_head(*this) = std::get<_Idx>(std::forward<_UTuple>(__u));
   _M_tail(*this)._M_assign(__tag, std::forward<_UTuple>(__u));
 }


    protected:
      constexpr
      void
      _M_swap(_Tuple_impl& __in)
      {
 using std::swap;
 swap(_M_head(*this), _M_head(__in));
 _Inherited::_M_swap(_M_tail(__in));
      }


      constexpr void
      _M_swap(const _Tuple_impl& __in) const
      {
 using std::swap;
 swap(_M_head(*this), _M_head(__in));
 _Inherited::_M_swap(_M_tail(__in));
      }

    };


  template<size_t _Idx, typename _Head>
    struct _Tuple_impl<_Idx, _Head>
    : private _Head_base<_Idx, _Head>
    {
      template<size_t, typename...> friend struct _Tuple_impl;

      typedef _Head_base<_Idx, _Head> _Base;

      static constexpr _Head&
      _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }

      static constexpr const _Head&
      _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }

      constexpr
      _Tuple_impl()
      : _Base() { }

      explicit constexpr
      _Tuple_impl(const _Head& __head)
      : _Base(__head)
      { }

      template<typename _UHead>
 explicit constexpr
 _Tuple_impl(_UHead&& __head)
 : _Base(std::forward<_UHead>(__head))
 { }

      constexpr _Tuple_impl(const _Tuple_impl&) = default;



      _Tuple_impl& operator=(const _Tuple_impl&) = delete;




      constexpr
      _Tuple_impl(_Tuple_impl&& __in)
      noexcept(is_nothrow_move_constructible<_Head>::value)
      : _Base(static_cast<_Base&&>(__in))
      { }


      template<typename _UHead>
 constexpr
 _Tuple_impl(const _Tuple_impl<_Idx, _UHead>& __in)
 : _Base(_Tuple_impl<_Idx, _UHead>::_M_head(__in))
 { }

      template<typename _UHead>
 constexpr
 _Tuple_impl(_Tuple_impl<_Idx, _UHead>&& __in)
 : _Base(std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
 { }


      template<typename _UHead>
 constexpr
 _Tuple_impl(_Tuple_impl<_Idx, _UHead>& __in)
 : _Base(_Tuple_impl<_Idx, _UHead>::_M_head(__in))
 { }

      template<typename _UHead>
 constexpr
 _Tuple_impl(const _Tuple_impl<_Idx, _UHead>&& __in)
 : _Base(std::forward<const _UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
 { }



      template<typename _UTuple>
 constexpr
 _Tuple_impl(__tuple_like_tag_t, _UTuple&& __u, index_sequence<0>)
 : _Tuple_impl(std::get<0>(std::forward<_UTuple>(__u)))
 { }


      template<typename _Alloc>
 constexpr
 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a)
 : _Base(__tag, __use_alloc<_Head>(__a))
 { }

      template<typename _Alloc>
 constexpr
 _Tuple_impl(allocator_arg_t, const _Alloc& __a,
      const _Head& __head)
 : _Base(__use_alloc<_Head, _Alloc, const _Head&>(__a), __head)
 { }

      template<typename _Alloc, typename _UHead>
 constexpr
 _Tuple_impl(allocator_arg_t, const _Alloc& __a,
      _UHead&& __head)
 : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
  std::forward<_UHead>(__head))
 { }

      template<typename _Alloc>
 constexpr
 _Tuple_impl(allocator_arg_t, const _Alloc& __a,
      const _Tuple_impl& __in)
 : _Base(__use_alloc<_Head, _Alloc, const _Head&>(__a), _M_head(__in))
 { }

      template<typename _Alloc>
 constexpr
 _Tuple_impl(allocator_arg_t, const _Alloc& __a,
      _Tuple_impl&& __in)
 : _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
  std::forward<_Head>(_M_head(__in)))
 { }

      template<typename _Alloc, typename _UHead>
 constexpr
 _Tuple_impl(allocator_arg_t, const _Alloc& __a,
      const _Tuple_impl<_Idx, _UHead>& __in)
 : _Base(__use_alloc<_Head, _Alloc, const _UHead&>(__a),
  _Tuple_impl<_Idx, _UHead>::_M_head(__in))
 { }

      template<typename _Alloc, typename _UHead>
 constexpr
 _Tuple_impl(allocator_arg_t, const _Alloc& __a,
      _Tuple_impl<_Idx, _UHead>&& __in)
 : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
  std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
 { }


      template<typename _Alloc, typename _UHead>
 constexpr
 _Tuple_impl(allocator_arg_t, const _Alloc& __a,
      _Tuple_impl<_Idx, _UHead>& __in)
 : _Base(__use_alloc<_Head, _Alloc, _UHead&>(__a),
  _Tuple_impl<_Idx, _UHead>::_M_head(__in))
 { }

      template<typename _Alloc, typename _UHead>
 constexpr
 _Tuple_impl(allocator_arg_t, const _Alloc& __a,
      const _Tuple_impl<_Idx, _UHead>&& __in)
 : _Base(__use_alloc<_Head, _Alloc, const _UHead>(__a),
  std::forward<const _UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
 { }



      template<typename _Alloc, typename _UTuple>
 constexpr
 _Tuple_impl(__tuple_like_tag_t, allocator_arg_t __tag, const _Alloc& __a,
      _UTuple&& __u, index_sequence<0>)
 : _Tuple_impl(__tag, __a, std::get<0>(std::forward<_UTuple>(__u)))
 { }


      template<typename _UHead>
 constexpr
 void
 _M_assign(const _Tuple_impl<_Idx, _UHead>& __in)
 {
   _M_head(*this) = _Tuple_impl<_Idx, _UHead>::_M_head(__in);
 }

      template<typename _UHead>
 constexpr
 void
 _M_assign(_Tuple_impl<_Idx, _UHead>&& __in)
 {
   _M_head(*this)
     = std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in));
 }


      template<typename _UHead>
 constexpr void
 _M_assign(const _Tuple_impl<_Idx, _UHead>& __in) const
 {
   _M_head(*this) = _Tuple_impl<_Idx, _UHead>::_M_head(__in);
 }

      template<typename _UHead>
 constexpr void
 _M_assign(_Tuple_impl<_Idx, _UHead>&& __in) const
 {
   _M_head(*this)
     = std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in));
 }



    template<typename _UTuple>
      constexpr void
      _M_assign(__tuple_like_tag_t, _UTuple&& __u)
      { _M_head(*this) = std::get<_Idx>(std::forward<_UTuple>(__u)); }

    template<typename _UTuple>
      constexpr void
      _M_assign(__tuple_like_tag_t, _UTuple&& __u) const
      { _M_head(*this) = std::get<_Idx>(std::forward<_UTuple>(__u)); }


    protected:
      constexpr
      void
      _M_swap(_Tuple_impl& __in)
      {
 using std::swap;
 swap(_M_head(*this), _M_head(__in));
      }


      constexpr void
      _M_swap(const _Tuple_impl& __in) const
      {
 using std::swap;
 swap(_M_head(*this), _M_head(__in));
      }

    };



  template<bool, typename... _Types>
    struct _TupleConstraints
    {
      template<typename... _UTypes>
 using __constructible = __and_<is_constructible<_Types, _UTypes>...>;

      template<typename... _UTypes>
 using __convertible = __and_<is_convertible<_UTypes, _Types>...>;




      template<typename... _UTypes>
 static constexpr bool __is_implicitly_constructible()
 {
   return __and_<__constructible<_UTypes...>,
   __convertible<_UTypes...>
   >::value;
 }




      template<typename... _UTypes>
 static constexpr bool __is_explicitly_constructible()
 {
   return __and_<__constructible<_UTypes...>,
   __not_<__convertible<_UTypes...>>
   >::value;
 }

      static constexpr bool __is_implicitly_default_constructible()
      {
 return __and_<std::__is_implicitly_default_constructible<_Types>...
        >::value;
      }

      static constexpr bool __is_explicitly_default_constructible()
      {
 return __and_<is_default_constructible<_Types>...,
        __not_<__and_<
   std::__is_implicitly_default_constructible<_Types>...>
        >>::value;
      }
    };



  template<typename... _Types>
    struct _TupleConstraints<false, _Types...>
    {
      template<typename... _UTypes>
 static constexpr bool __is_implicitly_constructible()
 { return false; }

      template<typename... _UTypes>
 static constexpr bool __is_explicitly_constructible()
 { return false; }
    };


  template<typename... _Elements>
    class tuple : public _Tuple_impl<0, _Elements...>
    {
      using _Inherited = _Tuple_impl<0, _Elements...>;


      template<typename... _UTypes>
 static consteval bool
 __constructible()
 {
   if constexpr (sizeof...(_UTypes) == sizeof...(_Elements))
     return __and_v<is_constructible<_Elements, _UTypes>...>;
   else
     return false;
 }

      template<typename... _UTypes>
 static consteval bool
 __nothrow_constructible()
 {
   if constexpr (sizeof...(_UTypes) == sizeof...(_Elements))
     return __and_v<is_nothrow_constructible<_Elements, _UTypes>...>;
   else
     return false;
 }

      template<typename... _UTypes>
 static consteval bool
 __convertible()
 {
   if constexpr (sizeof...(_UTypes) == sizeof...(_Elements))
     return __and_v<is_convertible<_UTypes, _Elements>...>;
   else
     return false;
 }



      template<typename... _UTypes>
 static consteval bool
 __disambiguating_constraint()
 {
   if constexpr (sizeof...(_Elements) != sizeof...(_UTypes))
     return false;
   else if constexpr (sizeof...(_Elements) == 1)
     {
       using _U0 = typename _Nth_type<0, _UTypes...>::type;
       return !is_same_v<remove_cvref_t<_U0>, tuple>;
     }
   else if constexpr (sizeof...(_Elements) < 4)
     {
       using _U0 = typename _Nth_type<0, _UTypes...>::type;
       if constexpr (!is_same_v<remove_cvref_t<_U0>, allocator_arg_t>)
  return true;
       else
  {
    using _T0 = typename _Nth_type<0, _Elements...>::type;
    return is_same_v<remove_cvref_t<_T0>, allocator_arg_t>;
  }
     }
   return true;
 }




      template<typename _Tuple>
 static consteval bool
 __use_other_ctor()
 {
   if constexpr (sizeof...(_Elements) != 1)
     return false;
   else if constexpr (is_same_v<remove_cvref_t<_Tuple>, tuple>)
     return true;
   else
     {
       using _Tp = typename _Nth_type<0, _Elements...>::type;
       if constexpr (is_convertible_v<_Tuple, _Tp>)
  return true;
       else if constexpr (is_constructible_v<_Tp, _Tuple>)
  return true;
     }
   return false;
 }

      template<typename... _Up>
 static consteval bool
 __dangles()
 {

   return (__reference_constructs_from_temporary(_Elements, _Up&&)
      || ...);



 }




      template<typename _UTuple>
 static consteval bool
 __dangles_from_tuple_like()
 {
   return []<size_t... _Is>(index_sequence<_Is...>) {
     return __dangles<decltype(std::get<_Is>(std::declval<_UTuple>()))...>();
   }(index_sequence_for<_Elements...>{});
 }

      template<typename _UTuple>
 static consteval bool
 __constructible_from_tuple_like()
 {
   return []<size_t... _Is>(index_sequence<_Is...>) {
     return __constructible<decltype(std::get<_Is>(std::declval<_UTuple>()))...>();
   }(index_sequence_for<_Elements...>{});
 }

      template<typename _UTuple>
 static consteval bool
 __convertible_from_tuple_like()
 {
   return []<size_t... _Is>(index_sequence<_Is...>) {
     return __convertible<decltype(std::get<_Is>(std::declval<_UTuple>()))...>();
   }(index_sequence_for<_Elements...>{});
 }


    public:
      constexpr
      explicit(!(__is_implicitly_default_constructible_v<_Elements> && ...))
      tuple()
      noexcept((is_nothrow_default_constructible_v<_Elements> && ...))
      requires (is_default_constructible_v<_Elements> && ...)
      : _Inherited()
      { }

      constexpr explicit(!__convertible<const _Elements&...>())
      tuple(const _Elements&... __elements)
      noexcept(__nothrow_constructible<const _Elements&...>())
      requires (__constructible<const _Elements&...>())
      : _Inherited(__elements...)
      { }

      template<typename... _UTypes>
 requires (__disambiguating_constraint<_UTypes...>())
   && (__constructible<_UTypes...>())
   && (!__dangles<_UTypes...>())
 constexpr explicit(!__convertible<_UTypes...>())
 tuple(_UTypes&&... __u)
 noexcept(__nothrow_constructible<_UTypes...>())
 : _Inherited(std::forward<_UTypes>(__u)...)
 { }

      template<typename... _UTypes>
 requires (__disambiguating_constraint<_UTypes...>())
   && (__constructible<_UTypes...>())
   && (__dangles<_UTypes...>())
 tuple(_UTypes&&...) = delete;

      constexpr tuple(const tuple&) = default;

      constexpr tuple(tuple&&) = default;

      template<typename... _UTypes>
 requires (__constructible<const _UTypes&...>())
   && (!__use_other_ctor<const tuple<_UTypes...>&>())
   && (!__dangles<const _UTypes&...>())
 constexpr explicit(!__convertible<const _UTypes&...>())
 tuple(const tuple<_UTypes...>& __u)
 noexcept(__nothrow_constructible<const _UTypes&...>())
 : _Inherited(static_cast<const _Tuple_impl<0, _UTypes...>&>(__u))
 { }

      template<typename... _UTypes>
 requires (__constructible<const _UTypes&...>())
   && (!__use_other_ctor<const tuple<_UTypes...>&>())
   && (__dangles<const _UTypes&...>())
 tuple(const tuple<_UTypes...>&) = delete;

      template<typename... _UTypes>
 requires (__constructible<_UTypes...>())
   && (!__use_other_ctor<tuple<_UTypes...>>())
   && (!__dangles<_UTypes...>())
 constexpr explicit(!__convertible<_UTypes...>())
 tuple(tuple<_UTypes...>&& __u)
 noexcept(__nothrow_constructible<_UTypes...>())
 : _Inherited(static_cast<_Tuple_impl<0, _UTypes...>&&>(__u))
 { }

      template<typename... _UTypes>
 requires (__constructible<_UTypes...>())
   && (!__use_other_ctor<tuple<_UTypes...>>())
   && (__dangles<_UTypes...>())
 tuple(tuple<_UTypes...>&&) = delete;


      template<typename... _UTypes>
 requires (__constructible<_UTypes&...>())
   && (!__use_other_ctor<tuple<_UTypes...>&>())
   && (!__dangles<_UTypes&...>())
 constexpr explicit(!__convertible<_UTypes&...>())
 tuple(tuple<_UTypes...>& __u)
 noexcept(__nothrow_constructible<_UTypes&...>())
 : _Inherited(static_cast<_Tuple_impl<0, _UTypes...>&>(__u))
 { }

      template<typename... _UTypes>
 requires (__constructible<_UTypes&...>())
   && (!__use_other_ctor<tuple<_UTypes...>&>())
   && (__dangles<_UTypes&...>())
 tuple(tuple<_UTypes...>&) = delete;

      template<typename... _UTypes>
 requires (__constructible<const _UTypes...>())
   && (!__use_other_ctor<const tuple<_UTypes...>>())
   && (!__dangles<const _UTypes...>())
 constexpr explicit(!__convertible<const _UTypes...>())
 tuple(const tuple<_UTypes...>&& __u)
 noexcept(__nothrow_constructible<const _UTypes...>())
 : _Inherited(static_cast<const _Tuple_impl<0, _UTypes...>&&>(__u))
 { }

      template<typename... _UTypes>
 requires (__constructible<const _UTypes...>())
   && (!__use_other_ctor<const tuple<_UTypes...>>())
   && (__dangles<const _UTypes...>())
 tuple(const tuple<_UTypes...>&&) = delete;


      template<typename _U1, typename _U2>
 requires (sizeof...(_Elements) == 2)
   && (__constructible<const _U1&, const _U2&>())
   && (!__dangles<const _U1&, const _U2&>())
 constexpr explicit(!__convertible<const _U1&, const _U2&>())
 tuple(const pair<_U1, _U2>& __u)
 noexcept(__nothrow_constructible<const _U1&, const _U2&>())
 : _Inherited(__u.first, __u.second)
 { }

      template<typename _U1, typename _U2>
 requires (sizeof...(_Elements) == 2)
   && (__constructible<const _U1&, const _U2&>())
   && (__dangles<const _U1&, const _U2&>())
 tuple(const pair<_U1, _U2>&) = delete;

      template<typename _U1, typename _U2>
 requires (sizeof...(_Elements) == 2)
   && (__constructible<_U1, _U2>())
   && (!__dangles<_U1, _U2>())
 constexpr explicit(!__convertible<_U1, _U2>())
 tuple(pair<_U1, _U2>&& __u)
 noexcept(__nothrow_constructible<_U1, _U2>())
 : _Inherited(std::forward<_U1>(__u.first),
       std::forward<_U2>(__u.second))
 { }

      template<typename _U1, typename _U2>
 requires (sizeof...(_Elements) == 2)
   && (__constructible<_U1, _U2>())
   && (__dangles<_U1, _U2>())
 tuple(pair<_U1, _U2>&&) = delete;


      template<typename _U1, typename _U2>
 requires (sizeof...(_Elements) == 2)
   && (__constructible<_U1&, _U2&>())
   && (!__dangles<_U1&, _U2&>())
 constexpr explicit(!__convertible<_U1&, _U2&>())
 tuple(pair<_U1, _U2>& __u)
 noexcept(__nothrow_constructible<_U1&, _U2&>())
 : _Inherited(__u.first, __u.second)
 { }

      template<typename _U1, typename _U2>
 requires (sizeof...(_Elements) == 2)
   && (__constructible<_U1&, _U2&>())
   && (__dangles<_U1&, _U2&>())
 tuple(pair<_U1, _U2>&) = delete;

      template<typename _U1, typename _U2>
 requires (sizeof...(_Elements) == 2)
   && (__constructible<const _U1, const _U2>())
   && (!__dangles<const _U1, const _U2>())
 constexpr explicit(!__convertible<const _U1, const _U2>())
 tuple(const pair<_U1, _U2>&& __u)
 noexcept(__nothrow_constructible<const _U1, const _U2>())
 : _Inherited(std::forward<const _U1>(__u.first),
       std::forward<const _U2>(__u.second))
 { }

      template<typename _U1, typename _U2>
 requires (sizeof...(_Elements) == 2)
   && (__constructible<const _U1, const _U2>())
   && (__dangles<const _U1, const _U2>())
 tuple(const pair<_U1, _U2>&&) = delete;



      template<__eligible_tuple_like<tuple> _UTuple>
 requires (__constructible_from_tuple_like<_UTuple>())
   && (!__use_other_ctor<_UTuple>())
   && (!__dangles_from_tuple_like<_UTuple>())
 constexpr explicit(!__convertible_from_tuple_like<_UTuple>())
 tuple(_UTuple&& __u)
 : _Inherited(__tuple_like_tag_t{},
       std::forward<_UTuple>(__u),
       index_sequence_for<_Elements...>{})
 { }

      template<__eligible_tuple_like<tuple> _UTuple>
 requires (__constructible_from_tuple_like<_UTuple>())
   && (!__use_other_ctor<_UTuple>())
   && (__dangles_from_tuple_like<_UTuple>())
 tuple(_UTuple&&) = delete;




      template<typename _Alloc>
 constexpr
 explicit(!(__is_implicitly_default_constructible_v<_Elements> && ...))
 tuple(allocator_arg_t __tag, const _Alloc& __a)
 requires (is_default_constructible_v<_Elements> && ...)
 : _Inherited(__tag, __a)
 { }

      template<typename _Alloc>
 constexpr explicit(!__convertible<const _Elements&...>())
 tuple(allocator_arg_t __tag, const _Alloc& __a,
       const _Elements&... __elements)
 requires (__constructible<const _Elements&...>())
 : _Inherited(__tag, __a, __elements...)
 { }

      template<typename _Alloc, typename... _UTypes>
 requires (__disambiguating_constraint<_UTypes...>())
   && (__constructible<_UTypes...>())
   && (!__dangles<_UTypes...>())
 constexpr explicit(!__convertible<_UTypes...>())
 tuple(allocator_arg_t __tag, const _Alloc& __a, _UTypes&&... __u)
 : _Inherited(__tag, __a, std::forward<_UTypes>(__u)...)
 { }

      template<typename _Alloc, typename... _UTypes>
 requires (__disambiguating_constraint<_UTypes...>())
   && (__constructible<_UTypes...>())
   && (__dangles<_UTypes...>())
 tuple(allocator_arg_t, const _Alloc&, _UTypes&&...) = delete;

      template<typename _Alloc>
 constexpr
 tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __u)
 : _Inherited(__tag, __a, static_cast<const _Inherited&>(__u))
 { }

      template<typename _Alloc>
 requires (__constructible<_Elements...>())
 constexpr
 tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __u)
 : _Inherited(__tag, __a, static_cast<_Inherited&&>(__u))
 { }

      template<typename _Alloc, typename... _UTypes>
 requires (__constructible<const _UTypes&...>())
   && (!__use_other_ctor<const tuple<_UTypes...>&>())
   && (!__dangles<const _UTypes&...>())
 constexpr explicit(!__convertible<const _UTypes&...>())
 tuple(allocator_arg_t __tag, const _Alloc& __a,
       const tuple<_UTypes...>& __u)
 : _Inherited(__tag, __a,
       static_cast<const _Tuple_impl<0, _UTypes...>&>(__u))
 { }

      template<typename _Alloc, typename... _UTypes>
 requires (__constructible<const _UTypes&...>())
   && (!__use_other_ctor<const tuple<_UTypes...>&>())
   && (__dangles<const _UTypes&...>())
 tuple(allocator_arg_t, const _Alloc&, const tuple<_UTypes...>&) = delete;

      template<typename _Alloc, typename... _UTypes>
 requires (__constructible<_UTypes...>())
   && (!__use_other_ctor<tuple<_UTypes...>>())
   && (!__dangles<_UTypes...>())
 constexpr explicit(!__use_other_ctor<tuple<_UTypes...>>())
 tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_UTypes...>&& __u)
 : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _UTypes...>&&>(__u))
 { }

      template<typename _Alloc, typename... _UTypes>
 requires (__constructible<_UTypes...>())
   && (!__use_other_ctor<tuple<_UTypes...>>())
   && (__dangles<_UTypes...>())
 tuple(allocator_arg_t, const _Alloc&, tuple<_UTypes...>&&) = delete;


      template<typename _Alloc, typename... _UTypes>
 requires (__constructible<_UTypes&...>())
   && (!__use_other_ctor<tuple<_UTypes...>&>())
   && (!__dangles<_UTypes&...>())
 constexpr explicit(!__convertible<_UTypes&...>())
 tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_UTypes...>& __u)
 : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _UTypes...>&>(__u))
 { }

      template<typename _Alloc, typename... _UTypes>
 requires (__constructible<_UTypes&...>())
   && (!__use_other_ctor<tuple<_UTypes...>&>())
   && (__dangles<_UTypes&...>())
 tuple(allocator_arg_t, const _Alloc&, tuple<_UTypes...>&) = delete;

      template<typename _Alloc, typename... _UTypes>
 requires (__constructible<const _UTypes...>())
   && (!__use_other_ctor<const tuple<_UTypes...>>())
   && (!__dangles<const _UTypes...>())
 constexpr explicit(!__convertible<const _UTypes...>())
 tuple(allocator_arg_t __tag, const _Alloc& __a,
       const tuple<_UTypes...>&& __u)
 : _Inherited(__tag, __a,
       static_cast<const _Tuple_impl<0, _UTypes...>&&>(__u))
 { }

      template<typename _Alloc, typename... _UTypes>
 requires (__constructible<const _UTypes...>())
   && (!__use_other_ctor<const tuple<_UTypes...>>())
   && (__dangles<const _UTypes...>())
 tuple(allocator_arg_t, const _Alloc&, const tuple<_UTypes...>&&) = delete;


      template<typename _Alloc, typename _U1, typename _U2>
 requires (sizeof...(_Elements) == 2)
   && (__constructible<const _U1&, const _U2&>())
   && (!__dangles<const _U1&, const _U2&>())
 constexpr explicit(!__convertible<const _U1&, const _U2&>())
 tuple(allocator_arg_t __tag, const _Alloc& __a,
       const pair<_U1, _U2>& __u)
 noexcept(__nothrow_constructible<const _U1&, const _U2&>())
 : _Inherited(__tag, __a, __u.first, __u.second)
 { }

      template<typename _Alloc, typename _U1, typename _U2>
 requires (sizeof...(_Elements) == 2)
   && (__constructible<const _U1&, const _U2&>())
   && (__dangles<const _U1&, const _U2&>())
 tuple(allocator_arg_t, const _Alloc&, const pair<_U1, _U2>&) = delete;

      template<typename _Alloc, typename _U1, typename _U2>
 requires (sizeof...(_Elements) == 2)
   && (__constructible<_U1, _U2>())
   && (!__dangles<_U1, _U2>())
 constexpr explicit(!__convertible<_U1, _U2>())
 tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __u)
 noexcept(__nothrow_constructible<_U1, _U2>())
 : _Inherited(__tag, __a, std::move(__u.first), std::move(__u.second))
 { }

      template<typename _Alloc, typename _U1, typename _U2>
 requires (sizeof...(_Elements) == 2)
   && (__constructible<_U1, _U2>())
   && (__dangles<_U1, _U2>())
 tuple(allocator_arg_t, const _Alloc&, pair<_U1, _U2>&&) = delete;


      template<typename _Alloc, typename _U1, typename _U2>
 requires (sizeof...(_Elements) == 2)
   && (__constructible<_U1&, _U2&>())
   && (!__dangles<_U1&, _U2&>())
 constexpr explicit(!__convertible<_U1&, _U2&>())
 tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>& __u)
 noexcept(__nothrow_constructible<_U1&, _U2&>())
 : _Inherited(__tag, __a, __u.first, __u.second)
 { }

      template<typename _Alloc, typename _U1, typename _U2>
 requires (sizeof...(_Elements) == 2)
   && (__constructible<_U1&, _U2&>())
   && (__dangles<_U1&, _U2&>())
 tuple(allocator_arg_t, const _Alloc&, pair<_U1, _U2>&) = delete;

      template<typename _Alloc, typename _U1, typename _U2>
 requires (sizeof...(_Elements) == 2)
   && (__constructible<const _U1, const _U2>())
   && (!__dangles<const _U1, const _U2>())
 constexpr explicit(!__convertible<const _U1, const _U2>())
 tuple(allocator_arg_t __tag, const _Alloc& __a,
 const pair<_U1, _U2>&& __u)
 noexcept(__nothrow_constructible<const _U1, const _U2>())
 : _Inherited(__tag, __a, std::move(__u.first), std::move(__u.second))
 { }

      template<typename _Alloc, typename _U1, typename _U2>
 requires (sizeof...(_Elements) == 2)
   && (__constructible<const _U1, const _U2>())
   && (__dangles<const _U1, const _U2>())
 tuple(allocator_arg_t, const _Alloc&, const pair<_U1, _U2>&&) = delete;



      template<typename _Alloc, __eligible_tuple_like<tuple> _UTuple>
 requires (__constructible_from_tuple_like<_UTuple>())
   && (!__use_other_ctor<_UTuple>())
   && (!__dangles_from_tuple_like<_UTuple>())
 constexpr explicit(!__convertible_from_tuple_like<_UTuple>())
 tuple(allocator_arg_t __tag, const _Alloc& __a, _UTuple&& __u)
 : _Inherited(__tuple_like_tag_t{},
       __tag, __a, std::forward<_UTuple>(__u),
       index_sequence_for<_Elements...>{})
 { }

      template<typename _Alloc, __eligible_tuple_like<tuple> _UTuple>
 requires (__constructible_from_tuple_like<_UTuple>())
   && (!__use_other_ctor<_UTuple>())
   && (__dangles_from_tuple_like<_UTuple>())
 tuple(allocator_arg_t, const _Alloc&, _UTuple&&) = delete;
# 1654 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tuple" 3
    private:
      template<typename... _UTypes>
 static consteval bool
 __assignable()
 {
   if constexpr (sizeof...(_UTypes) == sizeof...(_Elements))
     return __and_v<is_assignable<_Elements&, _UTypes>...>;
   else
     return false;
 }

      template<typename... _UTypes>
 static consteval bool
 __nothrow_assignable()
 {
   if constexpr (sizeof...(_UTypes) == sizeof...(_Elements))
     return __and_v<is_nothrow_assignable<_Elements&, _UTypes>...>;
   else
     return false;
 }


      template<typename... _UTypes>
 static consteval bool
 __const_assignable()
 {
   if constexpr (sizeof...(_UTypes) == sizeof...(_Elements))
     return __and_v<is_assignable<const _Elements&, _UTypes>...>;
   else
     return false;
 }



      template<typename _UTuple>
 static consteval bool
 __assignable_from_tuple_like()
 {
   return []<size_t... _Is>(index_sequence<_Is...>) {
     return __assignable<decltype(std::get<_Is>(std::declval<_UTuple>()))...>();
   }(index_sequence_for<_Elements...>{});
 }

      template<typename _UTuple>
 static consteval bool
 __const_assignable_from_tuple_like()
 {
   return []<size_t... _Is>(index_sequence<_Is...>) {
     return __const_assignable<decltype(std::get<_Is>(std::declval<_UTuple>()))...>();
   }(index_sequence_for<_Elements...>{});
 }


    public:

      tuple& operator=(const tuple& __u) = delete;

      constexpr tuple&
      operator=(const tuple& __u)
      noexcept(__nothrow_assignable<const _Elements&...>())
      requires (__assignable<const _Elements&...>())
      {
 this->_M_assign(__u);
 return *this;
      }

      constexpr tuple&
      operator=(tuple&& __u)
      noexcept(__nothrow_assignable<_Elements...>())
      requires (__assignable<_Elements...>())
      {
 this->_M_assign(std::move(__u));
 return *this;
      }

      template<typename... _UTypes>
 requires (__assignable<const _UTypes&...>())
 constexpr tuple&
 operator=(const tuple<_UTypes...>& __u)
 noexcept(__nothrow_assignable<const _UTypes&...>())
 {
   this->_M_assign(__u);
   return *this;
 }

      template<typename... _UTypes>
 requires (__assignable<_UTypes...>())
 constexpr tuple&
 operator=(tuple<_UTypes...>&& __u)
 noexcept(__nothrow_assignable<_UTypes...>())
 {
   this->_M_assign(std::move(__u));
   return *this;
 }


      constexpr const tuple&
      operator=(const tuple& __u) const
      requires (__const_assignable<const _Elements&...>())
      {
 this->_M_assign(__u);
 return *this;
      }

      constexpr const tuple&
      operator=(tuple&& __u) const
      requires (__const_assignable<_Elements...>())
      {
 this->_M_assign(std::move(__u));
 return *this;
      }

      template<typename... _UTypes>
 constexpr const tuple&
 operator=(const tuple<_UTypes...>& __u) const
 requires (__const_assignable<const _UTypes&...>())
 {
   this->_M_assign(__u);
   return *this;
 }

      template<typename... _UTypes>
 constexpr const tuple&
 operator=(tuple<_UTypes...>&& __u) const
 requires (__const_assignable<_UTypes...>())
 {
   this->_M_assign(std::move(__u));
   return *this;
 }


      template<typename _U1, typename _U2>
 requires (__assignable<const _U1&, const _U2&>())
 constexpr tuple&
 operator=(const pair<_U1, _U2>& __u)
 noexcept(__nothrow_assignable<const _U1&, const _U2&>())
 {
   this->_M_head(*this) = __u.first;
   this->_M_tail(*this)._M_head(*this) = __u.second;
   return *this;
 }

      template<typename _U1, typename _U2>
 requires (__assignable<_U1, _U2>())
 constexpr tuple&
 operator=(pair<_U1, _U2>&& __u)
 noexcept(__nothrow_assignable<_U1, _U2>())
 {
   this->_M_head(*this) = std::forward<_U1>(__u.first);
   this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(__u.second);
   return *this;
 }


      template<typename _U1, typename _U2>
 requires (__const_assignable<const _U1&, const _U2>())
 constexpr const tuple&
 operator=(const pair<_U1, _U2>& __u) const
 {
   this->_M_head(*this) = __u.first;
   this->_M_tail(*this)._M_head(*this) = __u.second;
   return *this;
 }

      template<typename _U1, typename _U2>
 requires (__const_assignable<_U1, _U2>())
 constexpr const tuple&
 operator=(pair<_U1, _U2>&& __u) const
 {
   this->_M_head(*this) = std::forward<_U1>(__u.first);
   this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(__u.second);
   return *this;
 }



      template<__eligible_tuple_like<tuple> _UTuple>
 requires (__assignable_from_tuple_like<_UTuple>())
 constexpr tuple&
 operator=(_UTuple&& __u)
 {
   this->_M_assign(__tuple_like_tag_t{}, std::forward<_UTuple>(__u));
   return *this;
 }

      template<__eligible_tuple_like<tuple> _UTuple>
 requires (__const_assignable_from_tuple_like<_UTuple>())
 constexpr const tuple&
 operator=(_UTuple&& __u) const
 {
   this->_M_assign(__tuple_like_tag_t{}, std::forward<_UTuple>(__u));
   return *this;
 }

      template<__tuple_like _UTuple>
 requires (!__is_tuple_v<_UTuple>)
 friend constexpr bool
 operator==(const tuple& __t, const _UTuple& __u)
 {
   static_assert(sizeof...(_Elements) == tuple_size_v<_UTuple>,
       "tuple objects can only be compared if they have equal sizes.");
   return [&]<size_t... _Is>(index_sequence<_Is...>) {
     return (bool(std::get<_Is>(__t) == std::get<_Is>(__u))
      && ...);
   }(index_sequence_for<_Elements...>{});
 }

      template<__tuple_like _UTuple,
        typename = make_index_sequence<tuple_size_v<_UTuple>>>
 struct __tuple_like_common_comparison_category;

      template<__tuple_like _UTuple, size_t... _Is>
 requires requires
   { typename void_t<__detail::__synth3way_t<_Elements, tuple_element_t<_Is, _UTuple>>...>; }
 struct __tuple_like_common_comparison_category<_UTuple, index_sequence<_Is...>>
 {
   using type = common_comparison_category_t
     <__detail::__synth3way_t<_Elements, tuple_element_t<_Is, _UTuple>>...>;
 };

      template<__tuple_like _UTuple>
 requires (!__is_tuple_v<_UTuple>)
 friend constexpr typename __tuple_like_common_comparison_category<_UTuple>::type
 operator<=>(const tuple& __t, const _UTuple& __u)
 {
   using _Cat = typename __tuple_like_common_comparison_category<_UTuple>::type;
   return std::__tuple_cmp<_Cat>(__t, __u, index_sequence_for<_Elements...>());
 }
# 1947 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tuple" 3
      constexpr
      void
      swap(tuple& __in)
      noexcept(__and_<__is_nothrow_swappable<_Elements>...>::value)
      { _Inherited::_M_swap(__in); }
# 1960 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tuple" 3
      constexpr void
      swap(const tuple& __in) const
      noexcept(__and_v<__is_nothrow_swappable<const _Elements>...>)
      requires (is_swappable_v<const _Elements> && ...)
      { _Inherited::_M_swap(__in); }

    };


  template<typename... _UTypes>
    tuple(_UTypes...) -> tuple<_UTypes...>;
  template<typename _T1, typename _T2>
    tuple(pair<_T1, _T2>) -> tuple<_T1, _T2>;
  template<typename _Alloc, typename... _UTypes>
    tuple(allocator_arg_t, _Alloc, _UTypes...) -> tuple<_UTypes...>;
  template<typename _Alloc, typename _T1, typename _T2>
    tuple(allocator_arg_t, _Alloc, pair<_T1, _T2>) -> tuple<_T1, _T2>;
  template<typename _Alloc, typename... _UTypes>
    tuple(allocator_arg_t, _Alloc, tuple<_UTypes...>) -> tuple<_UTypes...>;



  template<>
    class tuple<>
    {
    public:
      constexpr
      void swap(tuple&) noexcept { }

      constexpr void swap(const tuple&) const noexcept { }



      tuple() = default;

      template<typename _Alloc>
 constexpr
 tuple(allocator_arg_t, const _Alloc&) noexcept { }
      template<typename _Alloc>
 constexpr
 tuple(allocator_arg_t, const _Alloc&, const tuple&) noexcept { }
    };
# 2402 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tuple" 3
  template<typename... _Elements>
    struct tuple_size<tuple<_Elements...>>
    : public integral_constant<size_t, sizeof...(_Elements)> { };


  template<typename... _Types>
    inline constexpr size_t tuple_size_v<tuple<_Types...>>
      = sizeof...(_Types);

  template<typename... _Types>
    inline constexpr size_t tuple_size_v<const tuple<_Types...>>
      = sizeof...(_Types);



  template<size_t __i, typename... _Types>
    struct tuple_element<__i, tuple<_Types...>>
    {
      static_assert(__i < sizeof...(_Types), "tuple index must be in range");

      using type = typename _Nth_type<__i, _Types...>::type;
    };

  template<size_t __i, typename _Head, typename... _Tail>
    constexpr _Head&
    __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
    { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }

  template<size_t __i, typename _Head, typename... _Tail>
    constexpr const _Head&
    __get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
    { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }


  template<size_t __i, typename... _Types>
    __enable_if_t<(__i >= sizeof...(_Types))>
    __get_helper(const tuple<_Types...>&) = delete;


  template<size_t __i, typename... _Elements>
    constexpr __tuple_element_t<__i, tuple<_Elements...>>&
    get(tuple<_Elements...>& __t) noexcept
    { return std::__get_helper<__i>(__t); }


  template<size_t __i, typename... _Elements>
    constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
    get(const tuple<_Elements...>& __t) noexcept
    { return std::__get_helper<__i>(__t); }


  template<size_t __i, typename... _Elements>
    constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
    get(tuple<_Elements...>&& __t) noexcept
    {
      typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type;
      return std::forward<__element_type>(std::__get_helper<__i>(__t));
    }


  template<size_t __i, typename... _Elements>
    constexpr const __tuple_element_t<__i, tuple<_Elements...>>&&
    get(const tuple<_Elements...>&& __t) noexcept
    {
      typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type;
      return std::forward<const __element_type>(std::__get_helper<__i>(__t));
    }



  template<size_t __i, typename... _Elements>
    constexpr __enable_if_t<(__i >= sizeof...(_Elements))>
    get(const tuple<_Elements...>&) = delete;




  template <typename _Tp, typename... _Types>
    constexpr _Tp&
    get(tuple<_Types...>& __t) noexcept
    {
      constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>();
      static_assert(__idx < sizeof...(_Types),
   "the type T in std::get<T> must occur exactly once in the tuple");
      return std::__get_helper<__idx>(__t);
    }


  template <typename _Tp, typename... _Types>
    constexpr _Tp&&
    get(tuple<_Types...>&& __t) noexcept
    {
      constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>();
      static_assert(__idx < sizeof...(_Types),
   "the type T in std::get<T> must occur exactly once in the tuple");
      return std::forward<_Tp>(std::__get_helper<__idx>(__t));
    }


  template <typename _Tp, typename... _Types>
    constexpr const _Tp&
    get(const tuple<_Types...>& __t) noexcept
    {
      constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>();
      static_assert(__idx < sizeof...(_Types),
   "the type T in std::get<T> must occur exactly once in the tuple");
      return std::__get_helper<__idx>(__t);
    }



  template <typename _Tp, typename... _Types>
    constexpr const _Tp&&
    get(const tuple<_Types...>&& __t) noexcept
    {
      constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>();
      static_assert(__idx < sizeof...(_Types),
   "the type T in std::get<T> must occur exactly once in the tuple");
      return std::forward<const _Tp>(std::__get_helper<__idx>(__t));
    }



  template<typename _Tp, typename _Up, size_t __i, size_t __size>
    struct __tuple_compare
    {
      static constexpr bool
      __eq(const _Tp& __t, const _Up& __u)
      {
 return bool(std::get<__i>(__t) == std::get<__i>(__u))
   && __tuple_compare<_Tp, _Up, __i + 1, __size>::__eq(__t, __u);
      }

      static constexpr bool
      __less(const _Tp& __t, const _Up& __u)
      {
 return bool(std::get<__i>(__t) < std::get<__i>(__u))
   || (!bool(std::get<__i>(__u) < std::get<__i>(__t))
       && __tuple_compare<_Tp, _Up, __i + 1, __size>::__less(__t, __u));
      }
    };

  template<typename _Tp, typename _Up, size_t __size>
    struct __tuple_compare<_Tp, _Up, __size, __size>
    {
      static constexpr bool
      __eq(const _Tp&, const _Up&) { return true; }

      static constexpr bool
      __less(const _Tp&, const _Up&) { return false; }
    };

  template<typename... _TElements, typename... _UElements>
    constexpr bool
    operator==(const tuple<_TElements...>& __t,
        const tuple<_UElements...>& __u)
    {
      static_assert(sizeof...(_TElements) == sizeof...(_UElements),
   "tuple objects can only be compared if they have equal sizes.");
      using __compare = __tuple_compare<tuple<_TElements...>,
     tuple<_UElements...>,
     0, sizeof...(_TElements)>;
      return __compare::__eq(__t, __u);
    }


  template<typename _Cat, typename _Tp, typename _Up>
    constexpr _Cat
    __tuple_cmp(const _Tp&, const _Up&, index_sequence<>)
    { return _Cat::equivalent; }

  template<typename _Cat, typename _Tp, typename _Up,
    size_t _Idx0, size_t... _Idxs>
    constexpr _Cat
    __tuple_cmp(const _Tp& __t, const _Up& __u,
  index_sequence<_Idx0, _Idxs...>)
    {
      auto __c
 = __detail::__synth3way(std::get<_Idx0>(__t), std::get<_Idx0>(__u));
      if (__c != 0)
 return __c;
      return std::__tuple_cmp<_Cat>(__t, __u, index_sequence<_Idxs...>());
    }

  template<typename... _Tps, typename... _Ups>
    constexpr
    common_comparison_category_t<__detail::__synth3way_t<_Tps, _Ups>...>
    operator<=>(const tuple<_Tps...>& __t, const tuple<_Ups...>& __u)
    {
      using _Cat
 = common_comparison_category_t<__detail::__synth3way_t<_Tps, _Ups>...>;
      return std::__tuple_cmp<_Cat>(__t, __u, index_sequence_for<_Tps...>());
    }
# 2636 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tuple" 3
  template<typename... _Elements>
    constexpr tuple<typename __decay_and_strip<_Elements>::__type...>
    make_tuple(_Elements&&... __args)
    {
      typedef tuple<typename __decay_and_strip<_Elements>::__type...>
 __result_type;
      return __result_type(std::forward<_Elements>(__args)...);
    }




  template<typename... _Elements>
    constexpr tuple<_Elements&&...>
    forward_as_tuple(_Elements&&... __args) noexcept
    { return tuple<_Elements&&...>(std::forward<_Elements>(__args)...); }


  template<size_t, typename, typename, size_t>
    struct __make_tuple_impl;

  template<size_t _Idx, typename _Tuple, typename... _Tp, size_t _Nm>
    struct __make_tuple_impl<_Idx, tuple<_Tp...>, _Tuple, _Nm>
    : __make_tuple_impl<_Idx + 1,
   tuple<_Tp..., __tuple_element_t<_Idx, _Tuple>>,
   _Tuple, _Nm>
    { };

  template<size_t _Nm, typename _Tuple, typename... _Tp>
    struct __make_tuple_impl<_Nm, tuple<_Tp...>, _Tuple, _Nm>
    {
      typedef tuple<_Tp...> __type;
    };

  template<typename _Tuple>
    struct __do_make_tuple
    : __make_tuple_impl<0, tuple<>, _Tuple, tuple_size<_Tuple>::value>
    { };


  template<typename _Tuple>
    struct __make_tuple
    : public __do_make_tuple<__remove_cvref_t<_Tuple>>
    { };


  template<typename...>
    struct __combine_tuples;

  template<>
    struct __combine_tuples<>
    {
      typedef tuple<> __type;
    };

  template<typename... _Ts>
    struct __combine_tuples<tuple<_Ts...>>
    {
      typedef tuple<_Ts...> __type;
    };

  template<typename... _T1s, typename... _T2s, typename... _Rem>
    struct __combine_tuples<tuple<_T1s...>, tuple<_T2s...>, _Rem...>
    {
      typedef typename __combine_tuples<tuple<_T1s..., _T2s...>,
     _Rem...>::__type __type;
    };


  template<typename... _Tpls>
    struct __tuple_cat_result
    {
      typedef typename __combine_tuples
        <typename __make_tuple<_Tpls>::__type...>::__type __type;
    };



  template<typename...>
    struct __make_1st_indices;

  template<>
    struct __make_1st_indices<>
    {
      typedef _Index_tuple<> __type;
    };

  template<typename _Tp, typename... _Tpls>
    struct __make_1st_indices<_Tp, _Tpls...>
    {
      typedef typename _Build_index_tuple<tuple_size<
 typename remove_reference<_Tp>::type>::value>::__type __type;
    };




  template<typename _Ret, typename _Indices, typename... _Tpls>
    struct __tuple_concater;

  template<typename _Ret, size_t... _Is, typename _Tp, typename... _Tpls>
    struct __tuple_concater<_Ret, _Index_tuple<_Is...>, _Tp, _Tpls...>
    {
      template<typename... _Us>
        static constexpr _Ret
        _S_do(_Tp&& __tp, _Tpls&&... __tps, _Us&&... __us)
        {
   typedef typename __make_1st_indices<_Tpls...>::__type __idx;
   typedef __tuple_concater<_Ret, __idx, _Tpls...> __next;
   return __next::_S_do(std::forward<_Tpls>(__tps)...,
          std::forward<_Us>(__us)...,
          std::get<_Is>(std::forward<_Tp>(__tp))...);
 }
    };

  template<typename _Ret>
    struct __tuple_concater<_Ret, _Index_tuple<>>
    {
      template<typename... _Us>
 static constexpr _Ret
 _S_do(_Us&&... __us)
        {
   return _Ret(std::forward<_Us>(__us)...);
 }
    };

  template<typename... _Tps>
    struct __is_tuple_like_impl<tuple<_Tps...>> : true_type
    { };




  template<__tuple_like... _Tpls>




    constexpr auto
    tuple_cat(_Tpls&&... __tpls)
    -> typename __tuple_cat_result<_Tpls...>::__type
    {
      typedef typename __tuple_cat_result<_Tpls...>::__type __ret;
      typedef typename __make_1st_indices<_Tpls...>::__type __idx;
      typedef __tuple_concater<__ret, __idx, _Tpls...> __concater;
      return __concater::_S_do(std::forward<_Tpls>(__tpls)...);
    }




  template<typename... _Elements>
    constexpr tuple<_Elements&...>
    tie(_Elements&... __args) noexcept
    { return tuple<_Elements&...>(__args...); }


  template<typename... _Elements>
    constexpr
    inline


    typename enable_if<__and_<__is_swappable<_Elements>...>::value
      >::type



    swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y)
    noexcept(noexcept(__x.swap(__y)))
    { __x.swap(__y); }


  template<typename... _Elements>
    requires (is_swappable_v<const _Elements> && ...)
    constexpr void
    swap(const tuple<_Elements...>& __x, const tuple<_Elements...>& __y)
    noexcept(noexcept(__x.swap(__y)))
    { __x.swap(__y); }




  template<typename... _Elements>
    constexpr
    typename enable_if<!__and_<__is_swappable<_Elements>...>::value>::type
    swap(tuple<_Elements...>&, tuple<_Elements...>&) = delete;






  struct _Swallow_assign
  {
    template<class _Tp>
      constexpr const _Swallow_assign&
      operator=(const _Tp&) const
      { return *this; }
  };
# 2853 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tuple" 3
  inline constexpr _Swallow_assign ignore{};


  template<typename... _Types, typename _Alloc>
    struct uses_allocator<tuple<_Types...>, _Alloc> : true_type { };
# 2868 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tuple" 3
  template<class _T1, class _T2>
    template<typename... _Args1, typename... _Args2>
      constexpr
      inline
      pair<_T1, _T2>::
      pair(piecewise_construct_t,
    tuple<_Args1...> __first, tuple<_Args2...> __second)
      : pair(__first, __second,
      typename _Build_index_tuple<sizeof...(_Args1)>::__type(),
      typename _Build_index_tuple<sizeof...(_Args2)>::__type())
      { }

  template<class _T1, class _T2>
    template<typename... _Args1, size_t... _Indexes1,
      typename... _Args2, size_t... _Indexes2>
      constexpr inline
      pair<_T1, _T2>::
      pair(tuple<_Args1...>& __tuple1, tuple<_Args2...>& __tuple2,
    _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>)
      : first(std::forward<_Args1>(std::get<_Indexes1>(__tuple1))...),
 second(std::forward<_Args2>(std::get<_Indexes2>(__tuple2))...)
      { }






  template<template<typename...> class _Trait, typename _Tp, typename _Tuple>
    inline constexpr bool __unpack_std_tuple = false;

  template<template<typename...> class _Trait, typename _Tp, typename... _Up>
    inline constexpr bool __unpack_std_tuple<_Trait, _Tp, tuple<_Up...>>
      = _Trait<_Tp, _Up...>::value;

  template<template<typename...> class _Trait, typename _Tp, typename... _Up>
    inline constexpr bool __unpack_std_tuple<_Trait, _Tp, tuple<_Up...>&>
      = _Trait<_Tp, _Up&...>::value;

  template<template<typename...> class _Trait, typename _Tp, typename... _Up>
    inline constexpr bool __unpack_std_tuple<_Trait, _Tp, const tuple<_Up...>>
      = _Trait<_Tp, const _Up...>::value;

  template<template<typename...> class _Trait, typename _Tp, typename... _Up>
    inline constexpr bool __unpack_std_tuple<_Trait, _Tp, const tuple<_Up...>&>
      = _Trait<_Tp, const _Up&...>::value;



  template <typename _Fn, typename _Tuple, size_t... _Idx>
    constexpr decltype(auto)
    __apply_impl(_Fn&& __f, _Tuple&& __t, index_sequence<_Idx...>)
    {
      return std::__invoke(std::forward<_Fn>(__f),
      std::get<_Idx>(std::forward<_Tuple>(__t))...);
    }


  template <typename _Fn, __tuple_like _Tuple>



    constexpr decltype(auto)
    apply(_Fn&& __f, _Tuple&& __t)
    noexcept(__unpack_std_tuple<is_nothrow_invocable, _Fn, _Tuple>)
    {
      using _Indices
 = make_index_sequence<tuple_size_v<remove_reference_t<_Tuple>>>;
      return std::__apply_impl(std::forward<_Fn>(__f),
          std::forward<_Tuple>(__t),
          _Indices{});
    }



  template <typename _Tp, typename _Tuple, size_t... _Idx>
    constexpr _Tp
    __make_from_tuple_impl(_Tuple&& __t, index_sequence<_Idx...>)
    { return _Tp(std::get<_Idx>(std::forward<_Tuple>(__t))...); }


  template <typename _Tp, __tuple_like _Tuple>



    constexpr _Tp
    make_from_tuple(_Tuple&& __t)
    noexcept(__unpack_std_tuple<is_nothrow_constructible, _Tp, _Tuple>)
    {
      constexpr size_t __n = tuple_size_v<remove_reference_t<_Tuple>>;

      if constexpr (__n == 1)
 {
   using _Elt = decltype(std::get<0>(std::declval<_Tuple>()));
   static_assert(!__reference_constructs_from_temporary(_Tp, _Elt));
 }

      return __make_from_tuple_impl<_Tp>(std::forward<_Tuple>(__t),
      make_index_sequence<__n>{});
    }



  template<__tuple_like _TTuple, __tuple_like _UTuple,
    template<typename> class _TQual, template<typename> class _UQual,
    typename = make_index_sequence<tuple_size_v<_TTuple>>>
  struct __tuple_like_common_reference;

  template<__tuple_like _TTuple, __tuple_like _UTuple,
    template<typename> class _TQual, template<typename> class _UQual,
    size_t... _Is>
    requires requires
      { typename tuple<common_reference_t<_TQual<tuple_element_t<_Is, _TTuple>>,
       _UQual<tuple_element_t<_Is, _UTuple>>>...>; }
  struct __tuple_like_common_reference<_TTuple, _UTuple, _TQual, _UQual, index_sequence<_Is...>>
  {
    using type = tuple<common_reference_t<_TQual<tuple_element_t<_Is, _TTuple>>,
       _UQual<tuple_element_t<_Is, _UTuple>>>...>;
  };

  template<__tuple_like _TTuple, __tuple_like _UTuple,
    template<typename> class _TQual, template<typename> class _UQual>
    requires (__is_tuple_v<_TTuple> || __is_tuple_v<_UTuple>)
      && is_same_v<_TTuple, decay_t<_TTuple>>
      && is_same_v<_UTuple, decay_t<_UTuple>>
      && (tuple_size_v<_TTuple> == tuple_size_v<_UTuple>)
      && requires { typename __tuple_like_common_reference<_TTuple, _UTuple, _TQual, _UQual>::type; }
  struct basic_common_reference<_TTuple, _UTuple, _TQual, _UQual>
  {
    using type = typename __tuple_like_common_reference<_TTuple, _UTuple, _TQual, _UQual>::type;
  };

  template<__tuple_like _TTuple, __tuple_like _UTuple,
    typename = make_index_sequence<tuple_size_v<_TTuple>>>
  struct __tuple_like_common_type;

  template<__tuple_like _TTuple, __tuple_like _UTuple, size_t... _Is>
    requires requires
      { typename tuple<common_type_t<tuple_element_t<_Is, _TTuple>,
       tuple_element_t<_Is, _UTuple>>...>; }
  struct __tuple_like_common_type<_TTuple, _UTuple, index_sequence<_Is...>>
  {
    using type = tuple<common_type_t<tuple_element_t<_Is, _TTuple>,
         tuple_element_t<_Is, _UTuple>>...>;
  };

  template<__tuple_like _TTuple, __tuple_like _UTuple>
    requires (__is_tuple_v<_TTuple> || __is_tuple_v<_UTuple>)
      && is_same_v<_TTuple, decay_t<_TTuple>>
      && is_same_v<_UTuple, decay_t<_UTuple>>
      && (tuple_size_v<_TTuple> == tuple_size_v<_UTuple>)
      && requires { typename __tuple_like_common_type<_TTuple, _UTuple>::type; }
  struct common_type<_TTuple, _UTuple>
  {
    using type = typename __tuple_like_common_type<_TTuple, _UTuple>::type;
  };







}
# 35 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/hashtable_policy.h" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/functional_hash.h" 1 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/functional_hash.h" 3


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/hash_bytes.h" 1 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/functional_hash.h" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{
# 50 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/functional_hash.h" 3
  template<typename _Result, typename _Arg>
    struct __hash_base
    {
      typedef _Result result_type [[__deprecated__]];
      typedef _Arg argument_type [[__deprecated__]];
    };


  template<typename _Tp>
    struct hash;

  template<typename _Tp, typename = void>
    struct __poison_hash
    {
      static constexpr bool __enable_hash_call = false;
    private:

      __poison_hash(__poison_hash&&);
      ~__poison_hash();
    };

  template<typename _Tp>
    struct __poison_hash<_Tp, __void_t<decltype(hash<_Tp>()(declval<_Tp>()))>>
    {
      static constexpr bool __enable_hash_call = true;
    };


  template<typename _Tp, bool = is_enum<_Tp>::value>
    struct __hash_enum
    {
    private:

      __hash_enum(__hash_enum&&);
      ~__hash_enum();
    };


  template<typename _Tp>
    struct __hash_enum<_Tp, true> : public __hash_base<size_t, _Tp>
    {
      size_t
      operator()(_Tp __val) const noexcept
      {
       using __type = typename underlying_type<_Tp>::type;
       return hash<__type>{}(static_cast<__type>(__val));
      }
    };



  template<typename _Tp>
    struct hash : __hash_enum<_Tp>
    { };


  template<typename _Tp>
    struct hash<_Tp*> : public __hash_base<size_t, _Tp*>
    {
      size_t
      operator()(_Tp* __p) const noexcept
      { return reinterpret_cast<size_t>(__p); }
    };
# 125 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/functional_hash.h" 3
  template<> struct hash<bool> : public __hash_base<size_t, bool> { size_t operator()(bool __val) const noexcept { return static_cast<size_t>(__val); } };


  template<> struct hash<char> : public __hash_base<size_t, char> { size_t operator()(char __val) const noexcept { return static_cast<size_t>(__val); } };


  template<> struct hash<signed char> : public __hash_base<size_t, signed char> { size_t operator()(signed char __val) const noexcept { return static_cast<size_t>(__val); } };


  template<> struct hash<unsigned char> : public __hash_base<size_t, unsigned char> { size_t operator()(unsigned char __val) const noexcept { return static_cast<size_t>(__val); } };


  template<> struct hash<wchar_t> : public __hash_base<size_t, wchar_t> { size_t operator()(wchar_t __val) const noexcept { return static_cast<size_t>(__val); } };



  template<> struct hash<char8_t> : public __hash_base<size_t, char8_t> { size_t operator()(char8_t __val) const noexcept { return static_cast<size_t>(__val); } };



  template<> struct hash<char16_t> : public __hash_base<size_t, char16_t> { size_t operator()(char16_t __val) const noexcept { return static_cast<size_t>(__val); } };


  template<> struct hash<char32_t> : public __hash_base<size_t, char32_t> { size_t operator()(char32_t __val) const noexcept { return static_cast<size_t>(__val); } };


  template<> struct hash<short> : public __hash_base<size_t, short> { size_t operator()(short __val) const noexcept { return static_cast<size_t>(__val); } };


  template<> struct hash<int> : public __hash_base<size_t, int> { size_t operator()(int __val) const noexcept { return static_cast<size_t>(__val); } };


  template<> struct hash<long> : public __hash_base<size_t, long> { size_t operator()(long __val) const noexcept { return static_cast<size_t>(__val); } };


  template<> struct hash<long long> : public __hash_base<size_t, long long> { size_t operator()(long long __val) const noexcept { return static_cast<size_t>(__val); } };


  template<> struct hash<unsigned short> : public __hash_base<size_t, unsigned short> { size_t operator()(unsigned short __val) const noexcept { return static_cast<size_t>(__val); } };


  template<> struct hash<unsigned int> : public __hash_base<size_t, unsigned int> { size_t operator()(unsigned int __val) const noexcept { return static_cast<size_t>(__val); } };


  template<> struct hash<unsigned long> : public __hash_base<size_t, unsigned long> { size_t operator()(unsigned long __val) const noexcept { return static_cast<size_t>(__val); } };


  template<> struct hash<unsigned long long> : public __hash_base<size_t, unsigned long long> { size_t operator()(unsigned long long __val) const noexcept { return static_cast<size_t>(__val); } };


  __extension__
  template<> struct hash<__int128> : public __hash_base<size_t, __int128> { size_t operator()(__int128 __val) const noexcept { return static_cast<size_t>(__val); } };
  __extension__
  template<> struct hash<__int128 unsigned> : public __hash_base<size_t, __int128 unsigned> { size_t operator()(__int128 unsigned __val) const noexcept { return static_cast<size_t>(__val); } };
# 201 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/functional_hash.h" 3
  struct _Hash_impl
  {
    static size_t
    hash(const void* __ptr, size_t __clength,
  size_t __seed = static_cast<size_t>(0xc70f6907UL))
    { return _Hash_bytes(__ptr, __clength, __seed); }

    template<typename _Tp>
      static size_t
      hash(const _Tp& __val)
      { return hash(&__val, sizeof(__val)); }

    template<typename _Tp>
      static size_t
      __hash_combine(const _Tp& __val, size_t __hash)
      { return hash(&__val, sizeof(__val), __hash); }
  };


  struct _Fnv_hash_impl
  {
    static size_t
    hash(const void* __ptr, size_t __clength,
  size_t __seed = static_cast<size_t>(2166136261UL))
    { return _Fnv_hash_bytes(__ptr, __clength, __seed); }

    template<typename _Tp>
      static size_t
      hash(const _Tp& __val)
      { return hash(&__val, sizeof(__val)); }

    template<typename _Tp>
      static size_t
      __hash_combine(const _Tp& __val, size_t __hash)
      { return hash(&__val, sizeof(__val), __hash); }
  };


  template<>
    struct hash<float> : public __hash_base<size_t, float>
    {
      size_t
      operator()(float __val) const noexcept
      {

 return __val != 0.0f ? std::_Hash_impl::hash(__val) : 0;
      }
    };


  template<>
    struct hash<double> : public __hash_base<size_t, double>
    {
      size_t
      operator()(double __val) const noexcept
      {

 return __val != 0.0 ? std::_Hash_impl::hash(__val) : 0;
      }
    };


  template<>
    struct hash<long double>
    : public __hash_base<size_t, long double>
    {
      __attribute__ ((__pure__)) size_t
      operator()(long double __val) const noexcept;
    };


  template<>
    struct hash<nullptr_t> : public __hash_base<size_t, nullptr_t>
    {
      size_t
      operator()(nullptr_t) const noexcept
      { return 0; }
    };
# 294 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/functional_hash.h" 3
  template<typename _Hash>
    struct __is_fast_hash : public std::true_type
    { };

  template<>
    struct __is_fast_hash<hash<long double>> : public std::false_type
    { };


}
# 36 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/hashtable_policy.h" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algobase.h" 1 3
# 60 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algobase.h" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/functexcept.h" 1 3
# 42 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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_array_new_length(void) __attribute__((__noreturn__));


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

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


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

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

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

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

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

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

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

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

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

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


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

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


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


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


  void
  __throw_bad_function_call() __attribute__((__noreturn__,__cold__));
# 141 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/functexcept.h" 3
}
# 61 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algobase.h" 2 3








# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/debug/debug.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/debug/debug.h" 3
namespace std
{
  namespace __debug { }
}




namespace __gnu_debug
{
  using namespace std::__debug;

  template<typename _Ite, typename _Seq, typename _Cat>
    struct _Safe_iterator;
}
# 70 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algobase.h" 2 3

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/predefined_ops.h" 1 3
# 35 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/predefined_ops.h" 3
namespace __gnu_cxx
{
namespace __ops
{
  struct _Iter_less_iter
  {
    template<typename _Iterator1, typename _Iterator2>
      constexpr
      bool
      operator()(_Iterator1 __it1, _Iterator2 __it2) const
      { return *__it1 < *__it2; }
  };

  constexpr
  inline _Iter_less_iter
  __iter_less_iter()
  { return _Iter_less_iter(); }

  struct _Iter_less_val
  {

    constexpr _Iter_less_val() = default;




    constexpr
    explicit
    _Iter_less_val(_Iter_less_iter) { }

    template<typename _Iterator, typename _Value>
      constexpr
      bool
      operator()(_Iterator __it, _Value& __val) const
      { return *__it < __val; }
  };

  constexpr
  inline _Iter_less_val
  __iter_less_val()
  { return _Iter_less_val(); }

  constexpr
  inline _Iter_less_val
  __iter_comp_val(_Iter_less_iter)
  { return _Iter_less_val(); }

  struct _Val_less_iter
  {

    constexpr _Val_less_iter() = default;




    constexpr
    explicit
    _Val_less_iter(_Iter_less_iter) { }

    template<typename _Value, typename _Iterator>
      constexpr
      bool
      operator()(_Value& __val, _Iterator __it) const
      { return __val < *__it; }
  };

  constexpr
  inline _Val_less_iter
  __val_less_iter()
  { return _Val_less_iter(); }

  constexpr
  inline _Val_less_iter
  __val_comp_iter(_Iter_less_iter)
  { return _Val_less_iter(); }

  struct _Iter_equal_to_iter
  {
    template<typename _Iterator1, typename _Iterator2>
      constexpr
      bool
      operator()(_Iterator1 __it1, _Iterator2 __it2) const
      { return *__it1 == *__it2; }
  };

  constexpr
  inline _Iter_equal_to_iter
  __iter_equal_to_iter()
  { return _Iter_equal_to_iter(); }

  struct _Iter_equal_to_val
  {
    template<typename _Iterator, typename _Value>
      constexpr
      bool
      operator()(_Iterator __it, _Value& __val) const
      { return *__it == __val; }
  };

  constexpr
  inline _Iter_equal_to_val
  __iter_equal_to_val()
  { return _Iter_equal_to_val(); }

  constexpr
  inline _Iter_equal_to_val
  __iter_comp_val(_Iter_equal_to_iter)
  { return _Iter_equal_to_val(); }

  template<typename _Compare>
    struct _Iter_comp_iter
    {
      _Compare _M_comp;

      explicit constexpr
      _Iter_comp_iter(_Compare __comp)
 : _M_comp(std::move(__comp))
      { }

      template<typename _Iterator1, typename _Iterator2>
        constexpr
        bool
        operator()(_Iterator1 __it1, _Iterator2 __it2)
        { return bool(_M_comp(*__it1, *__it2)); }
    };

  template<typename _Compare>
    constexpr
    inline _Iter_comp_iter<_Compare>
    __iter_comp_iter(_Compare __comp)
    { return _Iter_comp_iter<_Compare>(std::move(__comp)); }

  template<typename _Compare>
    struct _Iter_comp_val
    {
      _Compare _M_comp;

      constexpr
      explicit
      _Iter_comp_val(_Compare __comp)
 : _M_comp(std::move(__comp))
      { }

      constexpr
      explicit
      _Iter_comp_val(const _Iter_comp_iter<_Compare>& __comp)
 : _M_comp(__comp._M_comp)
      { }


      constexpr
      explicit
      _Iter_comp_val(_Iter_comp_iter<_Compare>&& __comp)
 : _M_comp(std::move(__comp._M_comp))
      { }


      template<typename _Iterator, typename _Value>
 constexpr
 bool
 operator()(_Iterator __it, _Value& __val)
 { return bool(_M_comp(*__it, __val)); }
    };

  template<typename _Compare>
    constexpr
    inline _Iter_comp_val<_Compare>
    __iter_comp_val(_Compare __comp)
    { return _Iter_comp_val<_Compare>(std::move(__comp)); }

  template<typename _Compare>
    constexpr
    inline _Iter_comp_val<_Compare>
    __iter_comp_val(_Iter_comp_iter<_Compare> __comp)
    { return _Iter_comp_val<_Compare>(std::move(__comp)); }

  template<typename _Compare>
    struct _Val_comp_iter
    {
      _Compare _M_comp;

      constexpr
      explicit
      _Val_comp_iter(_Compare __comp)
 : _M_comp(std::move(__comp))
      { }

      constexpr
      explicit
      _Val_comp_iter(const _Iter_comp_iter<_Compare>& __comp)
 : _M_comp(__comp._M_comp)
      { }


      constexpr
      explicit
      _Val_comp_iter(_Iter_comp_iter<_Compare>&& __comp)
 : _M_comp(std::move(__comp._M_comp))
      { }


      template<typename _Value, typename _Iterator>
 constexpr
 bool
 operator()(_Value& __val, _Iterator __it)
 { return bool(_M_comp(__val, *__it)); }
    };

  template<typename _Compare>
    constexpr
    inline _Val_comp_iter<_Compare>
    __val_comp_iter(_Compare __comp)
    { return _Val_comp_iter<_Compare>(std::move(__comp)); }

  template<typename _Compare>
    constexpr
    inline _Val_comp_iter<_Compare>
    __val_comp_iter(_Iter_comp_iter<_Compare> __comp)
    { return _Val_comp_iter<_Compare>(std::move(__comp)); }

  template<typename _Value>
    struct _Iter_equals_val
    {
      _Value& _M_value;

      constexpr
      explicit
      _Iter_equals_val(_Value& __value)
 : _M_value(__value)
      { }

      template<typename _Iterator>
 constexpr
 bool
 operator()(_Iterator __it)
 { return *__it == _M_value; }
    };

  template<typename _Value>
    constexpr
    inline _Iter_equals_val<_Value>
    __iter_equals_val(_Value& __val)
    { return _Iter_equals_val<_Value>(__val); }

  template<typename _Iterator1>
    struct _Iter_equals_iter
    {
      _Iterator1 _M_it1;

      constexpr
      explicit
      _Iter_equals_iter(_Iterator1 __it1)
 : _M_it1(__it1)
      { }

      template<typename _Iterator2>
 constexpr
 bool
 operator()(_Iterator2 __it2)
 { return *__it2 == *_M_it1; }
    };

  template<typename _Iterator>
    constexpr
    inline _Iter_equals_iter<_Iterator>
    __iter_comp_iter(_Iter_equal_to_iter, _Iterator __it)
    { return _Iter_equals_iter<_Iterator>(__it); }

  template<typename _Predicate>
    struct _Iter_pred
    {
      _Predicate _M_pred;

      constexpr
      explicit
      _Iter_pred(_Predicate __pred)
 : _M_pred(std::move(__pred))
      { }

      template<typename _Iterator>
 constexpr
 bool
 operator()(_Iterator __it)
 { return bool(_M_pred(*__it)); }
    };

  template<typename _Predicate>
    constexpr
    inline _Iter_pred<_Predicate>
    __pred_iter(_Predicate __pred)
    { return _Iter_pred<_Predicate>(std::move(__pred)); }

  template<typename _Compare, typename _Value>
    struct _Iter_comp_to_val
    {
      _Compare _M_comp;
      _Value& _M_value;

      constexpr
      _Iter_comp_to_val(_Compare __comp, _Value& __value)
 : _M_comp(std::move(__comp)), _M_value(__value)
      { }

      template<typename _Iterator>
 constexpr
 bool
 operator()(_Iterator __it)
 { return bool(_M_comp(*__it, _M_value)); }
    };

  template<typename _Compare, typename _Value>
    _Iter_comp_to_val<_Compare, _Value>
    constexpr
    __iter_comp_val(_Compare __comp, _Value &__val)
    {
      return _Iter_comp_to_val<_Compare, _Value>(std::move(__comp), __val);
    }

  template<typename _Compare, typename _Iterator1>
    struct _Iter_comp_to_iter
    {
      _Compare _M_comp;
      _Iterator1 _M_it1;

      constexpr
      _Iter_comp_to_iter(_Compare __comp, _Iterator1 __it1)
 : _M_comp(std::move(__comp)), _M_it1(__it1)
      { }

      template<typename _Iterator2>
 constexpr
 bool
 operator()(_Iterator2 __it2)
 { return bool(_M_comp(*__it2, *_M_it1)); }
    };

  template<typename _Compare, typename _Iterator>
    constexpr
    inline _Iter_comp_to_iter<_Compare, _Iterator>
    __iter_comp_iter(_Iter_comp_iter<_Compare> __comp, _Iterator __it)
    {
      return _Iter_comp_to_iter<_Compare, _Iterator>(
   std::move(__comp._M_comp), __it);
    }

  template<typename _Predicate>
    struct _Iter_negate
    {
      _Predicate _M_pred;

      constexpr
      explicit
      _Iter_negate(_Predicate __pred)
 : _M_pred(std::move(__pred))
      { }

      template<typename _Iterator>
 constexpr
 bool
 operator()(_Iterator __it)
 { return !bool(_M_pred(*__it)); }
    };

  template<typename _Predicate>
    constexpr
    inline _Iter_negate<_Predicate>
    __negate(_Iter_pred<_Predicate> __pred)
    { return _Iter_negate<_Predicate>(std::move(__pred._M_pred)); }

}
}
# 72 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algobase.h" 2 3




# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bit" 1 3
# 33 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bit" 3
# 61 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bit" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 62 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bit" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{
# 85 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bit" 3
  template<typename _To, typename _From>
    [[nodiscard]]
    constexpr _To
    bit_cast(const _From& __from) noexcept

    requires (sizeof(_To) == sizeof(_From))
      && is_trivially_copyable_v<_To> && is_trivially_copyable_v<_From>

    {
      return __builtin_bit_cast(_To, __from);
    }
# 107 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bit" 3
  template<integral _Tp>
    [[nodiscard]]
    constexpr _Tp
    byteswap(_Tp __value) noexcept
    {
      if constexpr (sizeof(_Tp) == 1)
 return __value;

      if !consteval
 {
   if constexpr (sizeof(_Tp) == 2)
     return __builtin_bswap16(__value);
   if constexpr (sizeof(_Tp) == 4)
     return __builtin_bswap32(__value);
   if constexpr (sizeof(_Tp) == 8)
     return __builtin_bswap64(__value);
   if constexpr (sizeof(_Tp) == 16)



     return (__builtin_bswap64(__value >> 64)
      | (static_cast<_Tp>(__builtin_bswap64(__value)) << 64));

 }



      using _Up = typename __make_unsigned<__remove_cv_t<_Tp>>::__type;
      size_t __diff = 8 * (sizeof(_Tp) - 1);
      _Up __mask1 = static_cast<unsigned char>(~0);
      _Up __mask2 = __mask1 << __diff;
      _Up __val = __value;
      for (size_t __i = 0; __i < sizeof(_Tp) / 2; ++__i)
 {
   _Up __byte1 = __val & __mask1;
   _Up __byte2 = __val & __mask2;
   __val = (__val ^ __byte1 ^ __byte2
     ^ (__byte1 << __diff) ^ (__byte2 >> __diff));
   __mask1 <<= 8;
   __mask2 >>= 8;
   __diff -= 2 * 8;
 }
      return __val;
    }




  template<typename _Tp>
    constexpr _Tp
    __rotl(_Tp __x, int __s) noexcept
    {
      constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits;
      if constexpr ((_Nd & (_Nd - 1)) == 0)
 {


   constexpr unsigned __uNd = _Nd;
   const unsigned __r = __s;
   return (__x << (__r % __uNd)) | (__x >> ((-__r) % __uNd));
 }
      const int __r = __s % _Nd;
      if (__r == 0)
 return __x;
      else if (__r > 0)
 return (__x << __r) | (__x >> ((_Nd - __r) % _Nd));
      else
 return (__x >> -__r) | (__x << ((_Nd + __r) % _Nd));
    }

  template<typename _Tp>
    constexpr _Tp
    __rotr(_Tp __x, int __s) noexcept
    {
      constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits;
      if constexpr ((_Nd & (_Nd - 1)) == 0)
 {


   constexpr unsigned __uNd = _Nd;
   const unsigned __r = __s;
   return (__x >> (__r % __uNd)) | (__x << ((-__r) % __uNd));
 }
      const int __r = __s % _Nd;
      if (__r == 0)
 return __x;
      else if (__r > 0)
 return (__x >> __r) | (__x << ((_Nd - __r) % _Nd));
      else
 return (__x << -__r) | (__x >> ((_Nd + __r) % _Nd));
    }

  template<typename _Tp>
    constexpr int
    __countl_zero(_Tp __x) noexcept
    {
      using __gnu_cxx::__int_traits;
      constexpr auto _Nd = __int_traits<_Tp>::__digits;

      if (__x == 0)
        return _Nd;

      constexpr auto _Nd_ull = __int_traits<unsigned long long>::__digits;
      constexpr auto _Nd_ul = __int_traits<unsigned long>::__digits;
      constexpr auto _Nd_u = __int_traits<unsigned>::__digits;

      if constexpr (_Nd <= _Nd_u)
 {
   constexpr int __diff = _Nd_u - _Nd;
   return __builtin_clz(__x) - __diff;
 }
      else if constexpr (_Nd <= _Nd_ul)
 {
   constexpr int __diff = _Nd_ul - _Nd;
   return __builtin_clzl(__x) - __diff;
 }
      else if constexpr (_Nd <= _Nd_ull)
 {
   constexpr int __diff = _Nd_ull - _Nd;
   return __builtin_clzll(__x) - __diff;
 }
      else
 {
   static_assert(_Nd <= (2 * _Nd_ull),
   "Maximum supported integer size is 128-bit");

   unsigned long long __high = __x >> _Nd_ull;
   if (__high != 0)
     {
       constexpr int __diff = (2 * _Nd_ull) - _Nd;
       return __builtin_clzll(__high) - __diff;
     }
   constexpr auto __max_ull = __int_traits<unsigned long long>::__max;
   unsigned long long __low = __x & __max_ull;
   return (_Nd - _Nd_ull) + __builtin_clzll(__low);
 }
    }

  template<typename _Tp>
    constexpr int
    __countl_one(_Tp __x) noexcept
    {
      return std::__countl_zero<_Tp>((_Tp)~__x);
    }

  template<typename _Tp>
    constexpr int
    __countr_zero(_Tp __x) noexcept
    {
      using __gnu_cxx::__int_traits;
      constexpr auto _Nd = __int_traits<_Tp>::__digits;

      if (__x == 0)
        return _Nd;

      constexpr auto _Nd_ull = __int_traits<unsigned long long>::__digits;
      constexpr auto _Nd_ul = __int_traits<unsigned long>::__digits;
      constexpr auto _Nd_u = __int_traits<unsigned>::__digits;

      if constexpr (_Nd <= _Nd_u)
 return __builtin_ctz(__x);
      else if constexpr (_Nd <= _Nd_ul)
 return __builtin_ctzl(__x);
      else if constexpr (_Nd <= _Nd_ull)
 return __builtin_ctzll(__x);
      else
 {
   static_assert(_Nd <= (2 * _Nd_ull),
   "Maximum supported integer size is 128-bit");

   constexpr auto __max_ull = __int_traits<unsigned long long>::__max;
   unsigned long long __low = __x & __max_ull;
   if (__low != 0)
     return __builtin_ctzll(__low);
   unsigned long long __high = __x >> _Nd_ull;
   return __builtin_ctzll(__high) + _Nd_ull;
 }
    }

  template<typename _Tp>
    constexpr int
    __countr_one(_Tp __x) noexcept
    {
      return std::__countr_zero((_Tp)~__x);
    }

  template<typename _Tp>
    constexpr int
    __popcount(_Tp __x) noexcept
    {
      using __gnu_cxx::__int_traits;
      constexpr auto _Nd = __int_traits<_Tp>::__digits;

      constexpr auto _Nd_ull = __int_traits<unsigned long long>::__digits;
      constexpr auto _Nd_ul = __int_traits<unsigned long>::__digits;
      constexpr auto _Nd_u = __int_traits<unsigned>::__digits;

      if constexpr (_Nd <= _Nd_u)
 return __builtin_popcount(__x);
      else if constexpr (_Nd <= _Nd_ul)
 return __builtin_popcountl(__x);
      else if constexpr (_Nd <= _Nd_ull)
 return __builtin_popcountll(__x);
      else
 {
   static_assert(_Nd <= (2 * _Nd_ull),
   "Maximum supported integer size is 128-bit");

   constexpr auto __max_ull = __int_traits<unsigned long long>::__max;
   unsigned long long __low = __x & __max_ull;
   unsigned long long __high = __x >> _Nd_ull;
   return __builtin_popcountll(__low) + __builtin_popcountll(__high);
 }
    }

  template<typename _Tp>
    constexpr bool
    __has_single_bit(_Tp __x) noexcept
    { return std::__popcount(__x) == 1; }

  template<typename _Tp>
    constexpr _Tp
    __bit_ceil(_Tp __x) noexcept
    {
      using __gnu_cxx::__int_traits;
      constexpr auto _Nd = __int_traits<_Tp>::__digits;
      if (__x == 0 || __x == 1)
        return 1;
      auto __shift_exponent = _Nd - std::__countl_zero((_Tp)(__x - 1u));




      if (!std::__is_constant_evaluated())
 {
   do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__shift_exponent != __int_traits<_Tp>::__digits), false)) std::__glibcxx_assert_fail(); } while (false);
 }

      using __promoted_type = decltype(__x << 1);
      if constexpr (!is_same<__promoted_type, _Tp>::value)
 {





   const int __extra_exp = sizeof(__promoted_type) / sizeof(_Tp) / 2;
   __shift_exponent |= (__shift_exponent & _Nd) << __extra_exp;
 }
      return (_Tp)1u << __shift_exponent;
    }

  template<typename _Tp>
    constexpr _Tp
    __bit_floor(_Tp __x) noexcept
    {
      constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits;
      if (__x == 0)
        return 0;
      return (_Tp)1u << (_Nd - std::__countl_zero((_Tp)(__x >> 1)));
    }

  template<typename _Tp>
    constexpr int
    __bit_width(_Tp __x) noexcept
    {
      constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits;
      return _Nd - std::__countl_zero(__x);
    }






  template<typename _Tp>
    concept __unsigned_integer = __is_unsigned_integer<_Tp>::value;





  template<__unsigned_integer _Tp>
    [[nodiscard]] constexpr _Tp
    rotl(_Tp __x, int __s) noexcept
    { return std::__rotl(__x, __s); }


  template<__unsigned_integer _Tp>
    [[nodiscard]] constexpr _Tp
    rotr(_Tp __x, int __s) noexcept
    { return std::__rotr(__x, __s); }




  template<__unsigned_integer _Tp>
    constexpr int
    countl_zero(_Tp __x) noexcept
    { return std::__countl_zero(__x); }


  template<__unsigned_integer _Tp>
    constexpr int
    countl_one(_Tp __x) noexcept
    { return std::__countl_one(__x); }


  template<__unsigned_integer _Tp>
    constexpr int
    countr_zero(_Tp __x) noexcept
    { return std::__countr_zero(__x); }


  template<__unsigned_integer _Tp>
    constexpr int
    countr_one(_Tp __x) noexcept
    { return std::__countr_one(__x); }


  template<__unsigned_integer _Tp>
    constexpr int
    popcount(_Tp __x) noexcept
    { return std::__popcount(__x); }






  template<__unsigned_integer _Tp>
    constexpr bool
    has_single_bit(_Tp __x) noexcept
    { return std::__has_single_bit(__x); }


  template<__unsigned_integer _Tp>
    constexpr _Tp
    bit_ceil(_Tp __x) noexcept
    { return std::__bit_ceil(__x); }


  template<__unsigned_integer _Tp>
    constexpr _Tp
    bit_floor(_Tp __x) noexcept
    { return std::__bit_floor(__x); }




  template<__unsigned_integer _Tp>
    constexpr int
    bit_width(_Tp __x) noexcept
    { return std::__bit_width(__x); }
# 472 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bit" 3
  enum class endian
  {
    little = 1234,
    big = 4321,
    native = 1234
  };





}
# 77 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algobase.h" 2 3





namespace std __attribute__ ((__visibility__ ("default")))
{






  template<typename _Tp, typename _Up>
    constexpr
    inline int
    __memcmp(const _Tp* __first1, const _Up* __first2, size_t __num)
    {

      static_assert(sizeof(_Tp) == sizeof(_Up), "can be compared with memcmp");


      if (std::is_constant_evaluated())
 {
   for(; __num > 0; ++__first1, ++__first2, --__num)
     if (*__first1 != *__first2)
       return *__first1 < *__first2 ? -1 : 1;
   return 0;
 }
      else

 return __builtin_memcmp(__first1, __first2, sizeof(_Tp) * __num);
    }
# 152 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algobase.h" 3
  template<typename _ForwardIterator1, typename _ForwardIterator2>
    constexpr
    inline void
    iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
    {
# 185 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algobase.h" 3
      swap(*__a, *__b);

    }
# 201 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algobase.h" 3
  template<typename _ForwardIterator1, typename _ForwardIterator2>
    constexpr
    _ForwardIterator2
    swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
  _ForwardIterator2 __first2)
    {





                                                       ;

      for (; __first1 != __last1; ++__first1, (void)++__first2)
 std::iter_swap(__first1, __first2);
      return __first2;
    }
# 230 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algobase.h" 3
  template<typename _Tp>
    [[__nodiscard__]] constexpr
    inline const _Tp&
    min(const _Tp& __a, const _Tp& __b)
    {



      if (__b < __a)
 return __b;
      return __a;
    }
# 254 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algobase.h" 3
  template<typename _Tp>
    [[__nodiscard__]] constexpr
    inline const _Tp&
    max(const _Tp& __a, const _Tp& __b)
    {



      if (__a < __b)
 return __b;
      return __a;
    }
# 278 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algobase.h" 3
  template<typename _Tp, typename _Compare>
    [[__nodiscard__]] constexpr
    inline const _Tp&
    min(const _Tp& __a, const _Tp& __b, _Compare __comp)
    {

      if (__comp(__b, __a))
 return __b;
      return __a;
    }
# 300 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algobase.h" 3
  template<typename _Tp, typename _Compare>
    [[__nodiscard__]] constexpr
    inline const _Tp&
    max(const _Tp& __a, const _Tp& __b, _Compare __comp)
    {

      if (__comp(__a, __b))
 return __b;
      return __a;
    }



  template<typename _Iterator>
    constexpr
    inline _Iterator
    __niter_base(_Iterator __it)
    noexcept(std::is_nothrow_copy_constructible<_Iterator>::value)
    { return __it; }
# 332 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algobase.h" 3
  template<typename _Ite, typename _Seq>
    constexpr
    decltype(std::__niter_base(std::declval<_Ite>()))
    __niter_base(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq,
   std::random_access_iterator_tag>&)
    noexcept(std::is_nothrow_copy_constructible<_Ite>::value);





  template<typename _From, typename _To>
    constexpr
    inline _From
    __niter_wrap(_From __from, _To __res)
    { return __from + (std::__niter_base(__res) - std::__niter_base(__from)); }


  template<typename _Iterator>
    constexpr
    inline _Iterator
    __niter_wrap(const _Iterator&, _Iterator __res)
    { return __res; }







  template<bool _IsMove, bool _IsSimple, typename _Category>
    struct __copy_move
    {
      template<typename _II, typename _OI>
 constexpr
 static _OI
 __copy_m(_II __first, _II __last, _OI __result)
 {
   for (; __first != __last; ++__result, (void)++__first)
     *__result = *__first;
   return __result;
 }
    };


  template<typename _Category>
    struct __copy_move<true, false, _Category>
    {
      template<typename _II, typename _OI>
 constexpr
 static _OI
 __copy_m(_II __first, _II __last, _OI __result)
 {
   for (; __first != __last; ++__result, (void)++__first)
     *__result = std::move(*__first);
   return __result;
 }
    };


  template<>
    struct __copy_move<false, false, random_access_iterator_tag>
    {
      template<typename _II, typename _OI>
 constexpr
 static _OI
 __copy_m(_II __first, _II __last, _OI __result)
 {
   typedef typename iterator_traits<_II>::difference_type _Distance;
   for(_Distance __n = __last - __first; __n > 0; --__n)
     {
       *__result = *__first;
       ++__first;
       ++__result;
     }
   return __result;
 }

      template<typename _Tp, typename _Up>
 static void
 __assign_one(_Tp* __to, _Up* __from)
 { *__to = *__from; }
    };


  template<>
    struct __copy_move<true, false, random_access_iterator_tag>
    {
      template<typename _II, typename _OI>
 constexpr
 static _OI
 __copy_m(_II __first, _II __last, _OI __result)
 {
   typedef typename iterator_traits<_II>::difference_type _Distance;
   for(_Distance __n = __last - __first; __n > 0; --__n)
     {
       *__result = std::move(*__first);
       ++__first;
       ++__result;
     }
   return __result;
 }

      template<typename _Tp, typename _Up>
 static void
 __assign_one(_Tp* __to, _Up* __from)
 { *__to = std::move(*__from); }
    };


  template<bool _IsMove>
    struct __copy_move<_IsMove, true, random_access_iterator_tag>
    {
      template<typename _Tp, typename _Up>
 constexpr
 static _Up*
 __copy_m(_Tp* __first, _Tp* __last, _Up* __result)
 {
   const ptrdiff_t _Num = __last - __first;
   if (__builtin_expect(_Num > 1, true))
     __builtin_memmove(__result, __first, sizeof(_Tp) * _Num);
   else if (_Num == 1)
     std::__copy_move<_IsMove, false, random_access_iterator_tag>::
       __assign_one(__result, __first);
   return __result + _Num;
 }
    };



  template<typename _Tp, typename _Ref, typename _Ptr>
    struct _Deque_iterator;

  struct _Bit_iterator;






  template<typename _CharT>
    struct char_traits;

  template<typename _CharT, typename _Traits>
    class istreambuf_iterator;

  template<typename _CharT, typename _Traits>
    class ostreambuf_iterator;

  template<bool _IsMove, typename _CharT>
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
      ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type
    __copy_move_a2(_CharT*, _CharT*,
     ostreambuf_iterator<_CharT, char_traits<_CharT> >);

  template<bool _IsMove, typename _CharT>
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
      ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type
    __copy_move_a2(const _CharT*, const _CharT*,
     ostreambuf_iterator<_CharT, char_traits<_CharT> >);

  template<bool _IsMove, typename _CharT>
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
        _CharT*>::__type
    __copy_move_a2(istreambuf_iterator<_CharT, char_traits<_CharT> >,
     istreambuf_iterator<_CharT, char_traits<_CharT> >, _CharT*);

  template<bool _IsMove, typename _CharT>
    typename __gnu_cxx::__enable_if<
      __is_char<_CharT>::__value,
      std::_Deque_iterator<_CharT, _CharT&, _CharT*> >::__type
    __copy_move_a2(
 istreambuf_iterator<_CharT, char_traits<_CharT> >,
 istreambuf_iterator<_CharT, char_traits<_CharT> >,
 std::_Deque_iterator<_CharT, _CharT&, _CharT*>);


  template<bool _IsMove, typename _II, typename _OI>
    constexpr
    inline _OI
    __copy_move_a2(_II __first, _II __last, _OI __result)
    {
      typedef typename iterator_traits<_II>::iterator_category _Category;

      if (std::is_constant_evaluated())
 return std::__copy_move<_IsMove, false, _Category>::
   __copy_m(__first, __last, __result);

      return std::__copy_move<_IsMove, __memcpyable<_OI, _II>::__value,
         _Category>::__copy_m(__first, __last, __result);
    }

  template<bool _IsMove,
    typename _Tp, typename _Ref, typename _Ptr, typename _OI>
    _OI
    __copy_move_a1(std::_Deque_iterator<_Tp, _Ref, _Ptr>,
     std::_Deque_iterator<_Tp, _Ref, _Ptr>,
     _OI);

  template<bool _IsMove,
    typename _ITp, typename _IRef, typename _IPtr, typename _OTp>
    std::_Deque_iterator<_OTp, _OTp&, _OTp*>
    __copy_move_a1(std::_Deque_iterator<_ITp, _IRef, _IPtr>,
     std::_Deque_iterator<_ITp, _IRef, _IPtr>,
     std::_Deque_iterator<_OTp, _OTp&, _OTp*>);

  template<bool _IsMove, typename _II, typename _Tp>
    typename __gnu_cxx::__enable_if<
      __is_random_access_iter<_II>::__value,
      std::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type
    __copy_move_a1(_II, _II, std::_Deque_iterator<_Tp, _Tp&, _Tp*>);

  template<bool _IsMove, typename _II, typename _OI>
    constexpr
    inline _OI
    __copy_move_a1(_II __first, _II __last, _OI __result)
    { return std::__copy_move_a2<_IsMove>(__first, __last, __result); }

  template<bool _IsMove, typename _II, typename _OI>
    constexpr
    inline _OI
    __copy_move_a(_II __first, _II __last, _OI __result)
    {
      return std::__niter_wrap(__result,
  std::__copy_move_a1<_IsMove>(std::__niter_base(__first),
          std::__niter_base(__last),
          std::__niter_base(__result)));
    }

  template<bool _IsMove,
    typename _Ite, typename _Seq, typename _Cat, typename _OI>
    constexpr
    _OI
    __copy_move_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&,
    const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&,
    _OI);

  template<bool _IsMove,
    typename _II, typename _Ite, typename _Seq, typename _Cat>
    constexpr
    __gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>
    __copy_move_a(_II, _II,
    const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&);

  template<bool _IsMove,
    typename _IIte, typename _ISeq, typename _ICat,
    typename _OIte, typename _OSeq, typename _OCat>
    constexpr
    ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>
    __copy_move_a(const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&,
    const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&,
    const ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>&);

  template<typename _InputIterator, typename _Size, typename _OutputIterator>
    constexpr
    _OutputIterator
    __copy_n_a(_InputIterator __first, _Size __n, _OutputIterator __result,
        bool)
    {
      if (__n > 0)
 {
   while (true)
     {
       *__result = *__first;
       ++__result;
       if (--__n > 0)
  ++__first;
       else
  break;
     }
 }
      return __result;
    }


  template<typename _CharT, typename _Size>
    typename __gnu_cxx::__enable_if<
      __is_char<_CharT>::__value, _CharT*>::__type
    __copy_n_a(istreambuf_iterator<_CharT, char_traits<_CharT> >,
        _Size, _CharT*, bool);

  template<typename _CharT, typename _Size>
    typename __gnu_cxx::__enable_if<
      __is_char<_CharT>::__value,
      std::_Deque_iterator<_CharT, _CharT&, _CharT*> >::__type
    __copy_n_a(istreambuf_iterator<_CharT, char_traits<_CharT> >, _Size,
        std::_Deque_iterator<_CharT, _CharT&, _CharT*>,
        bool);
# 639 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algobase.h" 3
  template<typename _II, typename _OI>
    constexpr
    inline _OI
    copy(_II __first, _II __last, _OI __result)
    {




                                                                       ;

      return std::__copy_move_a<__is_move_iterator<_II>::__value>
      (std::__miter_base(__first), std::__miter_base(__last), __result);
    }
# 672 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algobase.h" 3
  template<typename _II, typename _OI>
    constexpr
    inline _OI
    move(_II __first, _II __last, _OI __result)
    {




                                                                       ;

      return std::__copy_move_a<true>(std::__miter_base(__first),
          std::__miter_base(__last), __result);
    }






  template<bool _IsMove, bool _IsSimple, typename _Category>
    struct __copy_move_backward
    {
      template<typename _BI1, typename _BI2>
 constexpr
 static _BI2
 __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
 {
   while (__first != __last)
     *--__result = *--__last;
   return __result;
 }
    };


  template<typename _Category>
    struct __copy_move_backward<true, false, _Category>
    {
      template<typename _BI1, typename _BI2>
 constexpr
 static _BI2
 __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
 {
   while (__first != __last)
     *--__result = std::move(*--__last);
   return __result;
 }
    };


  template<>
    struct __copy_move_backward<false, false, random_access_iterator_tag>
    {
      template<typename _BI1, typename _BI2>
 constexpr
 static _BI2
 __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
 {
   typename iterator_traits<_BI1>::difference_type
     __n = __last - __first;
   for (; __n > 0; --__n)
     *--__result = *--__last;
   return __result;
 }
    };


  template<>
    struct __copy_move_backward<true, false, random_access_iterator_tag>
    {
      template<typename _BI1, typename _BI2>
 constexpr
 static _BI2
 __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result)
 {
   typename iterator_traits<_BI1>::difference_type
     __n = __last - __first;
   for (; __n > 0; --__n)
     *--__result = std::move(*--__last);
   return __result;
 }
    };


  template<bool _IsMove>
    struct __copy_move_backward<_IsMove, true, random_access_iterator_tag>
    {
      template<typename _Tp, typename _Up>
 constexpr
 static _Up*
 __copy_move_b(_Tp* __first, _Tp* __last, _Up* __result)
 {
   const ptrdiff_t _Num = __last - __first;
   if (__builtin_expect(_Num > 1, true))
     __builtin_memmove(__result - _Num, __first, sizeof(_Tp) * _Num);
   else if (_Num == 1)
     std::__copy_move<_IsMove, false, random_access_iterator_tag>::
       __assign_one(__result - 1, __first);
   return __result - _Num;
 }
    };

  template<bool _IsMove, typename _BI1, typename _BI2>
    constexpr
    inline _BI2
    __copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result)
    {
      typedef typename iterator_traits<_BI1>::iterator_category _Category;

      if (std::is_constant_evaluated())
 return std::__copy_move_backward<_IsMove, false, _Category>::
   __copy_move_b(__first, __last, __result);

      return std::__copy_move_backward<_IsMove,
           __memcpyable<_BI2, _BI1>::__value,
           _Category>::__copy_move_b(__first,
         __last,
         __result);
    }

  template<bool _IsMove, typename _BI1, typename _BI2>
    constexpr
    inline _BI2
    __copy_move_backward_a1(_BI1 __first, _BI1 __last, _BI2 __result)
    { return std::__copy_move_backward_a2<_IsMove>(__first, __last, __result); }

  template<bool _IsMove,
    typename _Tp, typename _Ref, typename _Ptr, typename _OI>
    _OI
    __copy_move_backward_a1(std::_Deque_iterator<_Tp, _Ref, _Ptr>,
       std::_Deque_iterator<_Tp, _Ref, _Ptr>,
       _OI);

  template<bool _IsMove,
    typename _ITp, typename _IRef, typename _IPtr, typename _OTp>
    std::_Deque_iterator<_OTp, _OTp&, _OTp*>
    __copy_move_backward_a1(
   std::_Deque_iterator<_ITp, _IRef, _IPtr>,
   std::_Deque_iterator<_ITp, _IRef, _IPtr>,
   std::_Deque_iterator<_OTp, _OTp&, _OTp*>);

  template<bool _IsMove, typename _II, typename _Tp>
    typename __gnu_cxx::__enable_if<
      __is_random_access_iter<_II>::__value,
      std::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type
    __copy_move_backward_a1(_II, _II,
       std::_Deque_iterator<_Tp, _Tp&, _Tp*>);

  template<bool _IsMove, typename _II, typename _OI>
    constexpr
    inline _OI
    __copy_move_backward_a(_II __first, _II __last, _OI __result)
    {
      return std::__niter_wrap(__result,
  std::__copy_move_backward_a1<_IsMove>
    (std::__niter_base(__first), std::__niter_base(__last),
     std::__niter_base(__result)));
    }

  template<bool _IsMove,
    typename _Ite, typename _Seq, typename _Cat, typename _OI>
    constexpr
    _OI
    __copy_move_backward_a(
  const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&,
  const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&,
  _OI);

  template<bool _IsMove,
    typename _II, typename _Ite, typename _Seq, typename _Cat>
    constexpr
    __gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>
    __copy_move_backward_a(_II, _II,
  const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&);

  template<bool _IsMove,
    typename _IIte, typename _ISeq, typename _ICat,
    typename _OIte, typename _OSeq, typename _OCat>
    constexpr
    ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>
    __copy_move_backward_a(
  const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&,
  const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&,
  const ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>&);
# 875 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algobase.h" 3
  template<typename _BI1, typename _BI2>
    constexpr
    inline _BI2
    copy_backward(_BI1 __first, _BI1 __last, _BI2 __result)
    {





                                                                       ;

      return std::__copy_move_backward_a<__is_move_iterator<_BI1>::__value>
      (std::__miter_base(__first), std::__miter_base(__last), __result);
    }
# 910 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algobase.h" 3
  template<typename _BI1, typename _BI2>
    constexpr
    inline _BI2
    move_backward(_BI1 __first, _BI1 __last, _BI2 __result)
    {





                                                                       ;

      return std::__copy_move_backward_a<true>(std::__miter_base(__first),
            std::__miter_base(__last),
            __result);
    }






  template<typename _ForwardIterator, typename _Tp>
    constexpr
    inline typename
    __gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, void>::__type
    __fill_a1(_ForwardIterator __first, _ForwardIterator __last,
       const _Tp& __value)
    {
      for (; __first != __last; ++__first)
 *__first = __value;
    }

  template<typename _ForwardIterator, typename _Tp>
    constexpr
    inline typename
    __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, void>::__type
    __fill_a1(_ForwardIterator __first, _ForwardIterator __last,
       const _Tp& __value)
    {
      const _Tp __tmp = __value;
      for (; __first != __last; ++__first)
 *__first = __tmp;
    }


  template<typename _Tp>
    constexpr
    inline typename
    __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, void>::__type
    __fill_a1(_Tp* __first, _Tp* __last, const _Tp& __c)
    {
      const _Tp __tmp = __c;

      if (std::is_constant_evaluated())
 {
   for (; __first != __last; ++__first)
     *__first = __tmp;
   return;
 }

      if (const size_t __len = __last - __first)
 __builtin_memset(__first, static_cast<unsigned char>(__tmp), __len);
    }

  template<typename _Ite, typename _Cont, typename _Tp>
    constexpr
    inline void
    __fill_a1(::__gnu_cxx::__normal_iterator<_Ite, _Cont> __first,
       ::__gnu_cxx::__normal_iterator<_Ite, _Cont> __last,
       const _Tp& __value)
    { std::__fill_a1(__first.base(), __last.base(), __value); }

  template<typename _Tp, typename _VTp>
    void
    __fill_a1(const std::_Deque_iterator<_Tp, _Tp&, _Tp*>&,
       const std::_Deque_iterator<_Tp, _Tp&, _Tp*>&,
       const _VTp&);

  constexpr
  void
  __fill_a1(std::_Bit_iterator, std::_Bit_iterator,
     const bool&);

  template<typename _FIte, typename _Tp>
    constexpr
    inline void
    __fill_a(_FIte __first, _FIte __last, const _Tp& __value)
    { std::__fill_a1(__first, __last, __value); }

  template<typename _Ite, typename _Seq, typename _Cat, typename _Tp>
    constexpr
    void
    __fill_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&,
      const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&,
      const _Tp&);
# 1019 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algobase.h" 3
  template<typename _ForwardIterator, typename _Tp>
    constexpr
    inline void
    fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
    {



                                                     ;

      std::__fill_a(__first, __last, __value);
    }


  inline constexpr int
  __size_to_integer(int __n) { return __n; }
  inline constexpr unsigned
  __size_to_integer(unsigned __n) { return __n; }
  inline constexpr long
  __size_to_integer(long __n) { return __n; }
  inline constexpr unsigned long
  __size_to_integer(unsigned long __n) { return __n; }
  inline constexpr long long
  __size_to_integer(long long __n) { return __n; }
  inline constexpr unsigned long long
  __size_to_integer(unsigned long long __n) { return __n; }


  __extension__ inline constexpr __int128
  __size_to_integer(__int128 __n) { return __n; }
  __extension__ inline constexpr unsigned __int128
  __size_to_integer(unsigned __int128 __n) { return __n; }
# 1071 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algobase.h" 3
  inline constexpr long long
  __size_to_integer(float __n) { return (long long)__n; }
  inline constexpr long long
  __size_to_integer(double __n) { return (long long)__n; }
  inline constexpr long long
  __size_to_integer(long double __n) { return (long long)__n; }

  __extension__ inline constexpr long long
  __size_to_integer(__float128 __n) { return (long long)__n; }


  template<typename _OutputIterator, typename _Size, typename _Tp>
    constexpr
    inline typename
    __gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, _OutputIterator>::__type
    __fill_n_a1(_OutputIterator __first, _Size __n, const _Tp& __value)
    {
      for (; __n > 0; --__n, (void) ++__first)
 *__first = __value;
      return __first;
    }

  template<typename _OutputIterator, typename _Size, typename _Tp>
    constexpr
    inline typename
    __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, _OutputIterator>::__type
    __fill_n_a1(_OutputIterator __first, _Size __n, const _Tp& __value)
    {
      const _Tp __tmp = __value;
      for (; __n > 0; --__n, (void) ++__first)
 *__first = __tmp;
      return __first;
    }

  template<typename _Ite, typename _Seq, typename _Cat, typename _Size,
    typename _Tp>
    constexpr
    ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>
    __fill_n_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>& __first,
        _Size __n, const _Tp& __value,
        std::input_iterator_tag);

  template<typename _OutputIterator, typename _Size, typename _Tp>
    constexpr
    inline _OutputIterator
    __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value,
        std::output_iterator_tag)
    {

      static_assert(is_integral<_Size>{}, "fill_n must pass integral size");

      return __fill_n_a1(__first, __n, __value);
    }

  template<typename _OutputIterator, typename _Size, typename _Tp>
    constexpr
    inline _OutputIterator
    __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value,
        std::input_iterator_tag)
    {

      static_assert(is_integral<_Size>{}, "fill_n must pass integral size");

      return __fill_n_a1(__first, __n, __value);
    }

  template<typename _OutputIterator, typename _Size, typename _Tp>
    constexpr
    inline _OutputIterator
    __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value,
        std::random_access_iterator_tag)
    {

      static_assert(is_integral<_Size>{}, "fill_n must pass integral size");

      if (__n <= 0)
 return __first;

                                                    ;

      std::__fill_a(__first, __first + __n, __value);
      return __first + __n;
    }
# 1172 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algobase.h" 3
  template<typename _OI, typename _Size, typename _Tp>
    constexpr
    inline _OI
    fill_n(_OI __first, _Size __n, const _Tp& __value)
    {



      return std::__fill_n_a(__first, std::__size_to_integer(__n), __value,
          std::__iterator_category(__first));
    }

  template<bool _BoolType>
    struct __equal
    {
      template<typename _II1, typename _II2>
 constexpr
 static bool
 equal(_II1 __first1, _II1 __last1, _II2 __first2)
 {
   for (; __first1 != __last1; ++__first1, (void) ++__first2)
     if (!(*__first1 == *__first2))
       return false;
   return true;
 }
    };

  template<>
    struct __equal<true>
    {
      template<typename _Tp>
 constexpr
 static bool
 equal(const _Tp* __first1, const _Tp* __last1, const _Tp* __first2)
 {
   if (const size_t __len = (__last1 - __first1))
     return !std::__memcmp(__first1, __first2, __len);
   return true;
 }
    };

  template<typename _Tp, typename _Ref, typename _Ptr, typename _II>
    typename __gnu_cxx::__enable_if<
      __is_random_access_iter<_II>::__value, bool>::__type
    __equal_aux1(std::_Deque_iterator<_Tp, _Ref, _Ptr>,
   std::_Deque_iterator<_Tp, _Ref, _Ptr>,
   _II);

  template<typename _Tp1, typename _Ref1, typename _Ptr1,
    typename _Tp2, typename _Ref2, typename _Ptr2>
    bool
    __equal_aux1(std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>,
   std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>,
   std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>);

  template<typename _II, typename _Tp, typename _Ref, typename _Ptr>
    typename __gnu_cxx::__enable_if<
      __is_random_access_iter<_II>::__value, bool>::__type
    __equal_aux1(_II, _II,
  std::_Deque_iterator<_Tp, _Ref, _Ptr>);

  template<typename _II1, typename _II2>
    constexpr
    inline bool
    __equal_aux1(_II1 __first1, _II1 __last1, _II2 __first2)
    {
      typedef typename iterator_traits<_II1>::value_type _ValueType1;
      const bool __simple = ((__is_integer<_ValueType1>::__value
         || __is_pointer<_ValueType1>::__value)
        && __memcmpable<_II1, _II2>::__value);
      return std::__equal<__simple>::equal(__first1, __last1, __first2);
    }

  template<typename _II1, typename _II2>
    constexpr
    inline bool
    __equal_aux(_II1 __first1, _II1 __last1, _II2 __first2)
    {
      return std::__equal_aux1(std::__niter_base(__first1),
          std::__niter_base(__last1),
          std::__niter_base(__first2));
    }

  template<typename _II1, typename _Seq1, typename _Cat1, typename _II2>
    constexpr
    bool
    __equal_aux(const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&,
  const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&,
  _II2);

  template<typename _II1, typename _II2, typename _Seq2, typename _Cat2>
    constexpr
    bool
    __equal_aux(_II1, _II1,
  const ::__gnu_debug::_Safe_iterator<_II2, _Seq2, _Cat2>&);

  template<typename _II1, typename _Seq1, typename _Cat1,
    typename _II2, typename _Seq2, typename _Cat2>
    constexpr
    bool
    __equal_aux(const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&,
  const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&,
  const ::__gnu_debug::_Safe_iterator<_II2, _Seq2, _Cat2>&);

  template<typename, typename>
    struct __lc_rai
    {
      template<typename _II1, typename _II2>
 constexpr
 static _II1
 __newlast1(_II1, _II1 __last1, _II2, _II2)
 { return __last1; }

      template<typename _II>
 constexpr
 static bool
 __cnd2(_II __first, _II __last)
 { return __first != __last; }
    };

  template<>
    struct __lc_rai<random_access_iterator_tag, random_access_iterator_tag>
    {
      template<typename _RAI1, typename _RAI2>
 constexpr
 static _RAI1
 __newlast1(_RAI1 __first1, _RAI1 __last1,
     _RAI2 __first2, _RAI2 __last2)
 {
   const typename iterator_traits<_RAI1>::difference_type
     __diff1 = __last1 - __first1;
   const typename iterator_traits<_RAI2>::difference_type
     __diff2 = __last2 - __first2;
   return __diff2 < __diff1 ? __first1 + __diff2 : __last1;
 }

      template<typename _RAI>
 static constexpr bool
 __cnd2(_RAI, _RAI)
 { return true; }
    };

  template<typename _II1, typename _II2, typename _Compare>
    constexpr
    bool
    __lexicographical_compare_impl(_II1 __first1, _II1 __last1,
       _II2 __first2, _II2 __last2,
       _Compare __comp)
    {
      typedef typename iterator_traits<_II1>::iterator_category _Category1;
      typedef typename iterator_traits<_II2>::iterator_category _Category2;
      typedef std::__lc_rai<_Category1, _Category2> __rai_type;

      __last1 = __rai_type::__newlast1(__first1, __last1, __first2, __last2);
      for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2);
    ++__first1, (void)++__first2)
 {
   if (__comp(__first1, __first2))
     return true;
   if (__comp(__first2, __first1))
     return false;
 }
      return __first1 == __last1 && __first2 != __last2;
    }

  template<bool _BoolType>
    struct __lexicographical_compare
    {
      template<typename _II1, typename _II2>
 constexpr
 static bool
 __lc(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)
 {
   using __gnu_cxx::__ops::__iter_less_iter;
   return std::__lexicographical_compare_impl(__first1, __last1,
           __first2, __last2,
           __iter_less_iter());
 }

      template<typename _II1, typename _II2>
 constexpr
 static int
 __3way(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)
 {
   while (__first1 != __last1)
     {
       if (__first2 == __last2)
  return +1;
       if (*__first1 < *__first2)
  return -1;
       if (*__first2 < *__first1)
  return +1;
       ++__first1;
       ++__first2;
     }
   return int(__first2 == __last2) - 1;
 }
    };

  template<>
    struct __lexicographical_compare<true>
    {
      template<typename _Tp, typename _Up>
 constexpr
 static bool
 __lc(const _Tp* __first1, const _Tp* __last1,
      const _Up* __first2, const _Up* __last2)
 { return __3way(__first1, __last1, __first2, __last2) < 0; }

      template<typename _Tp, typename _Up>
 constexpr
 static ptrdiff_t
 __3way(const _Tp* __first1, const _Tp* __last1,
        const _Up* __first2, const _Up* __last2)
 {
   const size_t __len1 = __last1 - __first1;
   const size_t __len2 = __last2 - __first2;
   if (const size_t __len = std::min(__len1, __len2))
     if (int __result = std::__memcmp(__first1, __first2, __len))
       return __result;
   return ptrdiff_t(__len1 - __len2);
 }
    };

  template<typename _II1, typename _II2>
    constexpr
    inline bool
    __lexicographical_compare_aux1(_II1 __first1, _II1 __last1,
       _II2 __first2, _II2 __last2)
    {
      typedef typename iterator_traits<_II1>::value_type _ValueType1;
      typedef typename iterator_traits<_II2>::value_type _ValueType2;
      const bool __simple =
 (__is_memcmp_ordered_with<_ValueType1, _ValueType2>::__value
  && __is_pointer<_II1>::__value
  && __is_pointer<_II2>::__value




  && !is_volatile_v<remove_reference_t<iter_reference_t<_II1>>>
  && !is_volatile_v<remove_reference_t<iter_reference_t<_II2>>>

  );

      return std::__lexicographical_compare<__simple>::__lc(__first1, __last1,
           __first2, __last2);
    }

  template<typename _Tp1, typename _Ref1, typename _Ptr1,
    typename _Tp2>
    bool
    __lexicographical_compare_aux1(
 std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>,
 std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>,
 _Tp2*, _Tp2*);

  template<typename _Tp1,
    typename _Tp2, typename _Ref2, typename _Ptr2>
    bool
    __lexicographical_compare_aux1(_Tp1*, _Tp1*,
 std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>,
 std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>);

  template<typename _Tp1, typename _Ref1, typename _Ptr1,
    typename _Tp2, typename _Ref2, typename _Ptr2>
    bool
    __lexicographical_compare_aux1(
 std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>,
 std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>,
 std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>,
 std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>);

  template<typename _II1, typename _II2>
    constexpr
    inline bool
    __lexicographical_compare_aux(_II1 __first1, _II1 __last1,
      _II2 __first2, _II2 __last2)
    {
      return std::__lexicographical_compare_aux1(std::__niter_base(__first1),
       std::__niter_base(__last1),
       std::__niter_base(__first2),
       std::__niter_base(__last2));
    }

  template<typename _Iter1, typename _Seq1, typename _Cat1,
    typename _II2>
    constexpr
    bool
    __lexicographical_compare_aux(
  const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&,
  const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&,
  _II2, _II2);

  template<typename _II1,
    typename _Iter2, typename _Seq2, typename _Cat2>
    constexpr
    bool
    __lexicographical_compare_aux(
  _II1, _II1,
  const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&,
  const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&);

  template<typename _Iter1, typename _Seq1, typename _Cat1,
    typename _Iter2, typename _Seq2, typename _Cat2>
    constexpr
    bool
    __lexicographical_compare_aux(
  const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&,
  const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&,
  const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&,
  const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&);

  template<typename _ForwardIterator, typename _Tp, typename _Compare>
    constexpr
    _ForwardIterator
    __lower_bound(_ForwardIterator __first, _ForwardIterator __last,
    const _Tp& __val, _Compare __comp)
    {
      typedef typename iterator_traits<_ForwardIterator>::difference_type
 _DistanceType;

      _DistanceType __len = std::distance(__first, __last);

      while (__len > 0)
 {
   _DistanceType __half = __len >> 1;
   _ForwardIterator __middle = __first;
   std::advance(__middle, __half);
   if (__comp(__middle, __val))
     {
       __first = __middle;
       ++__first;
       __len = __len - __half - 1;
     }
   else
     __len = __half;
 }
      return __first;
    }
# 1524 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algobase.h" 3
  template<typename _ForwardIterator, typename _Tp>
    [[__nodiscard__]] constexpr
    inline _ForwardIterator
    lower_bound(_ForwardIterator __first, _ForwardIterator __last,
  const _Tp& __val)
    {




                                                                  ;

      return std::__lower_bound(__first, __last, __val,
    __gnu_cxx::__ops::__iter_less_val());
    }



  template<typename _Tp>
    inline constexpr _Tp
    __lg(_Tp __n)
    {

      return std::__bit_width(make_unsigned_t<_Tp>(__n)) - 1;
# 1557 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algobase.h" 3
    }
# 1573 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algobase.h" 3
  template<typename _II1, typename _II2>
    [[__nodiscard__]] constexpr
    inline bool
    equal(_II1 __first1, _II1 __last1, _II2 __first2)
    {






                                                                         ;

      return std::__equal_aux(__first1, __last1, __first2);
    }
# 1604 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algobase.h" 3
  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
    [[__nodiscard__]] constexpr
    inline bool
    equal(_IIter1 __first1, _IIter1 __last1,
   _IIter2 __first2, _BinaryPredicate __binary_pred)
    {



                                                       ;

      for (; __first1 != __last1; ++__first1, (void)++__first2)
 if (!bool(__binary_pred(*__first1, *__first2)))
   return false;
      return true;
    }



  template<typename _II1, typename _II2>
    constexpr
    inline bool
    __equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)
    {
      using _RATag = random_access_iterator_tag;
      using _Cat1 = typename iterator_traits<_II1>::iterator_category;
      using _Cat2 = typename iterator_traits<_II2>::iterator_category;
      using _RAIters = __and_<is_same<_Cat1, _RATag>, is_same<_Cat2, _RATag>>;
      if (_RAIters())
 {
   auto __d1 = std::distance(__first1, __last1);
   auto __d2 = std::distance(__first2, __last2);
   if (__d1 != __d2)
     return false;
   return std::equal(__first1, __last1, __first2);
 }

      for (; __first1 != __last1 && __first2 != __last2;
   ++__first1, (void)++__first2)
 if (!(*__first1 == *__first2))
   return false;
      return __first1 == __last1 && __first2 == __last2;
    }


  template<typename _II1, typename _II2, typename _BinaryPredicate>
    constexpr
    inline bool
    __equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2,
      _BinaryPredicate __binary_pred)
    {
      using _RATag = random_access_iterator_tag;
      using _Cat1 = typename iterator_traits<_II1>::iterator_category;
      using _Cat2 = typename iterator_traits<_II2>::iterator_category;
      using _RAIters = __and_<is_same<_Cat1, _RATag>, is_same<_Cat2, _RATag>>;
      if (_RAIters())
 {
   auto __d1 = std::distance(__first1, __last1);
   auto __d2 = std::distance(__first2, __last2);
   if (__d1 != __d2)
     return false;
   return std::equal(__first1, __last1, __first2,
           __binary_pred);
 }

      for (; __first1 != __last1 && __first2 != __last2;
   ++__first1, (void)++__first2)
 if (!bool(__binary_pred(*__first1, *__first2)))
   return false;
      return __first1 == __last1 && __first2 == __last2;
    }
# 1691 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algobase.h" 3
  template<typename _II1, typename _II2>
    [[__nodiscard__]] constexpr
    inline bool
    equal(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2)
    {






                                                       ;
                                                       ;

      return std::__equal4(__first1, __last1, __first2, __last2);
    }
# 1724 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algobase.h" 3
  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
    [[__nodiscard__]] constexpr
    inline bool
    equal(_IIter1 __first1, _IIter1 __last1,
   _IIter2 __first2, _IIter2 __last2, _BinaryPredicate __binary_pred)
    {



                                                       ;
                                                       ;

      return std::__equal4(__first1, __last1, __first2, __last2,
          __binary_pred);
    }
# 1756 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algobase.h" 3
  template<typename _II1, typename _II2>
    [[__nodiscard__]] constexpr
    inline bool
    lexicographical_compare(_II1 __first1, _II1 __last1,
       _II2 __first2, _II2 __last2)
    {
# 1771 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algobase.h" 3
                                                       ;
                                                       ;

      return std::__lexicographical_compare_aux(__first1, __last1,
      __first2, __last2);
    }
# 1791 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algobase.h" 3
  template<typename _II1, typename _II2, typename _Compare>
    [[__nodiscard__]] 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<typename _Iter1, typename _Iter2>
    concept __memcmp_ordered_with
      = (__is_memcmp_ordered_with<iter_value_t<_Iter1>,
      iter_value_t<_Iter2>>::__value)
   && contiguous_iterator<_Iter1> && contiguous_iterator<_Iter2>;



  template<typename _Tp>
    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};
    }
# 1845 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algobase.h" 3
  template<typename _InputIter1, typename _InputIter2, typename _Comp>
    [[nodiscard]] 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<common_comparison_category_t<_Cat>, _Cat>);

      if (!std::__is_constant_evaluated())
 if constexpr (same_as<_Comp, __detail::_Synth3way>
        || same_as<_Comp, compare_three_way>)
   if constexpr (__memcmp_ordered_with<_InputIter1, _InputIter2>)
     {
       const auto [__len, __lencmp] = std::
  __min_cmp(__last1 - __first1, __last2 - __first2);
       if (__len)
  {
    const auto __blen = __len * sizeof(*__first1);
    const auto __c
      = __builtin_memcmp(&*__first1, &*__first2, __blen) <=> 0;
    if (__c != 0)
      return __c;
  }
       return __lencmp;
     }

      while (__first1 != __last1)
 {
   if (__first2 == __last2)
     return strong_ordering::greater;
   if (auto __cmp = __comp(*__first1, *__first2); __cmp != 0)
     return __cmp;
   ++__first1;
   ++__first2;
 }
      return (__first2 == __last2) <=> true;
    }

  template<typename _InputIter1, typename _InputIter2>
    constexpr auto
    lexicographical_compare_three_way(_InputIter1 __first1,
          _InputIter1 __last1,
          _InputIter2 __first2,
          _InputIter2 __last2)
    {
      return std::
 lexicographical_compare_three_way(__first1, __last1, __first2, __last2,
       compare_three_way{});
    }


  template<typename _InputIterator1, typename _InputIterator2,
    typename _BinaryPredicate>
    constexpr
    pair<_InputIterator1, _InputIterator2>
    __mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
        _InputIterator2 __first2, _BinaryPredicate __binary_pred)
    {
      while (__first1 != __last1 && __binary_pred(__first1, __first2))
 {
   ++__first1;
   ++__first2;
 }
      return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
    }
# 1934 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algobase.h" 3
  template<typename _InputIterator1, typename _InputIterator2>
    [[__nodiscard__]] constexpr
    inline pair<_InputIterator1, _InputIterator2>
    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
      _InputIterator2 __first2)
    {






                                                       ;

      return std::__mismatch(__first1, __last1, __first2,
        __gnu_cxx::__ops::__iter_equal_to_iter());
    }
# 1968 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algobase.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _BinaryPredicate>
    [[__nodiscard__]] constexpr
    inline pair<_InputIterator1, _InputIterator2>
    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
      _InputIterator2 __first2, _BinaryPredicate __binary_pred)
    {



                                                       ;

      return std::__mismatch(__first1, __last1, __first2,
 __gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
    }


  template<typename _InputIterator1, typename _InputIterator2,
    typename _BinaryPredicate>
    constexpr
    pair<_InputIterator1, _InputIterator2>
    __mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
        _InputIterator2 __first2, _InputIterator2 __last2,
        _BinaryPredicate __binary_pred)
    {
      while (__first1 != __last1 && __first2 != __last2
      && __binary_pred(__first1, __first2))
 {
   ++__first1;
   ++__first2;
 }
      return pair<_InputIterator1, _InputIterator2>(__first1, __first2);
    }
# 2016 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algobase.h" 3
  template<typename _InputIterator1, typename _InputIterator2>
    [[__nodiscard__]] constexpr
    inline pair<_InputIterator1, _InputIterator2>
    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
      _InputIterator2 __first2, _InputIterator2 __last2)
    {






                                                       ;
                                                       ;

      return std::__mismatch(__first1, __last1, __first2, __last2,
        __gnu_cxx::__ops::__iter_equal_to_iter());
    }
# 2052 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algobase.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _BinaryPredicate>
    [[__nodiscard__]] constexpr
    inline pair<_InputIterator1, _InputIterator2>
    mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
      _InputIterator2 __first2, _InputIterator2 __last2,
      _BinaryPredicate __binary_pred)
    {



                                                       ;
                                                       ;

      return std::__mismatch(__first1, __last1, __first2, __last2,
        __gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
    }





  template<typename _InputIterator, typename _Predicate>
    constexpr
    inline _InputIterator
    __find_if(_InputIterator __first, _InputIterator __last,
       _Predicate __pred, input_iterator_tag)
    {
      while (__first != __last && !__pred(__first))
 ++__first;
      return __first;
    }


  template<typename _RandomAccessIterator, typename _Predicate>
    constexpr
    _RandomAccessIterator
    __find_if(_RandomAccessIterator __first, _RandomAccessIterator __last,
       _Predicate __pred, random_access_iterator_tag)
    {
      typename iterator_traits<_RandomAccessIterator>::difference_type
 __trip_count = (__last - __first) >> 2;

      for (; __trip_count > 0; --__trip_count)
 {
   if (__pred(__first))
     return __first;
   ++__first;

   if (__pred(__first))
     return __first;
   ++__first;

   if (__pred(__first))
     return __first;
   ++__first;

   if (__pred(__first))
     return __first;
   ++__first;
 }

      switch (__last - __first)
 {
 case 3:
   if (__pred(__first))
     return __first;
   ++__first;

 case 2:
   if (__pred(__first))
     return __first;
   ++__first;

 case 1:
   if (__pred(__first))
     return __first;
   ++__first;

 case 0:
 default:
   return __last;
 }
    }

  template<typename _Iterator, typename _Predicate>
    constexpr
    inline _Iterator
    __find_if(_Iterator __first, _Iterator __last, _Predicate __pred)
    {
      return __find_if(__first, __last, __pred,
         std::__iterator_category(__first));
    }

  template<typename _InputIterator, typename _Predicate>
    constexpr
    typename iterator_traits<_InputIterator>::difference_type
    __count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
    {
      typename iterator_traits<_InputIterator>::difference_type __n = 0;
      for (; __first != __last; ++__first)
 if (__pred(__first))
   ++__n;
      return __n;
    }

  template<typename _ForwardIterator, typename _Predicate>
    constexpr
    _ForwardIterator
    __remove_if(_ForwardIterator __first, _ForwardIterator __last,
  _Predicate __pred)
    {
      __first = std::__find_if(__first, __last, __pred);
      if (__first == __last)
 return __first;
      _ForwardIterator __result = __first;
      ++__first;
      for (; __first != __last; ++__first)
 if (!__pred(__first))
   {
     *__result = std::move(*__first);
     ++__result;
   }
      return __result;
    }

  template<typename _ForwardIterator1, typename _ForwardIterator2,
    typename _BinaryPredicate>
    constexpr
    _ForwardIterator1
    __search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
      _ForwardIterator2 __first2, _ForwardIterator2 __last2,
      _BinaryPredicate __predicate)
    {

      if (__first1 == __last1 || __first2 == __last2)
 return __first1;


      _ForwardIterator2 __p1(__first2);
      if (++__p1 == __last2)
 return std::__find_if(__first1, __last1,
  __gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2));


      _ForwardIterator1 __current = __first1;

      for (;;)
 {
   __first1 =
     std::__find_if(__first1, __last1,
  __gnu_cxx::__ops::__iter_comp_iter(__predicate, __first2));

   if (__first1 == __last1)
     return __last1;

   _ForwardIterator2 __p = __p1;
   __current = __first1;
   if (++__current == __last1)
     return __last1;

   while (__predicate(__current, __p))
     {
       if (++__p == __last2)
  return __first1;
       if (++__current == __last1)
  return __last1;
     }
   ++__first1;
 }
      return __first1;
    }


  template<typename _ForwardIterator1, typename _ForwardIterator2,
    typename _BinaryPredicate>
    constexpr
    bool
    __is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
       _ForwardIterator2 __first2, _BinaryPredicate __pred)
    {


      for (; __first1 != __last1; ++__first1, (void)++__first2)
 if (!__pred(__first1, __first2))
   break;

      if (__first1 == __last1)
 return true;



      _ForwardIterator2 __last2 = __first2;
      std::advance(__last2, std::distance(__first1, __last1));
      for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan)
 {
   if (__scan != std::__find_if(__first1, __scan,
     __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)))
     continue;

   auto __matches
     = std::__count_if(__first2, __last2,
   __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan));
   if (0 == __matches ||
       std::__count_if(__scan, __last1,
   __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))
       != __matches)
     return false;
 }
      return true;
    }
# 2276 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algobase.h" 3
  template<typename _ForwardIterator1, typename _ForwardIterator2>
    constexpr
    inline bool
    is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
     _ForwardIterator2 __first2)
    {






                                                       ;

      return std::__is_permutation(__first1, __last1, __first2,
       __gnu_cxx::__ops::__iter_equal_to_iter());
    }
# 2318 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algobase.h" 3
  template<typename _ForwardIterator1, typename _ForwardIterator2,
    typename _BinaryPredicate>
    constexpr
    inline _ForwardIterator1
    search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
    _ForwardIterator2 __first2, _ForwardIterator2 __last2,
    _BinaryPredicate __predicate)
    {






                                                       ;
                                                       ;

      return std::__search(__first1, __last1, __first2, __last2,
      __gnu_cxx::__ops::__iter_comp_iter(__predicate));
    }



}
# 37 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/hashtable_policy.h" 2 3

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ext/aligned_buffer.h" 1 3
# 33 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ext/aligned_buffer.h" 3







namespace __gnu_cxx
{




  template<typename _Tp>
    struct __aligned_membuf
    {





      struct _Tp2 { _Tp _M_t; };

      alignas(__alignof__(_Tp2::_M_t)) unsigned char _M_storage[sizeof(_Tp)];

      __aligned_membuf() = default;


      __aligned_membuf(std::nullptr_t) { }

      void*
      _M_addr() noexcept
      { return static_cast<void*>(&_M_storage); }

      const void*
      _M_addr() const noexcept
      { return static_cast<const void*>(&_M_storage); }

      _Tp*
      _M_ptr() noexcept
      { return static_cast<_Tp*>(_M_addr()); }

      const _Tp*
      _M_ptr() const noexcept
      { return static_cast<const _Tp*>(_M_addr()); }
    };





#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"





  template<typename _Tp>
    struct __aligned_buffer
    : std::aligned_storage<sizeof(_Tp), __alignof__(_Tp)>
    {
      typename
 std::aligned_storage<sizeof(_Tp), __alignof__(_Tp)>::type _M_storage;

      __aligned_buffer() = default;


      __aligned_buffer(std::nullptr_t) { }

      void*
      _M_addr() noexcept
      {
        return static_cast<void*>(&_M_storage);
      }

      const void*
      _M_addr() const noexcept
      {
        return static_cast<const void*>(&_M_storage);
      }

      _Tp*
      _M_ptr() noexcept
      { return static_cast<_Tp*>(_M_addr()); }

      const _Tp*
      _M_ptr() const noexcept
      { return static_cast<const _Tp*>(_M_addr()); }
    };
#pragma GCC diagnostic pop


}
# 39 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/hashtable_policy.h" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ext/alloc_traits.h" 1 3
# 33 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ext/alloc_traits.h" 3

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/alloc_traits.h" 1 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/alloc_traits.h" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/memoryfwd.h" 1 3
# 47 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/memoryfwd.h" 3



namespace std __attribute__ ((__visibility__ ("default")))
{
# 64 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/memoryfwd.h" 3
  template<typename>
    class allocator;

  template<>
    class allocator<void>;



  template<typename, typename>
    struct uses_allocator;

  template<typename>
    struct allocator_traits;





}
# 35 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/alloc_traits.h" 2 3




# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/allocator.h" 1 3
# 46 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/allocator.h" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/c++allocator.h" 1 3
# 33 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/c++allocator.h" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/new_allocator.h" 1 3
# 41 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/new_allocator.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 62 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/new_allocator.h" 3
  template<typename _Tp>
    class __new_allocator
    {
    public:
      typedef _Tp value_type;
      typedef std::size_t size_type;
      typedef std::ptrdiff_t difference_type;
# 83 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/new_allocator.h" 3
      typedef std::true_type propagate_on_container_move_assignment;


      __attribute__((__always_inline__))
      constexpr
      __new_allocator() noexcept { }

      __attribute__((__always_inline__))
      constexpr
      __new_allocator(const __new_allocator&) noexcept { }

      template<typename _Tp1>
 __attribute__((__always_inline__))
 constexpr
 __new_allocator(const __new_allocator<_Tp1>&) noexcept { }


      __new_allocator& operator=(const __new_allocator&) = default;
# 125 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/new_allocator.h" 3
      [[__nodiscard__]] _Tp*
      allocate(size_type __n, const void* = static_cast<const void*>(0))
      {



 static_assert(sizeof(_Tp) != 0, "cannot allocate incomplete types");


 if (__builtin_expect(__n > this->_M_max_size(), false))
   {


     if (__n > (std::size_t(-1) / sizeof(_Tp)))
       std::__throw_bad_array_new_length();
     std::__throw_bad_alloc();
   }


 if (alignof(_Tp) > 16UL)
   {
     std::align_val_t __al = std::align_val_t(alignof(_Tp));
     return static_cast<_Tp*>(__builtin_operator_new(__n * sizeof(_Tp),
          __al));
   }

 return static_cast<_Tp*>(__builtin_operator_new(__n * sizeof(_Tp)));
      }


      void
      deallocate(_Tp* __p, size_type __n __attribute__ ((__unused__)))
      {







 if (alignof(_Tp) > 16UL)
   {
     __builtin_operator_delete((__p),
         std::align_val_t(alignof(_Tp)));
     return;
   }

 __builtin_operator_delete((__p));
      }
# 213 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/new_allocator.h" 3
      template<typename _Up>
 friend __attribute__((__always_inline__)) constexpr bool
 operator==(const __new_allocator&, const __new_allocator<_Up>&)
 noexcept
 { return true; }
# 227 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/new_allocator.h" 3
    private:
      __attribute__((__always_inline__))
      constexpr size_type
      _M_max_size() const noexcept
      {

 return std::size_t(9223372036854775807L) / sizeof(_Tp);



      }
    };


}
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/c++allocator.h" 2 3


namespace std
{
# 46 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/c++allocator.h" 3
  template<typename _Tp>
    using __allocator_base = __new_allocator<_Tp>;
}
# 47 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/allocator.h" 2 3





namespace std __attribute__ ((__visibility__ ("default")))
{
# 72 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/allocator.h" 3
  template<>
    class allocator<void>
    {
    public:
      typedef void value_type;
      typedef size_t size_type;
      typedef ptrdiff_t difference_type;
# 93 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/allocator.h" 3
      using propagate_on_container_move_assignment = true_type;

      using is_always_equal
 __attribute__ ((__deprecated__ ("use '" "std::allocator_traits::is_always_equal" "' instead")))
 = true_type;




      allocator() = default;
      ~allocator() = default;

      template<typename _Up>
 __attribute__((__always_inline__))
 constexpr
 allocator(const allocator<_Up>&) noexcept { }






    };
# 127 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/allocator.h" 3
  template<typename _Tp>
    class allocator : public __allocator_base<_Tp>
    {
    public:
      typedef _Tp value_type;
      typedef size_t size_type;
      typedef ptrdiff_t difference_type;
# 150 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/allocator.h" 3
      using propagate_on_container_move_assignment = true_type;

      using is_always_equal
 __attribute__ ((__deprecated__ ("use '" "std::allocator_traits::is_always_equal" "' instead")))
 = true_type;




      __attribute__((__always_inline__))
      constexpr
      allocator() noexcept { }

      __attribute__((__always_inline__))
      constexpr
      allocator(const allocator& __a) noexcept
      : __allocator_base<_Tp>(__a) { }



      allocator& operator=(const allocator&) = default;


      template<typename _Tp1>
 __attribute__((__always_inline__))
 constexpr
 allocator(const allocator<_Tp1>&) noexcept { }

      __attribute__((__always_inline__))

      constexpr

      ~allocator() noexcept { }


      [[nodiscard,__gnu__::__always_inline__]]
      constexpr _Tp*
      allocate(size_t __n)
      {
 if (std::__is_constant_evaluated())
   {
     if (__builtin_mul_overflow(__n, sizeof(_Tp), &__n))
       std::__throw_bad_array_new_length();
     return static_cast<_Tp*>(::operator new(__n));
   }

 return __allocator_base<_Tp>::allocate(__n, 0);
      }

      [[__gnu__::__always_inline__]]
      constexpr void
      deallocate(_Tp* __p, size_t __n)
      {
 if (std::__is_constant_evaluated())
   {
     ::operator delete(__p);
     return;
   }
 __allocator_base<_Tp>::deallocate(__p, __n);
      }


      friend __attribute__((__always_inline__)) constexpr
      bool
      operator==(const allocator&, const allocator&) noexcept
      { return true; }
# 225 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/allocator.h" 3
    };






  template<typename _T1, typename _T2>
    __attribute__((__always_inline__))
    inline constexpr bool
    operator==(const allocator<_T1>&, const allocator<_T2>&)
    noexcept
    { return true; }
# 252 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/allocator.h" 3
  template<typename _Tp>
    class allocator<const _Tp>
    {
    public:
      typedef _Tp value_type;
      allocator() { }
      template<typename _Up> allocator(const allocator<_Up>&) { }
    };

  template<typename _Tp>
    class allocator<volatile _Tp>
    {
    public:
      typedef _Tp value_type;
      allocator() { }
      template<typename _Up> allocator(const allocator<_Up>&) { }
    };

  template<typename _Tp>
    class allocator<const volatile _Tp>
    {
    public:
      typedef _Tp value_type;
      allocator() { }
      template<typename _Up> allocator(const allocator<_Up>&) { }
    };







  extern template class allocator<char>;
  extern template class allocator<wchar_t>;






}
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/alloc_traits.h" 2 3






namespace std __attribute__ ((__visibility__ ("default")))
{




  struct __allocator_traits_base
  {
    template<typename _Tp, typename _Up, typename = void>
      struct __rebind : __replace_first_arg<_Tp, _Up>
      {
 static_assert(is_same<
   typename __replace_first_arg<_Tp, typename _Tp::value_type>::type,
   _Tp>::value,
   "allocator_traits<A>::rebind_alloc<A::value_type> must be A");
      };

    template<typename _Tp, typename _Up>
      struct __rebind<_Tp, _Up,
        __void_t<typename _Tp::template rebind<_Up>::other>>
      {
 using type = typename _Tp::template rebind<_Up>::other;

 static_assert(is_same<
   typename _Tp::template rebind<typename _Tp::value_type>::other,
   _Tp>::value,
   "allocator_traits<A>::rebind_alloc<A::value_type> must be A");
      };

  protected:
    template<typename _Tp>
      using __pointer = typename _Tp::pointer;
    template<typename _Tp>
      using __c_pointer = typename _Tp::const_pointer;
    template<typename _Tp>
      using __v_pointer = typename _Tp::void_pointer;
    template<typename _Tp>
      using __cv_pointer = typename _Tp::const_void_pointer;
    template<typename _Tp>
      using __pocca = typename _Tp::propagate_on_container_copy_assignment;
    template<typename _Tp>
      using __pocma = typename _Tp::propagate_on_container_move_assignment;
    template<typename _Tp>
      using __pocs = typename _Tp::propagate_on_container_swap;
    template<typename _Tp>
      using __equal = __type_identity<typename _Tp::is_always_equal>;
  };

  template<typename _Alloc, typename _Up>
    using __alloc_rebind
      = typename __allocator_traits_base::template __rebind<_Alloc, _Up>::type;
# 105 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/alloc_traits.h" 3
  template<typename _Alloc>
    struct allocator_traits : __allocator_traits_base
    {

      typedef _Alloc allocator_type;

      typedef typename _Alloc::value_type value_type;






      using pointer = __detected_or_t<value_type*, __pointer, _Alloc>;

    private:

      template<template<typename> class _Func, typename _Tp, typename = void>
 struct _Ptr
 {
   using type = typename pointer_traits<pointer>::template rebind<_Tp>;
 };

      template<template<typename> class _Func, typename _Tp>
 struct _Ptr<_Func, _Tp, __void_t<_Func<_Alloc>>>
 {
   using type = _Func<_Alloc>;
 };


      template<typename _A2, typename _PtrT, typename = void>
 struct _Diff
 { using type = typename pointer_traits<_PtrT>::difference_type; };

      template<typename _A2, typename _PtrT>
 struct _Diff<_A2, _PtrT, __void_t<typename _A2::difference_type>>
 { using type = typename _A2::difference_type; };


      template<typename _A2, typename _DiffT, typename = void>
 struct _Size : make_unsigned<_DiffT> { };

      template<typename _A2, typename _DiffT>
 struct _Size<_A2, _DiffT, __void_t<typename _A2::size_type>>
 { using type = typename _A2::size_type; };

    public:






      using const_pointer = typename _Ptr<__c_pointer, const value_type>::type;







      using void_pointer = typename _Ptr<__v_pointer, void>::type;







      using const_void_pointer = typename _Ptr<__cv_pointer, const void>::type;







      using difference_type = typename _Diff<_Alloc, pointer>::type;







      using size_type = typename _Size<_Alloc, difference_type>::type;







      using propagate_on_container_copy_assignment
 = __detected_or_t<false_type, __pocca, _Alloc>;







      using propagate_on_container_move_assignment
 = __detected_or_t<false_type, __pocma, _Alloc>;







      using propagate_on_container_swap
 = __detected_or_t<false_type, __pocs, _Alloc>;







      using is_always_equal
 = typename __detected_or_t<is_empty<_Alloc>, __equal, _Alloc>::type;

      template<typename _Tp>
 using rebind_alloc = __alloc_rebind<_Alloc, _Tp>;
      template<typename _Tp>
 using rebind_traits = allocator_traits<rebind_alloc<_Tp>>;

    private:
      template<typename _Alloc2>
 static constexpr auto
 _S_allocate(_Alloc2& __a, size_type __n, const_void_pointer __hint, int)
 -> decltype(__a.allocate(__n, __hint))
 { return __a.allocate(__n, __hint); }

      template<typename _Alloc2>
 static constexpr pointer
 _S_allocate(_Alloc2& __a, size_type __n, const_void_pointer, ...)
 { return __a.allocate(__n); }

      template<typename _Tp, typename... _Args>
 struct __construct_helper
 {
   template<typename _Alloc2,
     typename = decltype(std::declval<_Alloc2*>()->construct(
    std::declval<_Tp*>(), std::declval<_Args>()...))>
     static true_type __test(int);

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

   using type = decltype(__test<_Alloc>(0));
 };

      template<typename _Tp, typename... _Args>
 using __has_construct
   = typename __construct_helper<_Tp, _Args...>::type;

      template<typename _Tp, typename... _Args>
 static constexpr _Require<__has_construct<_Tp, _Args...>>
 _S_construct(_Alloc& __a, _Tp* __p, _Args&&... __args)
 noexcept(noexcept(__a.construct(__p, std::forward<_Args>(__args)...)))
 { __a.construct(__p, std::forward<_Args>(__args)...); }

      template<typename _Tp, typename... _Args>
 static constexpr
 _Require<__and_<__not_<__has_construct<_Tp, _Args...>>,
          is_constructible<_Tp, _Args...>>>
 _S_construct(_Alloc&, _Tp* __p, _Args&&... __args)
 noexcept(std::is_nothrow_constructible<_Tp, _Args...>::value)
 {



   std::construct_at(__p, std::forward<_Args>(__args)...);

 }

      template<typename _Alloc2, typename _Tp>
 static constexpr auto
 _S_destroy(_Alloc2& __a, _Tp* __p, int)
 noexcept(noexcept(__a.destroy(__p)))
 -> decltype(__a.destroy(__p))
 { __a.destroy(__p); }

      template<typename _Alloc2, typename _Tp>
 static constexpr void
 _S_destroy(_Alloc2&, _Tp* __p, ...)
 noexcept(std::is_nothrow_destructible<_Tp>::value)
 { std::_Destroy(__p); }

      template<typename _Alloc2>
 static constexpr auto
 _S_max_size(_Alloc2& __a, int)
 -> decltype(__a.max_size())
 { return __a.max_size(); }

      template<typename _Alloc2>
 static constexpr size_type
 _S_max_size(_Alloc2&, ...)
 {


   return __gnu_cxx::__numeric_traits<size_type>::__max
     / sizeof(value_type);
 }

      template<typename _Alloc2>
 static constexpr auto
 _S_select(_Alloc2& __a, int)
 -> decltype(__a.select_on_container_copy_construction())
 { return __a.select_on_container_copy_construction(); }

      template<typename _Alloc2>
 static constexpr _Alloc2
 _S_select(_Alloc2& __a, ...)
 { return __a; }

    public:
# 332 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/alloc_traits.h" 3
      [[__nodiscard__]] static constexpr pointer
      allocate(_Alloc& __a, size_type __n)
      { return __a.allocate(__n); }
# 347 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/alloc_traits.h" 3
      [[__nodiscard__]] static constexpr pointer
      allocate(_Alloc& __a, size_type __n, const_void_pointer __hint)
      { return _S_allocate(__a, __n, __hint, 0); }
# 359 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/alloc_traits.h" 3
      static constexpr void
      deallocate(_Alloc& __a, pointer __p, size_type __n)
      { __a.deallocate(__p, __n); }
# 374 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/alloc_traits.h" 3
      template<typename _Tp, typename... _Args>
 static constexpr auto
 construct(_Alloc& __a, _Tp* __p, _Args&&... __args)
 noexcept(noexcept(_S_construct(__a, __p,
           std::forward<_Args>(__args)...)))
 -> decltype(_S_construct(__a, __p, std::forward<_Args>(__args)...))
 { _S_construct(__a, __p, std::forward<_Args>(__args)...); }
# 390 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/alloc_traits.h" 3
      template<typename _Tp>
 static constexpr void
 destroy(_Alloc& __a, _Tp* __p)
 noexcept(noexcept(_S_destroy(__a, __p, 0)))
 { _S_destroy(__a, __p, 0); }
# 404 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/alloc_traits.h" 3
      static constexpr size_type
      max_size(const _Alloc& __a) noexcept
      { return _S_max_size(__a, 0); }
# 416 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/alloc_traits.h" 3
      static constexpr _Alloc
      select_on_container_copy_construction(const _Alloc& __rhs)
      { return _S_select(__rhs, 0); }
    };



  template<typename _Tp>
    struct allocator_traits<allocator<_Tp>>
    {

      using allocator_type = allocator<_Tp>;


      using value_type = _Tp;


      using pointer = _Tp*;


      using const_pointer = const _Tp*;


      using void_pointer = void*;


      using const_void_pointer = const void*;


      using difference_type = std::ptrdiff_t;


      using size_type = std::size_t;


      using propagate_on_container_copy_assignment = false_type;


      using propagate_on_container_move_assignment = true_type;


      using propagate_on_container_swap = false_type;


      using is_always_equal = true_type;

      template<typename _Up>
 using rebind_alloc = allocator<_Up>;

      template<typename _Up>
 using rebind_traits = allocator_traits<allocator<_Up>>;
# 475 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/alloc_traits.h" 3
      [[__nodiscard__,__gnu__::__always_inline__]]
      static constexpr pointer
      allocate(allocator_type& __a, size_type __n)
      { return __a.allocate(__n); }
# 490 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/alloc_traits.h" 3
      [[__nodiscard__,__gnu__::__always_inline__]]
      static constexpr pointer
      allocate(allocator_type& __a, size_type __n,
        [[maybe_unused]] const_void_pointer __hint)
      {



 return __a.allocate(__n);

      }
# 510 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/alloc_traits.h" 3
      [[__gnu__::__always_inline__]]
      static constexpr void
      deallocate(allocator_type& __a, pointer __p, size_type __n)
      { __a.deallocate(__p, __n); }
# 526 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/alloc_traits.h" 3
      template<typename _Up, typename... _Args>
 [[__gnu__::__always_inline__]]
 static constexpr void
 construct(allocator_type& __a __attribute__((__unused__)), _Up* __p,
    _Args&&... __args)
 noexcept(std::is_nothrow_constructible<_Up, _Args...>::value)
 {



   std::construct_at(__p, std::forward<_Args>(__args)...);

 }
# 547 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/alloc_traits.h" 3
      template<typename _Up>
 [[__gnu__::__always_inline__]]
 static constexpr void
 destroy(allocator_type& __a __attribute__((__unused__)), _Up* __p)
 noexcept(is_nothrow_destructible<_Up>::value)
 {



   std::destroy_at(__p);

 }






      [[__gnu__::__always_inline__]]
      static constexpr size_type
      max_size(const allocator_type& __a __attribute__((__unused__))) noexcept
      {



 return size_t(-1) / sizeof(value_type);

      }






      [[__gnu__::__always_inline__]]
      static constexpr allocator_type
      select_on_container_copy_construction(const allocator_type& __rhs)
      { return __rhs; }
    };


  template<>
    struct allocator_traits<allocator<void>>
    {

      using allocator_type = allocator<void>;


      using value_type = void;


      using pointer = void*;


      using const_pointer = const void*;


      using void_pointer = void*;


      using const_void_pointer = const void*;


      using difference_type = std::ptrdiff_t;


      using size_type = std::size_t;


      using propagate_on_container_copy_assignment = false_type;


      using propagate_on_container_move_assignment = true_type;


      using propagate_on_container_swap = false_type;


      using is_always_equal = true_type;

      template<typename _Up>
 using rebind_alloc = allocator<_Up>;

      template<typename _Up>
 using rebind_traits = allocator_traits<allocator<_Up>>;


      static void*
      allocate(allocator_type&, size_type, const void* = nullptr) = delete;


      static void
      deallocate(allocator_type&, void*, size_type) = delete;
# 652 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/alloc_traits.h" 3
      template<typename _Up, typename... _Args>
 [[__gnu__::__always_inline__]]
 static constexpr void
 construct(allocator_type&, _Up* __p, _Args&&... __args)
 noexcept(std::is_nothrow_constructible<_Up, _Args...>::value)
 { std::_Construct(__p, std::forward<_Args>(__args)...); }
# 666 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/alloc_traits.h" 3
      template<typename _Up>
 [[__gnu__::__always_inline__]]
 static constexpr void
 destroy(allocator_type&, _Up* __p)
 noexcept(is_nothrow_destructible<_Up>::value)
 { std::_Destroy(__p); }


      static size_type
      max_size(const allocator_type&) = delete;






      [[__gnu__::__always_inline__]]
      static constexpr allocator_type
      select_on_container_copy_construction(const allocator_type& __rhs)
      { return __rhs; }
    };
# 704 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/alloc_traits.h" 3
  template<typename _Alloc>
    [[__gnu__::__always_inline__]]
    constexpr inline void
    __alloc_on_copy(_Alloc& __one, const _Alloc& __two)
    {
      using __traits = allocator_traits<_Alloc>;
      using __pocca =
 typename __traits::propagate_on_container_copy_assignment::type;

      if constexpr (__pocca::value)
 __one = __two;



    }

  template<typename _Alloc>
    [[__gnu__::__always_inline__]]
    constexpr _Alloc
    __alloc_on_copy(const _Alloc& __a)
    {
      typedef allocator_traits<_Alloc> __traits;
      return __traits::select_on_container_copy_construction(__a);
    }
# 741 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/alloc_traits.h" 3
  template<typename _Alloc>
    [[__gnu__::__always_inline__]]
    constexpr inline void
    __alloc_on_move(_Alloc& __one, _Alloc& __two)
    {
      using __traits = allocator_traits<_Alloc>;
      using __pocma
 = typename __traits::propagate_on_container_move_assignment::type;

      if constexpr (__pocma::value)
 __one = std::move(__two);



    }
# 772 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/alloc_traits.h" 3
  template<typename _Alloc>
    [[__gnu__::__always_inline__]]
    constexpr inline void
    __alloc_on_swap(_Alloc& __one, _Alloc& __two)
    {
      using __traits = allocator_traits<_Alloc>;
      using __pocs = typename __traits::propagate_on_container_swap::type;

      if constexpr (__pocs::value)
 {
   using std::swap;
   swap(__one, __two);
 }



    }

  template<typename _Alloc, typename _Tp,
    typename _ValueT = __remove_cvref_t<typename _Alloc::value_type>,
    typename = void>
    struct __is_alloc_insertable_impl
    : false_type
    { };

  template<typename _Alloc, typename _Tp, typename _ValueT>
    struct __is_alloc_insertable_impl<_Alloc, _Tp, _ValueT,
      __void_t<decltype(allocator_traits<_Alloc>::construct(
     std::declval<_Alloc&>(), std::declval<_ValueT*>(),
     std::declval<_Tp>()))>>
    : true_type
    { };




  template<typename _Alloc>
    struct __is_copy_insertable
    : __is_alloc_insertable_impl<_Alloc,
     typename _Alloc::value_type const&>::type
    { };



  template<typename _Tp>
    struct __is_copy_insertable<allocator<_Tp>>
    : is_copy_constructible<_Tp>
    { };





  template<typename _Alloc>
    struct __is_move_insertable
    : __is_alloc_insertable_impl<_Alloc, typename _Alloc::value_type>::type
    { };



  template<typename _Tp>
    struct __is_move_insertable<allocator<_Tp>>
    : is_move_constructible<_Tp>
    { };



  template<typename _Alloc, typename = void>
    struct __is_allocator : false_type { };

  template<typename _Alloc>
    struct __is_allocator<_Alloc,
      __void_t<typename _Alloc::value_type,
        decltype(std::declval<_Alloc&>().allocate(size_t{}))>>
    : true_type { };

  template<typename _Alloc>
    using _RequireAllocator
      = typename enable_if<__is_allocator<_Alloc>::value, _Alloc>::type;

  template<typename _Alloc>
    using _RequireNotAllocator
      = typename enable_if<!__is_allocator<_Alloc>::value, _Alloc>::type;


  template<typename _Alloc>
    concept __allocator_like = requires (_Alloc& __a) {
      typename _Alloc::value_type;
      __a.deallocate(__a.allocate(1u), 1u);
    };







  template<typename _Alloc, bool = __is_empty(_Alloc)>
    struct __alloc_swap
    { static void _S_do_it(_Alloc&, _Alloc&) noexcept { } };

  template<typename _Alloc>
    struct __alloc_swap<_Alloc, false>
    {
      static void
      _S_do_it(_Alloc& __one, _Alloc& __two) noexcept
      {

 if (__one != __two)
   swap(__one, __two);
      }
    };


  template<typename _Tp, bool
    = __or_<is_copy_constructible<typename _Tp::value_type>,
            is_nothrow_move_constructible<typename _Tp::value_type>>::value>
    struct __shrink_to_fit_aux
    { static bool _S_do_it(_Tp&) noexcept { return false; } };

  template<typename _Tp>
    struct __shrink_to_fit_aux<_Tp, true>
    {
      constexpr
      static bool
      _S_do_it(_Tp& __c) noexcept
      {

 try
   {
     _Tp(__make_move_if_noexcept_iterator(__c.begin()),
  __make_move_if_noexcept_iterator(__c.end()),
  __c.get_allocator()).swap(__c);
     return true;
   }
 catch(...)
   { return false; }



      }
    };
# 922 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/alloc_traits.h" 3
  template<typename _ForwardIterator, typename _Allocator>
    constexpr
    void
    _Destroy(_ForwardIterator __first, _ForwardIterator __last,
      _Allocator& __alloc)
    {
      for (; __first != __last; ++__first)



 allocator_traits<_Allocator>::destroy(__alloc,
           std::__addressof(*__first));

    }


  template<typename _ForwardIterator, typename _Tp>
    __attribute__((__always_inline__)) constexpr
    inline void
    _Destroy(_ForwardIterator __first, _ForwardIterator __last,
      allocator<_Tp>&)
    {
      std::_Destroy(__first, __last);
    }




}
# 35 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ext/alloc_traits.h" 2 3

namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{






template<typename _Alloc, typename = typename _Alloc::value_type>
  struct __alloc_traits

  : std::allocator_traits<_Alloc>

  {
    typedef _Alloc allocator_type;

    typedef std::allocator_traits<_Alloc> _Base_type;
    typedef typename _Base_type::value_type value_type;
    typedef typename _Base_type::pointer pointer;
    typedef typename _Base_type::const_pointer const_pointer;
    typedef typename _Base_type::size_type size_type;
    typedef typename _Base_type::difference_type difference_type;

    typedef value_type& reference;
    typedef const value_type& const_reference;
    using _Base_type::allocate;
    using _Base_type::deallocate;
    using _Base_type::construct;
    using _Base_type::destroy;
    using _Base_type::max_size;

  private:
    template<typename _Ptr>
      using __is_custom_pointer
 = std::__and_<std::is_same<pointer, _Ptr>,
        std::__not_<std::is_pointer<_Ptr>>>;

  public:

    template<typename _Ptr, typename... _Args>
      [[__gnu__::__always_inline__]]
      static constexpr
      std::__enable_if_t<__is_custom_pointer<_Ptr>::value>
      construct(_Alloc& __a, _Ptr __p, _Args&&... __args)
      noexcept(noexcept(_Base_type::construct(__a, std::__to_address(__p),
           std::forward<_Args>(__args)...)))
      {
 _Base_type::construct(__a, std::__to_address(__p),
         std::forward<_Args>(__args)...);
      }


    template<typename _Ptr>
      [[__gnu__::__always_inline__]]
      static constexpr
      std::__enable_if_t<__is_custom_pointer<_Ptr>::value>
      destroy(_Alloc& __a, _Ptr __p)
      noexcept(noexcept(_Base_type::destroy(__a, std::__to_address(__p))))
      { _Base_type::destroy(__a, std::__to_address(__p)); }

    [[__gnu__::__always_inline__]]
    static constexpr _Alloc _S_select_on_copy(const _Alloc& __a)
    { return _Base_type::select_on_container_copy_construction(__a); }

    [[__gnu__::__always_inline__]]
    static constexpr void _S_on_swap(_Alloc& __a, _Alloc& __b)
    { std::__alloc_on_swap(__a, __b); }

    [[__gnu__::__always_inline__]]
    static constexpr bool _S_propagate_on_copy_assign()
    { return _Base_type::propagate_on_container_copy_assignment::value; }

    [[__gnu__::__always_inline__]]
    static constexpr bool _S_propagate_on_move_assign()
    { return _Base_type::propagate_on_container_move_assignment::value; }

    [[__gnu__::__always_inline__]]
    static constexpr bool _S_propagate_on_swap()
    { return _Base_type::propagate_on_container_swap::value; }

    [[__gnu__::__always_inline__]]
    static constexpr bool _S_always_equal()
    { return _Base_type::is_always_equal::value; }

    __attribute__((__always_inline__))
    static constexpr bool _S_nothrow_move()
    { return _S_propagate_on_move_assign() || _S_always_equal(); }

    template<typename _Tp>
      struct rebind
      { typedef typename _Base_type::template rebind_alloc<_Tp> other; };
# 180 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ext/alloc_traits.h" 3
  };


}
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/hashtable_policy.h" 2 3


namespace std __attribute__ ((__visibility__ ("default")))
{



  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    class _Hashtable;

namespace __detail
{





  template<typename _Key, typename _Value, typename _ExtractKey,
    typename _Equal, typename _Hash, typename _RangeHash,
    typename _Unused, typename _Traits>
    struct _Hashtable_base;



  template<typename _Iterator>
    inline typename std::iterator_traits<_Iterator>::difference_type
    __distance_fw(_Iterator __first, _Iterator __last,
    std::input_iterator_tag)
    { return __first != __last ? 1 : 0; }

  template<typename _Iterator>
    inline typename std::iterator_traits<_Iterator>::difference_type
    __distance_fw(_Iterator __first, _Iterator __last,
    std::forward_iterator_tag)
    { return std::distance(__first, __last); }

  template<typename _Iterator>
    inline typename std::iterator_traits<_Iterator>::difference_type
    __distance_fw(_Iterator __first, _Iterator __last)
    { return __distance_fw(__first, __last,
      std::__iterator_category(__first)); }

  struct _Identity
  {
    template<typename _Tp>
      _Tp&&
      operator()(_Tp&& __x) const noexcept
      { return std::forward<_Tp>(__x); }
  };

  struct _Select1st
  {
    template<typename _Pair>
      struct __1st_type;

    template<typename _Tp, typename _Up>
      struct __1st_type<pair<_Tp, _Up>>
      { using type = _Tp; };

    template<typename _Tp, typename _Up>
      struct __1st_type<const pair<_Tp, _Up>>
      { using type = const _Tp; };

    template<typename _Pair>
      struct __1st_type<_Pair&>
      { using type = typename __1st_type<_Pair>::type&; };

    template<typename _Tp>
      typename __1st_type<_Tp>::type&&
      operator()(_Tp&& __x) const noexcept
      { return std::forward<_Tp>(__x).first; }
  };

  template<typename _ExKey, typename _Value>
    struct _ConvertToValueType;

  template<typename _Value>
    struct _ConvertToValueType<_Identity, _Value>
    {
      template<typename _Kt>
 constexpr _Kt&&
 operator()(_Kt&& __k) const noexcept
 { return std::forward<_Kt>(__k); }
    };

  template<typename _Value>
    struct _ConvertToValueType<_Select1st, _Value>
    {
      constexpr _Value&&
      operator()(_Value&& __x) const noexcept
      { return std::move(__x); }

      constexpr const _Value&
      operator()(const _Value& __x) const noexcept
      { return __x; }

      template<typename _Kt, typename _Val>
 constexpr std::pair<_Kt, _Val>&&
 operator()(std::pair<_Kt, _Val>&& __x) const noexcept
 { return std::move(__x); }

      template<typename _Kt, typename _Val>
 constexpr const std::pair<_Kt, _Val>&
 operator()(const std::pair<_Kt, _Val>& __x) const noexcept
 { return __x; }
    };

  template<typename _ExKey>
    struct _NodeBuilder;

  template<>
    struct _NodeBuilder<_Select1st>
    {
      template<typename _Kt, typename _Arg, typename _NodeGenerator>
 static auto
 _S_build(_Kt&& __k, _Arg&& __arg, const _NodeGenerator& __node_gen)
 -> typename _NodeGenerator::__node_ptr
 {
   return __node_gen(std::forward<_Kt>(__k),
       std::forward<_Arg>(__arg).second);
 }
    };

  template<>
    struct _NodeBuilder<_Identity>
    {
      template<typename _Kt, typename _Arg, typename _NodeGenerator>
 static auto
 _S_build(_Kt&& __k, _Arg&&, const _NodeGenerator& __node_gen)
 -> typename _NodeGenerator::__node_ptr
 { return __node_gen(std::forward<_Kt>(__k)); }
    };

  template<typename _HashtableAlloc, typename _NodePtr>
    struct _NodePtrGuard
    {
      _HashtableAlloc& _M_h;
      _NodePtr _M_ptr;

      ~_NodePtrGuard()
      {
 if (_M_ptr)
   _M_h._M_deallocate_node_ptr(_M_ptr);
      }
    };

  template<typename _NodeAlloc>
    struct _Hashtable_alloc;



  template<typename _NodeAlloc>
    struct _ReuseOrAllocNode
    {
    private:
      using __node_alloc_type = _NodeAlloc;
      using __hashtable_alloc = _Hashtable_alloc<__node_alloc_type>;
      using __node_alloc_traits =
 typename __hashtable_alloc::__node_alloc_traits;

    public:
      using __node_ptr = typename __hashtable_alloc::__node_ptr;

      _ReuseOrAllocNode(__node_ptr __nodes, __hashtable_alloc& __h)
      : _M_nodes(__nodes), _M_h(__h) { }
      _ReuseOrAllocNode(const _ReuseOrAllocNode&) = delete;

      ~_ReuseOrAllocNode()
      { _M_h._M_deallocate_nodes(_M_nodes); }

      template<typename... _Args>
 __node_ptr
 operator()(_Args&&... __args) const
 {
   if (!_M_nodes)
     return _M_h._M_allocate_node(std::forward<_Args>(__args)...);

   __node_ptr __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());
   _NodePtrGuard<__hashtable_alloc, __node_ptr> __guard { _M_h, __node };
   __node_alloc_traits::construct(__a, __node->_M_valptr(),
      std::forward<_Args>(__args)...);
   __guard._M_ptr = nullptr;
   return __node;
 }

    private:
      mutable __node_ptr _M_nodes;
      __hashtable_alloc& _M_h;
    };



  template<typename _NodeAlloc>
    struct _AllocNode
    {
    private:
      using __hashtable_alloc = _Hashtable_alloc<_NodeAlloc>;

    public:
      using __node_ptr = typename __hashtable_alloc::__node_ptr;

      _AllocNode(__hashtable_alloc& __h)
      : _M_h(__h) { }

      template<typename... _Args>
 __node_ptr
 operator()(_Args&&... __args) const
 { return _M_h._M_allocate_node(std::forward<_Args>(__args)...); }

    private:
      __hashtable_alloc& _M_h;
    };
# 285 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/hashtable_policy.h" 3
  template<bool _Cache_hash_code, bool _Constant_iterators, bool _Unique_keys>
    struct _Hashtable_traits
    {
      using __hash_cached = __bool_constant<_Cache_hash_code>;
      using __constant_iterators = __bool_constant<_Constant_iterators>;
      using __unique_keys = __bool_constant<_Unique_keys>;
    };







  template<typename _Hash>
    struct _Hashtable_hash_traits
    {
      static constexpr std::size_t
      __small_size_threshold() noexcept
      { return std::__is_fast_hash<_Hash>::value ? 0 : 20; }
    };
# 315 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/hashtable_policy.h" 3
  struct _Hash_node_base
  {
    _Hash_node_base* _M_nxt;

    _Hash_node_base() noexcept : _M_nxt() { }

    _Hash_node_base(_Hash_node_base* __next) noexcept : _M_nxt(__next) { }
  };






  template<typename _Value>
    struct _Hash_node_value_base
    {
      typedef _Value value_type;

      __gnu_cxx::__aligned_buffer<_Value> _M_storage;

      [[__gnu__::__always_inline__]]
      _Value*
      _M_valptr() noexcept
      { return _M_storage._M_ptr(); }

      [[__gnu__::__always_inline__]]
      const _Value*
      _M_valptr() const noexcept
      { return _M_storage._M_ptr(); }

      [[__gnu__::__always_inline__]]
      _Value&
      _M_v() noexcept
      { return *_M_valptr(); }

      [[__gnu__::__always_inline__]]
      const _Value&
      _M_v() const noexcept
      { return *_M_valptr(); }
    };




  template<bool _Cache_hash_code>
    struct _Hash_node_code_cache
    { };




  template<>
    struct _Hash_node_code_cache<true>
    { std::size_t _M_hash_code; };

  template<typename _Value, bool _Cache_hash_code>
    struct _Hash_node_value
    : _Hash_node_value_base<_Value>
    , _Hash_node_code_cache<_Cache_hash_code>
    { };




  template<typename _Value, bool _Cache_hash_code>
    struct _Hash_node
    : _Hash_node_base
    , _Hash_node_value<_Value, _Cache_hash_code>
    {
      _Hash_node*
      _M_next() const noexcept
      { return static_cast<_Hash_node*>(this->_M_nxt); }
    };


  template<typename _Value, bool _Cache_hash_code>
    struct _Node_iterator_base
    {
      using __node_type = _Hash_node<_Value, _Cache_hash_code>;

      __node_type* _M_cur;

      _Node_iterator_base() : _M_cur(nullptr) { }
      _Node_iterator_base(__node_type* __p) noexcept
      : _M_cur(__p) { }

      void
      _M_incr() noexcept
      { _M_cur = _M_cur->_M_next(); }

      friend bool
      operator==(const _Node_iterator_base& __x, const _Node_iterator_base& __y)
      noexcept
      { return __x._M_cur == __y._M_cur; }







    };


  template<typename _Value, bool __constant_iterators, bool __cache>
    struct _Node_iterator
    : public _Node_iterator_base<_Value, __cache>
    {
    private:
      using __base_type = _Node_iterator_base<_Value, __cache>;
      using __node_type = typename __base_type::__node_type;

    public:
      using value_type = _Value;
      using difference_type = std::ptrdiff_t;
      using iterator_category = std::forward_iterator_tag;

      using pointer = __conditional_t<__constant_iterators,
          const value_type*, value_type*>;

      using reference = __conditional_t<__constant_iterators,
     const value_type&, value_type&>;

      _Node_iterator() = default;

      explicit
      _Node_iterator(__node_type* __p) noexcept
      : __base_type(__p) { }

      reference
      operator*() const noexcept
      { return this->_M_cur->_M_v(); }

      pointer
      operator->() const noexcept
      { return this->_M_cur->_M_valptr(); }

      _Node_iterator&
      operator++() noexcept
      {
 this->_M_incr();
 return *this;
      }

      _Node_iterator
      operator++(int) noexcept
      {
 _Node_iterator __tmp(*this);
 this->_M_incr();
 return __tmp;
      }
    };


  template<typename _Value, bool __constant_iterators, bool __cache>
    struct _Node_const_iterator
    : public _Node_iterator_base<_Value, __cache>
    {
    private:
      using __base_type = _Node_iterator_base<_Value, __cache>;
      using __node_type = typename __base_type::__node_type;

    public:
      typedef _Value value_type;
      typedef std::ptrdiff_t difference_type;
      typedef std::forward_iterator_tag iterator_category;

      typedef const value_type* pointer;
      typedef const value_type& reference;

      _Node_const_iterator() = default;

      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_ceil(__n / (double)_M_max_load_factor); }





    std::pair<bool, std::size_t>
    _M_need_rehash(std::size_t __n_bkt, std::size_t __n_elt,
     std::size_t __n_ins) const;

    typedef std::size_t _State;

    _State
    _M_state() const
    { return _M_next_resize; }

    void
    _M_reset() noexcept
    { _M_next_resize = 0; }

    void
    _M_reset(_State __state)
    { _M_next_resize = __state; }

    static const std::size_t _S_growth_factor = 2;

    float _M_max_load_factor;
    mutable std::size_t _M_next_resize;
  };


  struct _Mask_range_hashing
  {
    typedef std::size_t first_argument_type;
    typedef std::size_t second_argument_type;
    typedef std::size_t result_type;

    result_type
    operator()(first_argument_type __num,
        second_argument_type __den) const noexcept
    { return __num & (__den - 1); }
  };


  inline std::size_t
  __clp2(std::size_t __n) noexcept
  {
    using __gnu_cxx::__int_traits;

    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) << (__int_traits<size_t>::__digits - __lz - 1)) << 1;
  }



  struct _Power2_rehash_policy
  {
    using __has_load_factor = true_type;

    _Power2_rehash_policy(float __z = 1.0) noexcept
    : _M_max_load_factor(__z), _M_next_resize(0) { }

    float
    max_load_factor() const noexcept
    { return _M_max_load_factor; }



    std::size_t
    _M_next_bkt(std::size_t __n) noexcept
    {
      if (__n == 0)



 return 1;

      const auto __max_width = std::min<size_t>(sizeof(size_t), 8);
      const auto __max_bkt = size_t(1) << (__max_width * 8 - 1);
      std::size_t __res = __clp2(__n);

      if (__res == 0)
 __res = __max_bkt;
      else if (__res == 1)



 __res = 2;

      if (__res == __max_bkt)



 _M_next_resize = size_t(-1);
      else
 _M_next_resize
   = __builtin_floor(__res * (double)_M_max_load_factor);

      return __res;
    }


    std::size_t
    _M_bkt_for_elements(std::size_t __n) const noexcept
    { return __builtin_ceil(__n / (double)_M_max_load_factor); }





    std::pair<bool, std::size_t>
    _M_need_rehash(std::size_t __n_bkt, std::size_t __n_elt,
     std::size_t __n_ins) noexcept
    {
      if (__n_elt + __n_ins > _M_next_resize)
 {



   double __min_bkts
     = std::max<std::size_t>(__n_elt + __n_ins, _M_next_resize ? 0 : 11)
       / (double)_M_max_load_factor;
   if (__min_bkts >= __n_bkt)
     return { true,
       _M_next_bkt(std::max<std::size_t>(__builtin_floor(__min_bkts) + 1,
      __n_bkt * _S_growth_factor)) };

   _M_next_resize
     = __builtin_floor(__n_bkt * (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;
  };

  template<typename _RehashPolicy>
    struct _RehashStateGuard
    {
      _RehashPolicy* _M_guarded_obj;
      typename _RehashPolicy::_State _M_prev_state;

      _RehashStateGuard(_RehashPolicy& __policy)
      : _M_guarded_obj(std::__addressof(__policy))
      , _M_prev_state(__policy._M_state())
      { }
      _RehashStateGuard(const _RehashStateGuard&) = delete;

      ~_RehashStateGuard()
      {
 if (_M_guarded_obj)
   _M_guarded_obj->_M_reset(_M_prev_state);
      }
    };
# 761 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/hashtable_policy.h" 3
  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits,
    bool _Unique_keys = _Traits::__unique_keys::value>
    struct _Map_base { };


  template<typename _Key, typename _Val, typename _Alloc, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    struct _Map_base<_Key, pair<const _Key, _Val>, _Alloc, _Select1st, _Equal,
       _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits, false>
    {
      using mapped_type = _Val;
    };


  template<typename _Key, typename _Val, typename _Alloc, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    struct _Map_base<_Key, pair<const _Key, _Val>, _Alloc, _Select1st, _Equal,
       _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits, true>
    {
    private:
      using __hashtable_base = _Hashtable_base<_Key, pair<const _Key, _Val>,
            _Select1st, _Equal, _Hash,
            _RangeHash, _Unused,
            _Traits>;

      using __hashtable = _Hashtable<_Key, pair<const _Key, _Val>, _Alloc,
         _Select1st, _Equal, _Hash, _RangeHash,
         _Unused, _RehashPolicy, _Traits>;

      using __hash_code = typename __hashtable_base::__hash_code;

    public:
      using key_type = typename __hashtable_base::key_type;
      using mapped_type = _Val;

      mapped_type&
      operator[](const key_type& __k);

      mapped_type&
      operator[](key_type&& __k);



      mapped_type&
      at(const key_type& __k)
      {
 auto __ite = static_cast<__hashtable*>(this)->find(__k);
 if (!__ite._M_cur)
   __throw_out_of_range(("unordered_map::at"));
 return __ite->second;
      }

      const mapped_type&
      at(const key_type& __k) const
      {
 auto __ite = static_cast<const __hashtable*>(this)->find(__k);
 if (!__ite._M_cur)
   __throw_out_of_range(("unordered_map::at"));
 return __ite->second;
      }
    };

  template<typename _Key, typename _Val, typename _Alloc, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    auto
    _Map_base<_Key, pair<const _Key, _Val>, _Alloc, _Select1st, _Equal,
       _Hash, _RangeHash, _Unused, _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(__code);
      if (auto __node = __h->_M_find_node(__bkt, __k, __code))
 return __node->_M_v().second;

      typename __hashtable::_Scoped_node __node {
 __h,
 std::piecewise_construct,
 std::tuple<const key_type&>(__k),
 std::tuple<>()
      };
      auto __pos
 = __h->_M_insert_unique_node(__bkt, __code, __node._M_node);
      __node._M_node = nullptr;
      return __pos->second;
    }

  template<typename _Key, typename _Val, typename _Alloc, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    auto
    _Map_base<_Key, pair<const _Key, _Val>, _Alloc, _Select1st, _Equal,
       _Hash, _RangeHash, _Unused, _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(__code);
      if (auto __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(__bkt, __code, __node._M_node);
      __node._M_node = nullptr;
      return __pos->second;
    }


  template<typename _Key, typename _Val, typename _Alloc, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits, bool __uniq>
    struct _Map_base<const _Key, pair<const _Key, _Val>,
       _Alloc, _Select1st, _Equal, _Hash,
       _RangeHash, _Unused, _RehashPolicy, _Traits, __uniq>
    : _Map_base<_Key, pair<const _Key, _Val>, _Alloc, _Select1st, _Equal, _Hash,
  _RangeHash, _Unused, _RehashPolicy, _Traits, __uniq>
    { };






  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    struct _Insert_base
    {
    protected:
      using __hashtable_base = _Hashtable_base<_Key, _Value, _ExtractKey,
            _Equal, _Hash, _RangeHash,
            _Unused, _Traits>;

      using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
         _Hash, _RangeHash,
         _Unused, _RehashPolicy, _Traits>;

      using __hash_cached = typename _Traits::__hash_cached;
      using __constant_iterators = typename _Traits::__constant_iterators;

      using __hashtable_alloc = _Hashtable_alloc<
 __alloc_rebind<_Alloc, _Hash_node<_Value,
       __hash_cached::value>>>;

      using value_type = typename __hashtable_base::value_type;
      using size_type = typename __hashtable_base::size_type;

      using __unique_keys = typename _Traits::__unique_keys;
      using __node_alloc_type = typename __hashtable_alloc::__node_alloc_type;
      using __node_gen_type = _AllocNode<__node_alloc_type>;

      __hashtable&
      _M_conjure_hashtable()
      { return *(static_cast<__hashtable*>(this)); }

      template<typename _InputIterator, typename _NodeGetter>
 void
 _M_insert_range(_InputIterator __first, _InputIterator __last,
   const _NodeGetter&, true_type __uks);

      template<typename _InputIterator, typename _NodeGetter>
 void
 _M_insert_range(_InputIterator __first, _InputIterator __last,
   const _NodeGetter&, false_type __uks);

    public:
      using iterator = _Node_iterator<_Value, __constant_iterators::value,
          __hash_cached::value>;

      using const_iterator = _Node_const_iterator<_Value,
        __constant_iterators::value,
        __hash_cached::value>;

      using __ireturn_type = __conditional_t<__unique_keys::value,
          std::pair<iterator, bool>,
          iterator>;

      __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{});
      }

      template<typename _KType, typename... _Args>
 std::pair<iterator, bool>
 try_emplace(const_iterator, _KType&& __k, _Args&&... __args)
 {
   __hashtable& __h = _M_conjure_hashtable();
   auto __code = __h._M_hash_code(__k);
   std::size_t __bkt = __h._M_bucket_index(__code);
   if (auto __node = __h._M_find_node(__bkt, __k, __code))
     return { iterator(__node), false };

   typename __hashtable::_Scoped_node __node {
     &__h,
     std::piecewise_construct,
     std::forward_as_tuple(std::forward<_KType>(__k)),
     std::forward_as_tuple(std::forward<_Args>(__args)...)
     };
   auto __it
     = __h._M_insert_unique_node(__bkt, __code, __node._M_node);
   __node._M_node = nullptr;
   return { __it, true };
 }

      void
      insert(initializer_list<value_type> __l)
      { this->insert(__l.begin(), __l.end()); }

      template<typename _InputIterator>
 void
 insert(_InputIterator __first, _InputIterator __last)
 {
   __hashtable& __h = _M_conjure_hashtable();
   __node_gen_type __node_gen(__h);
   return _M_insert_range(__first, __last, __node_gen, __unique_keys{});
 }
    };

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    template<typename _InputIterator, typename _NodeGetter>
      void
      _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal,
     _Hash, _RangeHash, _Unused,
     _RehashPolicy, _Traits>::
      _M_insert_range(_InputIterator __first, _InputIterator __last,
        const _NodeGetter& __node_gen, true_type __uks)
      {
 __hashtable& __h = _M_conjure_hashtable();
 for (; __first != __last; ++__first)
   __h._M_insert(*__first, __node_gen, __uks);
      }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    template<typename _InputIterator, typename _NodeGetter>
      void
      _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal,
     _Hash, _RangeHash, _Unused,
     _RehashPolicy, _Traits>::
      _M_insert_range(_InputIterator __first, _InputIterator __last,
        const _NodeGetter& __node_gen, false_type __uks)
      {
 using __rehash_guard_t = typename __hashtable::__rehash_guard_t;
 using __pair_type = std::pair<bool, std::size_t>;

 size_type __n_elt = __detail::__distance_fw(__first, __last);
 if (__n_elt == 0)
   return;

 __hashtable& __h = _M_conjure_hashtable();
 __rehash_guard_t __rehash_guard(__h._M_rehash_policy);
 __pair_type __do_rehash
   = __h._M_rehash_policy._M_need_rehash(__h._M_bucket_count,
      __h._M_element_count,
      __n_elt);

 if (__do_rehash.first)
   __h._M_rehash(__do_rehash.second, __uks);

 __rehash_guard._M_guarded_obj = nullptr;
 for (; __first != __last; ++__first)
   __h._M_insert(*__first, __node_gen, __uks);
      }







  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits,
    bool _Constant_iterators = _Traits::__constant_iterators::value>
    struct _Insert;


  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    struct _Insert<_Key, _Value, _Alloc, _ExtractKey, _Equal,
     _Hash, _RangeHash, _Unused,
     _RehashPolicy, _Traits, true>
    : public _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal,
     _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>
    {
      using __base_type = _Insert_base<_Key, _Value, _Alloc, _ExtractKey,
           _Equal, _Hash, _RangeHash, _Unused,
           _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 __ireturn_type = typename __base_type::__ireturn_type;

      using __unique_keys = typename __base_type::__unique_keys;
      using __hashtable = typename __base_type::__hashtable;
      using __node_gen_type = typename __base_type::__node_gen_type;

      using __base_type::insert;

      __ireturn_type
      insert(value_type&& __v)
      {
 __hashtable& __h = this->_M_conjure_hashtable();
 __node_gen_type __node_gen(__h);
 return __h._M_insert(std::move(__v), __node_gen, __unique_keys{});
      }

      iterator
      insert(const_iterator __hint, value_type&& __v)
      {
 __hashtable& __h = this->_M_conjure_hashtable();
 __node_gen_type __node_gen(__h);
 return __h._M_insert(__hint, std::move(__v), __node_gen,
        __unique_keys{});
      }
    };


  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    struct _Insert<_Key, _Value, _Alloc, _ExtractKey, _Equal,
     _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits, false>
    : public _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal,
     _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>
    {
      using __base_type = _Insert_base<_Key, _Value, _Alloc, _ExtractKey,
           _Equal, _Hash, _RangeHash, _Unused,
           _RehashPolicy, _Traits>;
      using value_type = typename __base_type::value_type;
      using iterator = typename __base_type::iterator;
      using const_iterator = typename __base_type::const_iterator;

      using __unique_keys = typename __base_type::__unique_keys;
      using __hashtable = typename __base_type::__hashtable;
      using __ireturn_type = typename __base_type::__ireturn_type;

      using __base_type::insert;

      template<typename _Pair>
 using __is_cons = std::is_constructible<value_type, _Pair&&>;

      template<typename _Pair>
 using _IFcons = std::enable_if<__is_cons<_Pair>::value>;

      template<typename _Pair>
 using _IFconsp = typename _IFcons<_Pair>::type;

      template<typename _Pair, typename = _IFconsp<_Pair>>
 __ireturn_type
 insert(_Pair&& __v)
 {
   __hashtable& __h = this->_M_conjure_hashtable();
   return __h._M_emplace(__unique_keys{}, std::forward<_Pair>(__v));
 }

      template<typename _Pair, typename = _IFconsp<_Pair>>
 iterator
 insert(const_iterator __hint, _Pair&& __v)
 {
   __hashtable& __h = this->_M_conjure_hashtable();
   return __h._M_emplace(__hint, __unique_keys{},
    std::forward<_Pair>(__v));
 }
   };

  template<typename _Policy>
    using __has_load_factor = typename _Policy::__has_load_factor;







  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits,
    typename =
      __detected_or_t<false_type, __has_load_factor, _RehashPolicy>>
    struct _Rehash_base;


  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    struct _Rehash_base<_Key, _Value, _Alloc, _ExtractKey, _Equal,
   _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits,
   false_type >
    {
    };


  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    struct _Rehash_base<_Key, _Value, _Alloc, _ExtractKey, _Equal,
   _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits,
   true_type >
    {
    private:
      using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey,
         _Equal, _Hash, _RangeHash, _Unused,
         _RehashPolicy, _Traits>;

    public:
      float
      max_load_factor() const noexcept
      {
 const __hashtable* __this = static_cast<const __hashtable*>(this);
 return __this->__rehash_policy().max_load_factor();
      }

      void
      max_load_factor(float __z)
      {
 __hashtable* __this = static_cast<__hashtable*>(this);
 __this->__rehash_policy(_RehashPolicy(__z));
      }

      void
      reserve(std::size_t __n)
      {
 __hashtable* __this = static_cast<__hashtable*>(this);
 __this->rehash(__this->__rehash_policy()._M_bkt_for_elements(__n));
      }
    };







  template<int _Nm, typename _Tp,
    bool __use_ebo = !__is_final(_Tp) && __is_empty(_Tp)>
    struct _Hashtable_ebo_helper;


  template<int _Nm, typename _Tp>
    struct _Hashtable_ebo_helper<_Nm, _Tp, true>
    : private _Tp
    {
      _Hashtable_ebo_helper() noexcept(noexcept(_Tp())) : _Tp() { }

      template<typename _OtherTp>
 _Hashtable_ebo_helper(_OtherTp&& __tp)
 : _Tp(std::forward<_OtherTp>(__tp))
 { }

      const _Tp& _M_cget() const { return static_cast<const _Tp&>(*this); }
      _Tp& _M_get() { return static_cast<_Tp&>(*this); }
    };


  template<int _Nm, typename _Tp>
    struct _Hashtable_ebo_helper<_Nm, _Tp, false>
    {
      _Hashtable_ebo_helper() = default;

      template<typename _OtherTp>
 _Hashtable_ebo_helper(_OtherTp&& __tp)
 : _M_tp(std::forward<_OtherTp>(__tp))
 { }

      const _Tp& _M_cget() const { return _M_tp; }
      _Tp& _M_get() { return _M_tp; }

    private:
      _Tp _M_tp{};
    };







  template<typename _Key, typename _Value, typename _ExtractKey,
    typename _Hash, typename _RangeHash, typename _Unused,
    bool __cache_hash_code>
    struct _Local_iterator_base;
# 1301 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/hashtable_policy.h" 3
  template<typename _Key, typename _Value, typename _ExtractKey,
    typename _Hash, typename _RangeHash, typename _Unused,
    bool __cache_hash_code>
    struct _Hash_code_base
    : private _Hashtable_ebo_helper<1, _Hash>
    {
    private:
      using __ebo_hash = _Hashtable_ebo_helper<1, _Hash>;


      friend struct _Local_iterator_base<_Key, _Value, _ExtractKey,
      _Hash, _RangeHash, _Unused, false>;

    public:
      typedef _Hash hasher;

      hasher
      hash_function() const
      { return _M_hash(); }

    protected:
      typedef std::size_t __hash_code;



      _Hash_code_base() = default;

      _Hash_code_base(const _Hash& __hash) : __ebo_hash(__hash) { }

      __hash_code
      _M_hash_code(const _Key& __k) const
      {
 static_assert(__is_invocable<const _Hash&, const _Key&>{},
     "hash function must be invocable with an argument of key type");
 return _M_hash()(__k);
      }

      template<typename _Kt>
 __hash_code
 _M_hash_code_tr(const _Kt& __k) const
 {
   static_assert(__is_invocable<const _Hash&, const _Kt&>{},
     "hash function must be invocable with an argument of key type");
   return _M_hash()(__k);
 }

      __hash_code
      _M_hash_code(const _Hash_node_value<_Value, false>& __n) const
      { return _M_hash_code(_ExtractKey{}(__n._M_v())); }

      __hash_code
      _M_hash_code(const _Hash_node_value<_Value, true>& __n) const
      { return __n._M_hash_code; }

      std::size_t
      _M_bucket_index(__hash_code __c, std::size_t __bkt_count) const
      { return _RangeHash{}(__c, __bkt_count); }

      std::size_t
      _M_bucket_index(const _Hash_node_value<_Value, false>& __n,
        std::size_t __bkt_count) const
 noexcept( noexcept(declval<const _Hash&>()(declval<const _Key&>()))
    && noexcept(declval<const _RangeHash&>()((__hash_code)0,
          (std::size_t)0)) )
      {
 return _RangeHash{}(_M_hash_code(_ExtractKey{}(__n._M_v())),
       __bkt_count);
      }

      std::size_t
      _M_bucket_index(const _Hash_node_value<_Value, true>& __n,
        std::size_t __bkt_count) const
 noexcept( noexcept(declval<const _RangeHash&>()((__hash_code)0,
       (std::size_t)0)) )
      { return _RangeHash{}(__n._M_hash_code, __bkt_count); }

      void
      _M_store_code(_Hash_node_code_cache<false>&, __hash_code) const
      { }

      void
      _M_copy_code(_Hash_node_code_cache<false>&,
     const _Hash_node_code_cache<false>&) const
      { }

      void
      _M_store_code(_Hash_node_code_cache<true>& __n, __hash_code __c) const
      { __n._M_hash_code = __c; }

      void
      _M_copy_code(_Hash_node_code_cache<true>& __to,
     const _Hash_node_code_cache<true>& __from) const
      { __to._M_hash_code = __from._M_hash_code; }

      void
      _M_swap(_Hash_code_base& __x)
      { std::swap(__ebo_hash::_M_get(), __x.__ebo_hash::_M_get()); }

      const _Hash&
      _M_hash() const { return __ebo_hash::_M_cget(); }
    };


  template<typename _Key, typename _Value, typename _ExtractKey,
    typename _Hash, typename _RangeHash, typename _Unused>
    struct _Local_iterator_base<_Key, _Value, _ExtractKey,
    _Hash, _RangeHash, _Unused, true>
    : public _Node_iterator_base<_Value, true>
    {
    protected:
      using __base_node_iter = _Node_iterator_base<_Value, true>;
      using __hash_code_base = _Hash_code_base<_Key, _Value, _ExtractKey,
           _Hash, _RangeHash, _Unused, true>;

      _Local_iterator_base() = default;
      _Local_iterator_base(const __hash_code_base&,
      _Hash_node<_Value, true>* __p,
      std::size_t __bkt, std::size_t __bkt_count)
      : __base_node_iter(__p), _M_bucket(__bkt), _M_bucket_count(__bkt_count)
      { }

      void
      _M_incr()
      {
 __base_node_iter::_M_incr();
 if (this->_M_cur)
   {
     std::size_t __bkt
       = _RangeHash{}(this->_M_cur->_M_hash_code, _M_bucket_count);
     if (__bkt != _M_bucket)
       this->_M_cur = nullptr;
   }
      }

      std::size_t _M_bucket;
      std::size_t _M_bucket_count;

    public:
      std::size_t
      _M_get_bucket() const { return _M_bucket; }
    };





  template<typename _Tp, bool _IsEmpty = std::is_empty<_Tp>::value>
    struct _Hash_code_storage
    {
      __gnu_cxx::__aligned_buffer<_Tp> _M_storage;

      _Tp*
      _M_h() { return _M_storage._M_ptr(); }

      const _Tp*
      _M_h() const { return _M_storage._M_ptr(); }
    };


  template<typename _Tp>
    struct _Hash_code_storage<_Tp, true>
    {
      static_assert( std::is_empty<_Tp>::value, "Type must be empty" );



      _Tp*
      _M_h() { return reinterpret_cast<_Tp*>(this); }

      const _Tp*
      _M_h() const { return reinterpret_cast<const _Tp*>(this); }
    };

  template<typename _Key, typename _Value, typename _ExtractKey,
    typename _Hash, typename _RangeHash, typename _Unused>
    using __hash_code_for_local_iter
      = _Hash_code_storage<_Hash_code_base<_Key, _Value, _ExtractKey,
        _Hash, _RangeHash, _Unused, false>>;


  template<typename _Key, typename _Value, typename _ExtractKey,
    typename _Hash, typename _RangeHash, typename _Unused>
    struct _Local_iterator_base<_Key, _Value, _ExtractKey,
    _Hash, _RangeHash, _Unused, false>
    : __hash_code_for_local_iter<_Key, _Value, _ExtractKey, _Hash, _RangeHash,
     _Unused>
    , _Node_iterator_base<_Value, false>
    {
    protected:
      using __hash_code_base = _Hash_code_base<_Key, _Value, _ExtractKey,
          _Hash, _RangeHash, _Unused, false>;
      using __node_iter_base = _Node_iterator_base<_Value, 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)
      : __node_iter_base(__p), _M_bucket(__bkt), _M_bucket_count(__bkt_count)
      { _M_init(__base); }

      ~_Local_iterator_base()
      {
 if (_M_bucket_count != size_t(-1))
   _M_destroy();
      }

      _Local_iterator_base(const _Local_iterator_base& __iter)
      : __node_iter_base(__iter._M_cur), _M_bucket(__iter._M_bucket)
      , _M_bucket_count(__iter._M_bucket_count)
      {
 if (_M_bucket_count != size_t(-1))
   _M_init(*__iter._M_h());
      }

      _Local_iterator_base&
      operator=(const _Local_iterator_base& __iter)
      {
 if (_M_bucket_count != -1)
   _M_destroy();
 this->_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()
      {
 __node_iter_base::_M_incr();
 if (this->_M_cur)
   {
     std::size_t __bkt = this->_M_h()->_M_bucket_index(*this->_M_cur,
             _M_bucket_count);
     if (__bkt != _M_bucket)
       this->_M_cur = nullptr;
   }
      }

      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:
      std::size_t
      _M_get_bucket() const { return _M_bucket; }
    };


  template<typename _Key, typename _Value, typename _ExtractKey,
    typename _Hash, typename _RangeHash, typename _Unused,
    bool __constant_iterators, bool __cache>
    struct _Local_iterator
    : public _Local_iterator_base<_Key, _Value, _ExtractKey,
      _Hash, _RangeHash, _Unused, __cache>
    {
    private:
      using __base_type = _Local_iterator_base<_Key, _Value, _ExtractKey,
        _Hash, _RangeHash, _Unused, __cache>;
      using __hash_code_base = typename __base_type::__hash_code_base;

    public:
      using value_type = _Value;
      using pointer = __conditional_t<__constant_iterators,
          const value_type*, value_type*>;
      using reference = __conditional_t<__constant_iterators,
     const value_type&, value_type&>;
      using difference_type = ptrdiff_t;
      using iterator_category = forward_iterator_tag;

      _Local_iterator() = default;

      _Local_iterator(const __hash_code_base& __base,
        _Hash_node<_Value, __cache>* __n,
        std::size_t __bkt, std::size_t __bkt_count)
      : __base_type(__base, __n, __bkt, __bkt_count)
      { }

      reference
      operator*() const
      { return this->_M_cur->_M_v(); }

      pointer
      operator->() const
      { return this->_M_cur->_M_valptr(); }

      _Local_iterator&
      operator++()
      {
 this->_M_incr();
 return *this;
      }

      _Local_iterator
      operator++(int)
      {
 _Local_iterator __tmp(*this);
 this->_M_incr();
 return __tmp;
      }
    };


  template<typename _Key, typename _Value, typename _ExtractKey,
    typename _Hash, typename _RangeHash, typename _Unused,
    bool __constant_iterators, bool __cache>
    struct _Local_const_iterator
    : public _Local_iterator_base<_Key, _Value, _ExtractKey,
      _Hash, _RangeHash, _Unused, __cache>
    {
    private:
      using __base_type = _Local_iterator_base<_Key, _Value, _ExtractKey,
        _Hash, _RangeHash, _Unused, __cache>;
      using __hash_code_base = typename __base_type::__hash_code_base;

    public:
      typedef _Value value_type;
      typedef const value_type* pointer;
      typedef const value_type& 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,
        _Hash, _RangeHash, _Unused,
        __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;
      }
    };
# 1680 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/hashtable_policy.h" 3
  template<typename _Key, typename _Value, typename _ExtractKey,
    typename _Equal, typename _Hash, typename _RangeHash,
    typename _Unused, typename _Traits>
    struct _Hashtable_base
    : public _Hash_code_base<_Key, _Value, _ExtractKey, _Hash, _RangeHash,
        _Unused, _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 __hash_code_base = _Hash_code_base<_Key, _Value, _ExtractKey,
            _Hash, _RangeHash, _Unused,
            __hash_cached::value>;

      using __hash_code = typename __hash_code_base::__hash_code;

    private:
      using _EqualEBO = _Hashtable_ebo_helper<0, _Equal>;

      static bool
      _S_equals(__hash_code, const _Hash_node_code_cache<false>&)
      { return true; }

      static bool
      _S_node_equals(const _Hash_node_code_cache<false>&,
       const _Hash_node_code_cache<false>&)
      { return true; }

      static bool
      _S_equals(__hash_code __c, const _Hash_node_code_cache<true>& __n)
      { return __c == __n._M_hash_code; }

      static bool
      _S_node_equals(const _Hash_node_code_cache<true>& __lhn,
       const _Hash_node_code_cache<true>& __rhn)
      { return __lhn._M_hash_code == __rhn._M_hash_code; }

    protected:
      _Hashtable_base() = default;

      _Hashtable_base(const _Hash& __hash, const _Equal& __eq)
      : __hash_code_base(__hash), _EqualEBO(__eq)
      { }

      bool
      _M_key_equals(const _Key& __k,
      const _Hash_node_value<_Value,
        __hash_cached::value>& __n) const
      {
 static_assert(__is_invocable<const _Equal&, const _Key&, const _Key&>{},
   "key equality predicate must be invocable with two arguments of "
   "key type");
 return _M_eq()(__k, _ExtractKey{}(__n._M_v()));
      }

      template<typename _Kt>
 bool
 _M_key_equals_tr(const _Kt& __k,
    const _Hash_node_value<_Value,
          __hash_cached::value>& __n) const
 {
   static_assert(
     __is_invocable<const _Equal&, const _Kt&, const _Key&>{},
     "key equality predicate must be invocable with two arguments of "
     "key type");
   return _M_eq()(__k, _ExtractKey{}(__n._M_v()));
 }

      bool
      _M_equals(const _Key& __k, __hash_code __c,
  const _Hash_node_value<_Value, __hash_cached::value>& __n) const
      { return _S_equals(__c, __n) && _M_key_equals(__k, __n); }

      template<typename _Kt>
 bool
 _M_equals_tr(const _Kt& __k, __hash_code __c,
       const _Hash_node_value<_Value,
         __hash_cached::value>& __n) const
 { return _S_equals(__c, __n) && _M_key_equals_tr(__k, __n); }

      bool
      _M_node_equals(
 const _Hash_node_value<_Value, __hash_cached::value>& __lhn,
 const _Hash_node_value<_Value, __hash_cached::value>& __rhn) const
      {
 return _S_node_equals(__lhn, __rhn)
   && _M_key_equals(_ExtractKey{}(__lhn._M_v()), __rhn);
      }

      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(); }
    };
# 1796 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/hashtable_policy.h" 3
  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits,
    bool _Unique_keys = _Traits::__unique_keys::value>
    struct _Equality;


  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    struct _Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal,
       _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits, true>
    {
      using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
         _Hash, _RangeHash, _Unused,
         _RehashPolicy, _Traits>;

      bool
      _M_equal(const __hashtable&) const;
    };

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    bool
    _Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal,
       _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits, true>::
    _M_equal(const __hashtable& __other) const
    {
      using __node_ptr = typename __hashtable::__node_ptr;
      const __hashtable* __this = static_cast<const __hashtable*>(this);
      if (__this->size() != __other.size())
 return false;

      for (auto __x_n = __this->_M_begin(); __x_n; __x_n = __x_n->_M_next())
 {
   std::size_t __ybkt = __other._M_bucket_index(*__x_n);
   auto __prev_n = __other._M_buckets[__ybkt];
   if (!__prev_n)
     return false;

   for (__node_ptr __n = static_cast<__node_ptr>(__prev_n->_M_nxt);;
        __n = __n->_M_next())
     {
       if (__n->_M_v() == __x_n->_M_v())
  break;

       if (!__n->_M_nxt
    || __other._M_bucket_index(*__n->_M_next()) != __ybkt)
  return false;
     }
 }

      return true;
    }


  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    struct _Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal,
       _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits, false>
    {
      using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
         _Hash, _RangeHash, _Unused,
         _RehashPolicy, _Traits>;

      bool
      _M_equal(const __hashtable&) const;
    };

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    bool
    _Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal,
       _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits, false>::
    _M_equal(const __hashtable& __other) const
    {
      using __node_ptr = typename __hashtable::__node_ptr;
      using const_iterator = typename __hashtable::const_iterator;
      const __hashtable* __this = static_cast<const __hashtable*>(this);
      if (__this->size() != __other.size())
 return false;

      for (auto __x_n = __this->_M_begin(); __x_n;)
 {
   std::size_t __x_count = 1;
   auto __x_n_end = __x_n->_M_next();
   for (; __x_n_end
   && __this->key_eq()(_ExtractKey{}(__x_n->_M_v()),
         _ExtractKey{}(__x_n_end->_M_v()));
        __x_n_end = __x_n_end->_M_next())
     ++__x_count;

   std::size_t __ybkt = __other._M_bucket_index(*__x_n);
   auto __y_prev_n = __other._M_buckets[__ybkt];
   if (!__y_prev_n)
     return false;

   __node_ptr __y_n = static_cast<__node_ptr>(__y_prev_n->_M_nxt);
   for (;;)
     {
       if (__this->key_eq()(_ExtractKey{}(__y_n->_M_v()),
       _ExtractKey{}(__x_n->_M_v())))
  break;

       auto __y_ref_n = __y_n;
       for (__y_n = __y_n->_M_next(); __y_n; __y_n = __y_n->_M_next())
  if (!__other._M_node_equals(*__y_ref_n, *__y_n))
    break;

       if (!__y_n || __other._M_bucket_index(*__y_n) != __ybkt)
  return false;
     }

   auto __y_n_end = __y_n;
   for (; __y_n_end; __y_n_end = __y_n_end->_M_next())
     if (--__x_count == 0)
       break;

   if (__x_count != 0)
     return false;

   const_iterator __itx(__x_n), __itx_end(__x_n_end);
   const_iterator __ity(__y_n);
   if (!std::is_permutation(__itx, __itx_end, __ity))
     return false;

   __x_n = __x_n_end;
 }
      return true;
    }





  template<typename _NodeAlloc>
    struct _Hashtable_alloc : private _Hashtable_ebo_helper<0, _NodeAlloc>
    {
    private:
      using __ebo_node_alloc = _Hashtable_ebo_helper<0, _NodeAlloc>;

      template<typename>
 struct __get_value_type;
      template<typename _Val, bool _Cache_hash_code>
 struct __get_value_type<_Hash_node<_Val, _Cache_hash_code>>
 { using type = _Val; };

    public:
      using __node_type = typename _NodeAlloc::value_type;
      using __node_alloc_type = _NodeAlloc;

      using __node_alloc_traits = __gnu_cxx::__alloc_traits<__node_alloc_type>;

      using __value_alloc_traits = typename __node_alloc_traits::template
 rebind_traits<typename __get_value_type<__node_type>::type>;

      using __node_ptr = __node_type*;
      using __node_base = _Hash_node_base;
      using __node_base_ptr = __node_base*;
      using __buckets_alloc_type =
 __alloc_rebind<__node_alloc_type, __node_base_ptr>;
      using __buckets_alloc_traits = std::allocator_traits<__buckets_alloc_type>;
      using __buckets_ptr = __node_base_ptr*;

      _Hashtable_alloc() = default;
      _Hashtable_alloc(const _Hashtable_alloc&) = default;
      _Hashtable_alloc(_Hashtable_alloc&&) = default;

      template<typename _Alloc>
 _Hashtable_alloc(_Alloc&& __a)
 : __ebo_node_alloc(std::forward<_Alloc>(__a))
 { }

      __node_alloc_type&
      _M_node_allocator()
      { return __ebo_node_alloc::_M_get(); }

      const __node_alloc_type&
      _M_node_allocator() const
      { return __ebo_node_alloc::_M_cget(); }


      template<typename... _Args>
 __node_ptr
 _M_allocate_node(_Args&&... __args);


      void
      _M_deallocate_node(__node_ptr __n);


      void
      _M_deallocate_node_ptr(__node_ptr __n);



      void
      _M_deallocate_nodes(__node_ptr __n);

      __buckets_ptr
      _M_allocate_buckets(std::size_t __bkt_count);

      void
      _M_deallocate_buckets(__buckets_ptr, std::size_t __bkt_count);
    };



  template<typename _NodeAlloc>
    template<typename... _Args>
      auto
      _Hashtable_alloc<_NodeAlloc>::_M_allocate_node(_Args&&... __args)
      -> __node_ptr
      {
 auto& __alloc = _M_node_allocator();
 auto __nptr = __node_alloc_traits::allocate(__alloc, 1);
 __node_ptr __n = std::__to_address(__nptr);
 try
   {
     ::new ((void*)__n) __node_type;
     __node_alloc_traits::construct(__alloc, __n->_M_valptr(),
        std::forward<_Args>(__args)...);
     return __n;
   }
 catch(...)
   {
     __n->~__node_type();
     __node_alloc_traits::deallocate(__alloc, __nptr, 1);
     throw;
   }
      }

  template<typename _NodeAlloc>
    void
    _Hashtable_alloc<_NodeAlloc>::_M_deallocate_node(__node_ptr __n)
    {
      __node_alloc_traits::destroy(_M_node_allocator(), __n->_M_valptr());
      _M_deallocate_node_ptr(__n);
    }

  template<typename _NodeAlloc>
    void
    _Hashtable_alloc<_NodeAlloc>::_M_deallocate_node_ptr(__node_ptr __n)
    {
      typedef typename __node_alloc_traits::pointer _Ptr;
      auto __ptr = std::pointer_traits<_Ptr>::pointer_to(*__n);
      __n->~__node_type();
      __node_alloc_traits::deallocate(_M_node_allocator(), __ptr, 1);
    }

  template<typename _NodeAlloc>
    void
    _Hashtable_alloc<_NodeAlloc>::_M_deallocate_nodes(__node_ptr __n)
    {
      while (__n)
 {
   __node_ptr __tmp = __n;
   __n = __n->_M_next();
   _M_deallocate_node(__tmp);
 }
    }

  template<typename _NodeAlloc>
    auto
    _Hashtable_alloc<_NodeAlloc>::_M_allocate_buckets(std::size_t __bkt_count)
    -> __buckets_ptr
    {
      __buckets_alloc_type __alloc(_M_node_allocator());

      auto __ptr = __buckets_alloc_traits::allocate(__alloc, __bkt_count);
      __buckets_ptr __p = std::__to_address(__ptr);
      __builtin_memset(__p, 0, __bkt_count * sizeof(__node_base_ptr));
      return __p;
    }

  template<typename _NodeAlloc>
    void
    _Hashtable_alloc<_NodeAlloc>::
    _M_deallocate_buckets(__buckets_ptr __bkts,
     std::size_t __bkt_count)
    {
      typedef typename __buckets_alloc_traits::pointer _Ptr;
      auto __ptr = std::pointer_traits<_Ptr>::pointer_to(*__bkts);
      __buckets_alloc_type __alloc(_M_node_allocator());
      __buckets_alloc_traits::deallocate(__alloc, __ptr, __bkt_count);
    }


}


}
# 36 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/hashtable.h" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/enable_special_members.h" 1 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/enable_special_members.h" 3



namespace std __attribute__ ((__visibility__ ("default")))
{



  struct _Enable_default_constructor_tag
  {
    explicit constexpr _Enable_default_constructor_tag() = default;
  };






template<bool _Switch, typename _Tag = void>
  struct _Enable_default_constructor
  {
    constexpr _Enable_default_constructor() noexcept = default;
    constexpr _Enable_default_constructor(_Enable_default_constructor const&)
      noexcept = default;
    constexpr _Enable_default_constructor(_Enable_default_constructor&&)
      noexcept = default;
    _Enable_default_constructor&
    operator=(_Enable_default_constructor const&) noexcept = default;
    _Enable_default_constructor&
    operator=(_Enable_default_constructor&&) noexcept = default;


    constexpr explicit
    _Enable_default_constructor(_Enable_default_constructor_tag) { }
  };







template<bool _Switch, typename _Tag = void>
  struct _Enable_destructor { };






template<bool _Copy, bool _CopyAssignment,
         bool _Move, bool _MoveAssignment,
         typename _Tag = void>
  struct _Enable_copy_move { };
# 96 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/enable_special_members.h" 3
template<bool _Default, bool _Destructor,
         bool _Copy, bool _CopyAssignment,
         bool _Move, bool _MoveAssignment,
         typename _Tag = void>
  struct _Enable_special_members
  : private _Enable_default_constructor<_Default, _Tag>,
    private _Enable_destructor<_Destructor, _Tag>,
    private _Enable_copy_move<_Copy, _CopyAssignment,
                              _Move, _MoveAssignment,
                              _Tag>
  { };



template<typename _Tag>
  struct _Enable_default_constructor<false, _Tag>
  {
    constexpr _Enable_default_constructor() noexcept = delete;
    constexpr _Enable_default_constructor(_Enable_default_constructor const&)
      noexcept = default;
    constexpr _Enable_default_constructor(_Enable_default_constructor&&)
      noexcept = default;
    _Enable_default_constructor&
    operator=(_Enable_default_constructor const&) noexcept = default;
    _Enable_default_constructor&
    operator=(_Enable_default_constructor&&) noexcept = default;


    constexpr explicit
    _Enable_default_constructor(_Enable_default_constructor_tag) { }
  };

template<typename _Tag>
  struct _Enable_destructor<false, _Tag>
  { ~_Enable_destructor() noexcept = delete; };

template<typename _Tag>
  struct _Enable_copy_move<false, true, true, true, _Tag>
  {
    constexpr _Enable_copy_move() noexcept = default;
    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete;
    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default;
    _Enable_copy_move&
    operator=(_Enable_copy_move const&) noexcept = default;
    _Enable_copy_move&
    operator=(_Enable_copy_move&&) noexcept = default;
  };

template<typename _Tag>
  struct _Enable_copy_move<true, false, true, true, _Tag>
  {
    constexpr _Enable_copy_move() noexcept = default;
    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default;
    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default;
    _Enable_copy_move&
    operator=(_Enable_copy_move const&) noexcept = delete;
    _Enable_copy_move&
    operator=(_Enable_copy_move&&) noexcept = default;
  };

template<typename _Tag>
  struct _Enable_copy_move<false, false, true, true, _Tag>
  {
    constexpr _Enable_copy_move() noexcept = default;
    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete;
    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default;
    _Enable_copy_move&
    operator=(_Enable_copy_move const&) noexcept = delete;
    _Enable_copy_move&
    operator=(_Enable_copy_move&&) noexcept = default;
  };

template<typename _Tag>
  struct _Enable_copy_move<true, true, false, true, _Tag>
  {
    constexpr _Enable_copy_move() noexcept = default;
    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default;
    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete;
    _Enable_copy_move&
    operator=(_Enable_copy_move const&) noexcept = default;
    _Enable_copy_move&
    operator=(_Enable_copy_move&&) noexcept = default;
  };

template<typename _Tag>
  struct _Enable_copy_move<false, true, false, true, _Tag>
  {
    constexpr _Enable_copy_move() noexcept = default;
    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete;
    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete;
    _Enable_copy_move&
    operator=(_Enable_copy_move const&) noexcept = default;
    _Enable_copy_move&
    operator=(_Enable_copy_move&&) noexcept = default;
  };

template<typename _Tag>
  struct _Enable_copy_move<true, false, false, true, _Tag>
  {
    constexpr _Enable_copy_move() noexcept = default;
    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default;
    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete;
    _Enable_copy_move&
    operator=(_Enable_copy_move const&) noexcept = delete;
    _Enable_copy_move&
    operator=(_Enable_copy_move&&) noexcept = default;
  };

template<typename _Tag>
  struct _Enable_copy_move<false, false, false, true, _Tag>
  {
    constexpr _Enable_copy_move() noexcept = default;
    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete;
    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete;
    _Enable_copy_move&
    operator=(_Enable_copy_move const&) noexcept = delete;
    _Enable_copy_move&
    operator=(_Enable_copy_move&&) noexcept = default;
  };

template<typename _Tag>
  struct _Enable_copy_move<true, true, true, false, _Tag>
  {
    constexpr _Enable_copy_move() noexcept = default;
    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default;
    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default;
    _Enable_copy_move&
    operator=(_Enable_copy_move const&) noexcept = default;
    _Enable_copy_move&
    operator=(_Enable_copy_move&&) noexcept = delete;
  };

template<typename _Tag>
  struct _Enable_copy_move<false, true, true, false, _Tag>
  {
    constexpr _Enable_copy_move() noexcept = default;
    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete;
    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default;
    _Enable_copy_move&
    operator=(_Enable_copy_move const&) noexcept = default;
    _Enable_copy_move&
    operator=(_Enable_copy_move&&) noexcept = delete;
  };

template<typename _Tag>
  struct _Enable_copy_move<true, false, true, false, _Tag>
  {
    constexpr _Enable_copy_move() noexcept = default;
    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default;
    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default;
    _Enable_copy_move&
    operator=(_Enable_copy_move const&) noexcept = delete;
    _Enable_copy_move&
    operator=(_Enable_copy_move&&) noexcept = delete;
  };

template<typename _Tag>
  struct _Enable_copy_move<false, false, true, false, _Tag>
  {
    constexpr _Enable_copy_move() noexcept = default;
    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete;
    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default;
    _Enable_copy_move&
    operator=(_Enable_copy_move const&) noexcept = delete;
    _Enable_copy_move&
    operator=(_Enable_copy_move&&) noexcept = delete;
  };

template<typename _Tag>
  struct _Enable_copy_move<true, true, false, false, _Tag>
  {
    constexpr _Enable_copy_move() noexcept = default;
    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default;
    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete;
    _Enable_copy_move&
    operator=(_Enable_copy_move const&) noexcept = default;
    _Enable_copy_move&
    operator=(_Enable_copy_move&&) noexcept = delete;
  };

template<typename _Tag>
  struct _Enable_copy_move<false, true, false, false, _Tag>
  {
    constexpr _Enable_copy_move() noexcept = default;
    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete;
    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete;
    _Enable_copy_move&
    operator=(_Enable_copy_move const&) noexcept = default;
    _Enable_copy_move&
    operator=(_Enable_copy_move&&) noexcept = delete;
  };

template<typename _Tag>
  struct _Enable_copy_move<true, false, false, false, _Tag>
  {
    constexpr _Enable_copy_move() noexcept = default;
    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default;
    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete;
    _Enable_copy_move&
    operator=(_Enable_copy_move const&) noexcept = delete;
    _Enable_copy_move&
    operator=(_Enable_copy_move&&) noexcept = delete;
  };

template<typename _Tag>
  struct _Enable_copy_move<false, false, false, false, _Tag>
  {
    constexpr _Enable_copy_move() noexcept = default;
    constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete;
    constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete;
    _Enable_copy_move&
    operator=(_Enable_copy_move const&) noexcept = delete;
    _Enable_copy_move&
    operator=(_Enable_copy_move&&) noexcept = delete;
  };



}
# 37 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/hashtable.h" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_function.h" 1 3
# 63 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_function.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 116 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_function.h" 3
  template<typename _Arg, typename _Result>
    struct unary_function
    {

      typedef _Arg argument_type;


      typedef _Result result_type;
    } __attribute__ ((__deprecated__));





  template<typename _Arg1, typename _Arg2, typename _Result>
    struct binary_function
    {

      typedef _Arg1 first_argument_type;


      typedef _Arg2 second_argument_type;


      typedef _Result result_type;
    } __attribute__ ((__deprecated__));
# 157 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_function.h" 3
  struct __is_transparent;

  template<typename _Tp = void>
    struct plus;

  template<typename _Tp = void>
    struct minus;

  template<typename _Tp = void>
    struct multiplies;

  template<typename _Tp = void>
    struct divides;

  template<typename _Tp = void>
    struct modulus;

  template<typename _Tp = void>
    struct negate;



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"


  template<typename _Tp>
    struct plus : public binary_function<_Tp, _Tp, _Tp>
    {

      constexpr
      _Tp
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x + __y; }
    };


  template<typename _Tp>
    struct minus : public binary_function<_Tp, _Tp, _Tp>
    {
      constexpr
      _Tp
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x - __y; }
    };


  template<typename _Tp>
    struct multiplies : public binary_function<_Tp, _Tp, _Tp>
    {
      constexpr
      _Tp
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x * __y; }
    };


  template<typename _Tp>
    struct divides : public binary_function<_Tp, _Tp, _Tp>
    {
      constexpr
      _Tp
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x / __y; }
    };


  template<typename _Tp>
    struct modulus : public binary_function<_Tp, _Tp, _Tp>
    {
      constexpr
      _Tp
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x % __y; }
    };


  template<typename _Tp>
    struct negate : public unary_function<_Tp, _Tp>
    {
      constexpr
      _Tp
      operator()(const _Tp& __x) const
      { return -__x; }
    };
#pragma GCC diagnostic pop


  template<>
    struct plus<void>
    {
      template <typename _Tp, typename _Up>
 constexpr
 auto
 operator()(_Tp&& __t, _Up&& __u) const
 noexcept(noexcept(std::forward<_Tp>(__t) + std::forward<_Up>(__u)))
 -> decltype(std::forward<_Tp>(__t) + std::forward<_Up>(__u))
 { return std::forward<_Tp>(__t) + std::forward<_Up>(__u); }

      typedef __is_transparent is_transparent;
    };


  template<>
    struct minus<void>
    {
      template <typename _Tp, typename _Up>
 constexpr
 auto
 operator()(_Tp&& __t, _Up&& __u) const
 noexcept(noexcept(std::forward<_Tp>(__t) - std::forward<_Up>(__u)))
 -> decltype(std::forward<_Tp>(__t) - std::forward<_Up>(__u))
 { return std::forward<_Tp>(__t) - std::forward<_Up>(__u); }

      typedef __is_transparent is_transparent;
    };


  template<>
    struct multiplies<void>
    {
      template <typename _Tp, typename _Up>
 constexpr
 auto
 operator()(_Tp&& __t, _Up&& __u) const
 noexcept(noexcept(std::forward<_Tp>(__t) * std::forward<_Up>(__u)))
 -> decltype(std::forward<_Tp>(__t) * std::forward<_Up>(__u))
 { return std::forward<_Tp>(__t) * std::forward<_Up>(__u); }

      typedef __is_transparent is_transparent;
    };


  template<>
    struct divides<void>
    {
      template <typename _Tp, typename _Up>
 constexpr
 auto
 operator()(_Tp&& __t, _Up&& __u) const
 noexcept(noexcept(std::forward<_Tp>(__t) / std::forward<_Up>(__u)))
 -> decltype(std::forward<_Tp>(__t) / std::forward<_Up>(__u))
 { return std::forward<_Tp>(__t) / std::forward<_Up>(__u); }

      typedef __is_transparent is_transparent;
    };


  template<>
    struct modulus<void>
    {
      template <typename _Tp, typename _Up>
 constexpr
 auto
 operator()(_Tp&& __t, _Up&& __u) const
 noexcept(noexcept(std::forward<_Tp>(__t) % std::forward<_Up>(__u)))
 -> decltype(std::forward<_Tp>(__t) % std::forward<_Up>(__u))
 { return std::forward<_Tp>(__t) % std::forward<_Up>(__u); }

      typedef __is_transparent is_transparent;
    };


  template<>
    struct negate<void>
    {
      template <typename _Tp>
 constexpr
 auto
 operator()(_Tp&& __t) const
 noexcept(noexcept(-std::forward<_Tp>(__t)))
 -> decltype(-std::forward<_Tp>(__t))
 { return -std::forward<_Tp>(__t); }

      typedef __is_transparent is_transparent;
    };
# 346 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_function.h" 3
  template<typename _Tp = void>
    struct equal_to;

  template<typename _Tp = void>
    struct not_equal_to;

  template<typename _Tp = void>
    struct greater;

  template<typename _Tp = void>
    struct less;

  template<typename _Tp = void>
    struct greater_equal;

  template<typename _Tp = void>
    struct less_equal;


#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"


  template<typename _Tp>
    struct equal_to : public binary_function<_Tp, _Tp, bool>
    {
      constexpr
      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x == __y; }
    };


  template<typename _Tp>
    struct not_equal_to : public binary_function<_Tp, _Tp, bool>
    {
      constexpr
      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x != __y; }
    };


  template<typename _Tp>
    struct greater : public binary_function<_Tp, _Tp, bool>
    {
      constexpr
      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x > __y; }
    };


  template<typename _Tp>
    struct less : public binary_function<_Tp, _Tp, bool>
    {
      constexpr
      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x < __y; }
    };


  template<typename _Tp>
    struct greater_equal : public binary_function<_Tp, _Tp, bool>
    {
      constexpr
      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x >= __y; }
    };


  template<typename _Tp>
    struct less_equal : public binary_function<_Tp, _Tp, bool>
    {
      constexpr
      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x <= __y; }
    };


  template<typename _Tp>
    struct greater<_Tp*> : public binary_function<_Tp*, _Tp*, bool>
    {
      constexpr bool
      operator()(_Tp* __x, _Tp* __y) const noexcept
      {

 if (std::__is_constant_evaluated())
   return __x > __y;

 return (long unsigned int)__x > (long unsigned int)__y;
      }
    };


  template<typename _Tp>
    struct less<_Tp*> : public binary_function<_Tp*, _Tp*, bool>
    {
      constexpr bool
      operator()(_Tp* __x, _Tp* __y) const noexcept
      {

 if (std::__is_constant_evaluated())
   return __x < __y;

 return (long unsigned int)__x < (long unsigned int)__y;
      }
    };


  template<typename _Tp>
    struct greater_equal<_Tp*> : public binary_function<_Tp*, _Tp*, bool>
    {
      constexpr bool
      operator()(_Tp* __x, _Tp* __y) const noexcept
      {

 if (std::__is_constant_evaluated())
   return __x >= __y;

 return (long unsigned int)__x >= (long unsigned int)__y;
      }
    };


  template<typename _Tp>
    struct less_equal<_Tp*> : public binary_function<_Tp*, _Tp*, bool>
    {
      constexpr bool
      operator()(_Tp* __x, _Tp* __y) const noexcept
      {

 if (std::__is_constant_evaluated())
   return __x <= __y;

 return (long unsigned int)__x <= (long unsigned int)__y;
      }
    };
#pragma GCC diagnostic pop



  template<>
    struct equal_to<void>
    {
      template <typename _Tp, typename _Up>
 constexpr auto
 operator()(_Tp&& __t, _Up&& __u) const
 noexcept(noexcept(std::forward<_Tp>(__t) == std::forward<_Up>(__u)))
 -> decltype(std::forward<_Tp>(__t) == std::forward<_Up>(__u))
 { return std::forward<_Tp>(__t) == std::forward<_Up>(__u); }

      typedef __is_transparent is_transparent;
    };


  template<>
    struct not_equal_to<void>
    {
      template <typename _Tp, typename _Up>
 constexpr auto
 operator()(_Tp&& __t, _Up&& __u) const
 noexcept(noexcept(std::forward<_Tp>(__t) != std::forward<_Up>(__u)))
 -> decltype(std::forward<_Tp>(__t) != std::forward<_Up>(__u))
 { return std::forward<_Tp>(__t) != std::forward<_Up>(__u); }

      typedef __is_transparent is_transparent;
    };


  template<>
    struct greater<void>
    {
      template <typename _Tp, typename _Up>
 constexpr auto
 operator()(_Tp&& __t, _Up&& __u) const
 noexcept(noexcept(std::forward<_Tp>(__t) > std::forward<_Up>(__u)))
 -> decltype(std::forward<_Tp>(__t) > std::forward<_Up>(__u))
 {
   return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u),
   __ptr_cmp<_Tp, _Up>{});
 }

      template<typename _Tp, typename _Up>
 constexpr bool
 operator()(_Tp* __t, _Up* __u) const noexcept
 { return greater<common_type_t<_Tp*, _Up*>>{}(__t, __u); }

      typedef __is_transparent is_transparent;

    private:
      template <typename _Tp, typename _Up>
 static constexpr decltype(auto)
 _S_cmp(_Tp&& __t, _Up&& __u, false_type)
 { return std::forward<_Tp>(__t) > std::forward<_Up>(__u); }

      template <typename _Tp, typename _Up>
 static constexpr bool
 _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept
 {
   return greater<const volatile void*>{}(
       static_cast<const volatile void*>(std::forward<_Tp>(__t)),
       static_cast<const volatile void*>(std::forward<_Up>(__u)));
 }


      template<typename _Tp, typename _Up, typename = void>
 struct __not_overloaded2 : true_type { };


      template<typename _Tp, typename _Up>
 struct __not_overloaded2<_Tp, _Up, __void_t<
   decltype(std::declval<_Tp>().operator>(std::declval<_Up>()))>>
 : false_type { };


      template<typename _Tp, typename _Up, typename = void>
 struct __not_overloaded : __not_overloaded2<_Tp, _Up> { };


      template<typename _Tp, typename _Up>
 struct __not_overloaded<_Tp, _Up, __void_t<
   decltype(operator>(std::declval<_Tp>(), std::declval<_Up>()))>>
 : false_type { };

      template<typename _Tp, typename _Up>
 using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>,
       is_convertible<_Tp, const volatile void*>,
       is_convertible<_Up, const volatile void*>>;
    };


  template<>
    struct less<void>
    {
      template <typename _Tp, typename _Up>
 constexpr auto
 operator()(_Tp&& __t, _Up&& __u) const
 noexcept(noexcept(std::forward<_Tp>(__t) < std::forward<_Up>(__u)))
 -> decltype(std::forward<_Tp>(__t) < std::forward<_Up>(__u))
 {
   return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u),
   __ptr_cmp<_Tp, _Up>{});
 }

      template<typename _Tp, typename _Up>
 constexpr bool
 operator()(_Tp* __t, _Up* __u) const noexcept
 { return less<common_type_t<_Tp*, _Up*>>{}(__t, __u); }

      typedef __is_transparent is_transparent;

    private:
      template <typename _Tp, typename _Up>
 static constexpr decltype(auto)
 _S_cmp(_Tp&& __t, _Up&& __u, false_type)
 { return std::forward<_Tp>(__t) < std::forward<_Up>(__u); }

      template <typename _Tp, typename _Up>
 static constexpr bool
 _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept
 {
   return less<const volatile void*>{}(
       static_cast<const volatile void*>(std::forward<_Tp>(__t)),
       static_cast<const volatile void*>(std::forward<_Up>(__u)));
 }


      template<typename _Tp, typename _Up, typename = void>
 struct __not_overloaded2 : true_type { };


      template<typename _Tp, typename _Up>
 struct __not_overloaded2<_Tp, _Up, __void_t<
   decltype(std::declval<_Tp>().operator<(std::declval<_Up>()))>>
 : false_type { };


      template<typename _Tp, typename _Up, typename = void>
 struct __not_overloaded : __not_overloaded2<_Tp, _Up> { };


      template<typename _Tp, typename _Up>
 struct __not_overloaded<_Tp, _Up, __void_t<
   decltype(operator<(std::declval<_Tp>(), std::declval<_Up>()))>>
 : false_type { };

      template<typename _Tp, typename _Up>
 using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>,
       is_convertible<_Tp, const volatile void*>,
       is_convertible<_Up, const volatile void*>>;
    };


  template<>
    struct greater_equal<void>
    {
      template <typename _Tp, typename _Up>
 constexpr auto
 operator()(_Tp&& __t, _Up&& __u) const
 noexcept(noexcept(std::forward<_Tp>(__t) >= std::forward<_Up>(__u)))
 -> decltype(std::forward<_Tp>(__t) >= std::forward<_Up>(__u))
 {
   return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u),
   __ptr_cmp<_Tp, _Up>{});
 }

      template<typename _Tp, typename _Up>
 constexpr bool
 operator()(_Tp* __t, _Up* __u) const noexcept
 { return greater_equal<common_type_t<_Tp*, _Up*>>{}(__t, __u); }

      typedef __is_transparent is_transparent;

    private:
      template <typename _Tp, typename _Up>
 static constexpr decltype(auto)
 _S_cmp(_Tp&& __t, _Up&& __u, false_type)
 { return std::forward<_Tp>(__t) >= std::forward<_Up>(__u); }

      template <typename _Tp, typename _Up>
 static constexpr bool
 _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept
 {
   return greater_equal<const volatile void*>{}(
       static_cast<const volatile void*>(std::forward<_Tp>(__t)),
       static_cast<const volatile void*>(std::forward<_Up>(__u)));
 }


      template<typename _Tp, typename _Up, typename = void>
 struct __not_overloaded2 : true_type { };


      template<typename _Tp, typename _Up>
 struct __not_overloaded2<_Tp, _Up, __void_t<
   decltype(std::declval<_Tp>().operator>=(std::declval<_Up>()))>>
 : false_type { };


      template<typename _Tp, typename _Up, typename = void>
 struct __not_overloaded : __not_overloaded2<_Tp, _Up> { };


      template<typename _Tp, typename _Up>
 struct __not_overloaded<_Tp, _Up, __void_t<
   decltype(operator>=(std::declval<_Tp>(), std::declval<_Up>()))>>
 : false_type { };

      template<typename _Tp, typename _Up>
 using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>,
       is_convertible<_Tp, const volatile void*>,
       is_convertible<_Up, const volatile void*>>;
    };


  template<>
    struct less_equal<void>
    {
      template <typename _Tp, typename _Up>
 constexpr auto
 operator()(_Tp&& __t, _Up&& __u) const
 noexcept(noexcept(std::forward<_Tp>(__t) <= std::forward<_Up>(__u)))
 -> decltype(std::forward<_Tp>(__t) <= std::forward<_Up>(__u))
 {
   return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u),
   __ptr_cmp<_Tp, _Up>{});
 }

      template<typename _Tp, typename _Up>
 constexpr bool
 operator()(_Tp* __t, _Up* __u) const noexcept
 { return less_equal<common_type_t<_Tp*, _Up*>>{}(__t, __u); }

      typedef __is_transparent is_transparent;

    private:
      template <typename _Tp, typename _Up>
 static constexpr decltype(auto)
 _S_cmp(_Tp&& __t, _Up&& __u, false_type)
 { return std::forward<_Tp>(__t) <= std::forward<_Up>(__u); }

      template <typename _Tp, typename _Up>
 static constexpr bool
 _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept
 {
   return less_equal<const volatile void*>{}(
       static_cast<const volatile void*>(std::forward<_Tp>(__t)),
       static_cast<const volatile void*>(std::forward<_Up>(__u)));
 }


      template<typename _Tp, typename _Up, typename = void>
 struct __not_overloaded2 : true_type { };


      template<typename _Tp, typename _Up>
 struct __not_overloaded2<_Tp, _Up, __void_t<
   decltype(std::declval<_Tp>().operator<=(std::declval<_Up>()))>>
 : false_type { };


      template<typename _Tp, typename _Up, typename = void>
 struct __not_overloaded : __not_overloaded2<_Tp, _Up> { };


      template<typename _Tp, typename _Up>
 struct __not_overloaded<_Tp, _Up, __void_t<
   decltype(operator<=(std::declval<_Tp>(), std::declval<_Up>()))>>
 : false_type { };

      template<typename _Tp, typename _Up>
 using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>,
       is_convertible<_Tp, const volatile void*>,
       is_convertible<_Up, const volatile void*>>;
    };
# 778 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_function.h" 3
  template<typename _Tp = void>
    struct logical_and;

  template<typename _Tp = void>
    struct logical_or;

  template<typename _Tp = void>
    struct logical_not;


#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"


  template<typename _Tp>
    struct logical_and : public binary_function<_Tp, _Tp, bool>
    {
      constexpr
      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x && __y; }
    };


  template<typename _Tp>
    struct logical_or : public binary_function<_Tp, _Tp, bool>
    {
      constexpr
      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x || __y; }
    };


  template<typename _Tp>
    struct logical_not : public unary_function<_Tp, bool>
    {
      constexpr
      bool
      operator()(const _Tp& __x) const
      { return !__x; }
    };
#pragma GCC diagnostic pop



  template<>
    struct logical_and<void>
    {
      template <typename _Tp, typename _Up>
 constexpr
 auto
 operator()(_Tp&& __t, _Up&& __u) const
 noexcept(noexcept(std::forward<_Tp>(__t) && std::forward<_Up>(__u)))
 -> decltype(std::forward<_Tp>(__t) && std::forward<_Up>(__u))
 { return std::forward<_Tp>(__t) && std::forward<_Up>(__u); }

      typedef __is_transparent is_transparent;
    };


  template<>
    struct logical_or<void>
    {
      template <typename _Tp, typename _Up>
 constexpr
 auto
 operator()(_Tp&& __t, _Up&& __u) const
 noexcept(noexcept(std::forward<_Tp>(__t) || std::forward<_Up>(__u)))
 -> decltype(std::forward<_Tp>(__t) || std::forward<_Up>(__u))
 { return std::forward<_Tp>(__t) || std::forward<_Up>(__u); }

      typedef __is_transparent is_transparent;
    };


  template<>
    struct logical_not<void>
    {
      template <typename _Tp>
 constexpr
 auto
 operator()(_Tp&& __t) const
 noexcept(noexcept(!std::forward<_Tp>(__t)))
 -> decltype(!std::forward<_Tp>(__t))
 { return !std::forward<_Tp>(__t); }

      typedef __is_transparent is_transparent;
    };




  template<typename _Tp = void>
    struct bit_and;

  template<typename _Tp = void>
    struct bit_or;

  template<typename _Tp = void>
    struct bit_xor;

  template<typename _Tp = void>
    struct bit_not;


#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"



  template<typename _Tp>
    struct bit_and : public binary_function<_Tp, _Tp, _Tp>
    {
      constexpr
      _Tp
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x & __y; }
    };

  template<typename _Tp>
    struct bit_or : public binary_function<_Tp, _Tp, _Tp>
    {
      constexpr
      _Tp
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x | __y; }
    };

  template<typename _Tp>
    struct bit_xor : public binary_function<_Tp, _Tp, _Tp>
    {
      constexpr
      _Tp
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x ^ __y; }
    };

  template<typename _Tp>
    struct bit_not : public unary_function<_Tp, _Tp>
    {
    constexpr
      _Tp
      operator()(const _Tp& __x) const
      { return ~__x; }
    };
#pragma GCC diagnostic pop


  template <>
    struct bit_and<void>
    {
      template <typename _Tp, typename _Up>
 constexpr
 auto
 operator()(_Tp&& __t, _Up&& __u) const
 noexcept(noexcept(std::forward<_Tp>(__t) & std::forward<_Up>(__u)))
 -> decltype(std::forward<_Tp>(__t) & std::forward<_Up>(__u))
 { return std::forward<_Tp>(__t) & std::forward<_Up>(__u); }

      typedef __is_transparent is_transparent;
    };

  template <>
    struct bit_or<void>
    {
      template <typename _Tp, typename _Up>
 constexpr
 auto
 operator()(_Tp&& __t, _Up&& __u) const
 noexcept(noexcept(std::forward<_Tp>(__t) | std::forward<_Up>(__u)))
 -> decltype(std::forward<_Tp>(__t) | std::forward<_Up>(__u))
 { return std::forward<_Tp>(__t) | std::forward<_Up>(__u); }

      typedef __is_transparent is_transparent;
    };

  template <>
    struct bit_xor<void>
    {
      template <typename _Tp, typename _Up>
 constexpr
 auto
 operator()(_Tp&& __t, _Up&& __u) const
 noexcept(noexcept(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u)))
 -> decltype(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u))
 { return std::forward<_Tp>(__t) ^ std::forward<_Up>(__u); }

      typedef __is_transparent is_transparent;
    };

  template <>
    struct bit_not<void>
    {
      template <typename _Tp>
 constexpr
 auto
 operator()(_Tp&& __t) const
 noexcept(noexcept(~std::forward<_Tp>(__t)))
 -> decltype(~std::forward<_Tp>(__t))
 { return ~std::forward<_Tp>(__t); }

      typedef __is_transparent is_transparent;
    };


#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
# 1020 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_function.h" 3
  template<typename _Predicate>
    class [[__deprecated__]] unary_negate
    : public unary_function<typename _Predicate::argument_type, bool>
    {
    protected:
      _Predicate _M_pred;

    public:
      constexpr
      explicit
      unary_negate(const _Predicate& __x) : _M_pred(__x) { }

      constexpr
      bool
      operator()(const typename _Predicate::argument_type& __x) const
      { return !_M_pred(__x); }
    };


  template<typename _Predicate>
    __attribute__ ((__deprecated__ ("use '" "std::not_fn" "' instead")))
    constexpr
    inline unary_negate<_Predicate>
    not1(const _Predicate& __pred)
    { return unary_negate<_Predicate>(__pred); }


  template<typename _Predicate>
    class [[__deprecated__]] binary_negate
    : public binary_function<typename _Predicate::first_argument_type,
        typename _Predicate::second_argument_type, bool>
    {
    protected:
      _Predicate _M_pred;

    public:
      constexpr
      explicit
      binary_negate(const _Predicate& __x) : _M_pred(__x) { }

      constexpr
      bool
      operator()(const typename _Predicate::first_argument_type& __x,
   const typename _Predicate::second_argument_type& __y) const
      { return !_M_pred(__x, __y); }
    };


  template<typename _Predicate>
    __attribute__ ((__deprecated__ ("use '" "std::not_fn" "' instead")))
    constexpr
    inline binary_negate<_Predicate>
    not2(const _Predicate& __pred)
    { return binary_negate<_Predicate>(__pred); }
# 1101 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_function.h" 3
  template<typename _Arg, typename _Result>
    class pointer_to_unary_function : public unary_function<_Arg, _Result>
    {
    protected:
      _Result (*_M_ptr)(_Arg);

    public:
      pointer_to_unary_function() { }

      explicit
      pointer_to_unary_function(_Result (*__x)(_Arg))
      : _M_ptr(__x) { }

      _Result
      operator()(_Arg __x) const
      { return _M_ptr(__x); }
    } __attribute__ ((__deprecated__));


  template<typename _Arg, typename _Result>
    __attribute__ ((__deprecated__ ("use '" "std::function" "' instead")))
    inline pointer_to_unary_function<_Arg, _Result>
    ptr_fun(_Result (*__x)(_Arg))
    { return pointer_to_unary_function<_Arg, _Result>(__x); }


  template<typename _Arg1, typename _Arg2, typename _Result>
    class pointer_to_binary_function
    : public binary_function<_Arg1, _Arg2, _Result>
    {
    protected:
      _Result (*_M_ptr)(_Arg1, _Arg2);

    public:
      pointer_to_binary_function() { }

      explicit
      pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2))
      : _M_ptr(__x) { }

      _Result
      operator()(_Arg1 __x, _Arg2 __y) const
      { return _M_ptr(__x, __y); }
    } __attribute__ ((__deprecated__));


  template<typename _Arg1, typename _Arg2, typename _Result>
    __attribute__ ((__deprecated__ ("use '" "std::function" "' instead")))
    inline pointer_to_binary_function<_Arg1, _Arg2, _Result>
    ptr_fun(_Result (*__x)(_Arg1, _Arg2))
    { return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); }


  template<typename _Tp>
    struct _Identity
    : public unary_function<_Tp, _Tp>
    {
      _Tp&
      operator()(_Tp& __x) const
      { return __x; }

      const _Tp&
      operator()(const _Tp& __x) const
      { return __x; }
    };


  template<typename _Tp> struct _Identity<const _Tp> : _Identity<_Tp> { };

  template<typename _Pair>
    struct _Select1st
    : public unary_function<_Pair, typename _Pair::first_type>
    {
      typename _Pair::first_type&
      operator()(_Pair& __x) const
      { return __x.first; }

      const typename _Pair::first_type&
      operator()(const _Pair& __x) const
      { return __x.first; }


      template<typename _Pair2>
        typename _Pair2::first_type&
        operator()(_Pair2& __x) const
        { return __x.first; }

      template<typename _Pair2>
        const typename _Pair2::first_type&
        operator()(const _Pair2& __x) const
        { return __x.first; }

    };

  template<typename _Pair>
    struct _Select2nd
    : public unary_function<_Pair, typename _Pair::second_type>
    {
      typename _Pair::second_type&
      operator()(_Pair& __x) const
      { return __x.second; }

      const typename _Pair::second_type&
      operator()(const _Pair& __x) const
      { return __x.second; }
    };
# 1228 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_function.h" 3
  template<typename _Ret, typename _Tp>
    class mem_fun_t : public unary_function<_Tp*, _Ret>
    {
    public:
      explicit
      mem_fun_t(_Ret (_Tp::*__pf)())
      : _M_f(__pf) { }

      _Ret
      operator()(_Tp* __p) const
      { return (__p->*_M_f)(); }

    private:
      _Ret (_Tp::*_M_f)();
    } __attribute__ ((__deprecated__));


  template<typename _Ret, typename _Tp>
    class const_mem_fun_t : public unary_function<const _Tp*, _Ret>
    {
    public:
      explicit
      const_mem_fun_t(_Ret (_Tp::*__pf)() const)
      : _M_f(__pf) { }

      _Ret
      operator()(const _Tp* __p) const
      { return (__p->*_M_f)(); }

    private:
      _Ret (_Tp::*_M_f)() const;
    } __attribute__ ((__deprecated__));


  template<typename _Ret, typename _Tp>
    class mem_fun_ref_t : public unary_function<_Tp, _Ret>
    {
    public:
      explicit
      mem_fun_ref_t(_Ret (_Tp::*__pf)())
      : _M_f(__pf) { }

      _Ret
      operator()(_Tp& __r) const
      { return (__r.*_M_f)(); }

    private:
      _Ret (_Tp::*_M_f)();
    } __attribute__ ((__deprecated__));


  template<typename _Ret, typename _Tp>
    class const_mem_fun_ref_t : public unary_function<_Tp, _Ret>
    {
    public:
      explicit
      const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const)
      : _M_f(__pf) { }

      _Ret
      operator()(const _Tp& __r) const
      { return (__r.*_M_f)(); }

    private:
      _Ret (_Tp::*_M_f)() const;
    } __attribute__ ((__deprecated__));


  template<typename _Ret, typename _Tp, typename _Arg>
    class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret>
    {
    public:
      explicit
      mem_fun1_t(_Ret (_Tp::*__pf)(_Arg))
      : _M_f(__pf) { }

      _Ret
      operator()(_Tp* __p, _Arg __x) const
      { return (__p->*_M_f)(__x); }

    private:
      _Ret (_Tp::*_M_f)(_Arg);
    } __attribute__ ((__deprecated__));


  template<typename _Ret, typename _Tp, typename _Arg>
    class const_mem_fun1_t : public binary_function<const _Tp*, _Arg, _Ret>
    {
    public:
      explicit
      const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const)
      : _M_f(__pf) { }

      _Ret
      operator()(const _Tp* __p, _Arg __x) const
      { return (__p->*_M_f)(__x); }

    private:
      _Ret (_Tp::*_M_f)(_Arg) const;
    } __attribute__ ((__deprecated__));


  template<typename _Ret, typename _Tp, typename _Arg>
    class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
    {
    public:
      explicit
      mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg))
      : _M_f(__pf) { }

      _Ret
      operator()(_Tp& __r, _Arg __x) const
      { return (__r.*_M_f)(__x); }

    private:
      _Ret (_Tp::*_M_f)(_Arg);
    } __attribute__ ((__deprecated__));


  template<typename _Ret, typename _Tp, typename _Arg>
    class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
    {
    public:
      explicit
      const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const)
      : _M_f(__pf) { }

      _Ret
      operator()(const _Tp& __r, _Arg __x) const
      { return (__r.*_M_f)(__x); }

    private:
      _Ret (_Tp::*_M_f)(_Arg) const;
    } __attribute__ ((__deprecated__));



  template<typename _Ret, typename _Tp>
    __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead")))
    inline mem_fun_t<_Ret, _Tp>
    mem_fun(_Ret (_Tp::*__f)())
    { return mem_fun_t<_Ret, _Tp>(__f); }

  template<typename _Ret, typename _Tp>
    __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead")))
    inline const_mem_fun_t<_Ret, _Tp>
    mem_fun(_Ret (_Tp::*__f)() const)
    { return const_mem_fun_t<_Ret, _Tp>(__f); }

  template<typename _Ret, typename _Tp>
    __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead")))
    inline mem_fun_ref_t<_Ret, _Tp>
    mem_fun_ref(_Ret (_Tp::*__f)())
    { return mem_fun_ref_t<_Ret, _Tp>(__f); }

  template<typename _Ret, typename _Tp>
    __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead")))
    inline const_mem_fun_ref_t<_Ret, _Tp>
    mem_fun_ref(_Ret (_Tp::*__f)() const)
    { return const_mem_fun_ref_t<_Ret, _Tp>(__f); }

  template<typename _Ret, typename _Tp, typename _Arg>
    __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead")))
    inline mem_fun1_t<_Ret, _Tp, _Arg>
    mem_fun(_Ret (_Tp::*__f)(_Arg))
    { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); }

  template<typename _Ret, typename _Tp, typename _Arg>
    __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead")))
    inline const_mem_fun1_t<_Ret, _Tp, _Arg>
    mem_fun(_Ret (_Tp::*__f)(_Arg) const)
    { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); }

  template<typename _Ret, typename _Tp, typename _Arg>
    __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead")))
    inline mem_fun1_ref_t<_Ret, _Tp, _Arg>
    mem_fun_ref(_Ret (_Tp::*__f)(_Arg))
    { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }

  template<typename _Ret, typename _Tp, typename _Arg>
    __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead")))
    inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg>
    mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const)
    { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
#pragma GCC diagnostic pop




  template<typename _Func, typename _SfinaeType, typename = __void_t<>>
    struct __has_is_transparent
    { };

  template<typename _Func, typename _SfinaeType>
    struct __has_is_transparent<_Func, _SfinaeType,
    __void_t<typename _Func::is_transparent>>
    { typedef void type; };

  template<typename _Func, typename _SfinaeType>
    using __has_is_transparent_t
      = typename __has_is_transparent<_Func, _SfinaeType>::type;



}


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/backward/binders.h" 1 3
# 60 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/backward/binders.h" 3
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"

namespace std __attribute__ ((__visibility__ ("default")))
{
# 107 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/backward/binders.h" 3
  template<typename _Operation>
    class binder1st
    : public unary_function<typename _Operation::second_argument_type,
       typename _Operation::result_type>
    {
    protected:
      _Operation op;
      typename _Operation::first_argument_type value;

    public:
      binder1st(const _Operation& __x,
  const typename _Operation::first_argument_type& __y)
      : op(__x), value(__y) { }

      typename _Operation::result_type
      operator()(const typename _Operation::second_argument_type& __x) const
      { return op(value, __x); }



      typename _Operation::result_type
      operator()(typename _Operation::second_argument_type& __x) const
      { return op(value, __x); }
    } __attribute__ ((__deprecated__ ("use '" "std::bind" "' instead")));


  template<typename _Operation, typename _Tp>
    __attribute__ ((__deprecated__ ("use '" "std::bind" "' instead")))
    inline binder1st<_Operation>
    bind1st(const _Operation& __fn, const _Tp& __x)
    {
      typedef typename _Operation::first_argument_type _Arg1_type;
      return binder1st<_Operation>(__fn, _Arg1_type(__x));
    }


  template<typename _Operation>
    class binder2nd
    : public unary_function<typename _Operation::first_argument_type,
       typename _Operation::result_type>
    {
    protected:
      _Operation op;
      typename _Operation::second_argument_type value;

    public:
      binder2nd(const _Operation& __x,
  const typename _Operation::second_argument_type& __y)
      : op(__x), value(__y) { }

      typename _Operation::result_type
      operator()(const typename _Operation::first_argument_type& __x) const
      { return op(__x, value); }



      typename _Operation::result_type
      operator()(typename _Operation::first_argument_type& __x) const
      { return op(__x, value); }
    } __attribute__ ((__deprecated__ ("use '" "std::bind" "' instead")));


  template<typename _Operation, typename _Tp>
    __attribute__ ((__deprecated__ ("use '" "std::bind" "' instead")))
    inline binder2nd<_Operation>
    bind2nd(const _Operation& __fn, const _Tp& __x)
    {
      typedef typename _Operation::second_argument_type _Arg2_type;
      return binder2nd<_Operation>(__fn, _Arg2_type(__x));
    }



}

#pragma GCC diagnostic pop
# 1436 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_function.h" 2 3
# 38 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/hashtable.h" 2 3

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/node_handle.h" 1 3
# 35 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/node_handle.h" 3

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 37 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/node_handle.h" 2 3







namespace std __attribute__ ((__visibility__ ("default")))
{
# 64 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/node_handle.h" 3
  template<typename _Val, typename _NodeAlloc>
    class _Node_handle_common
    {
      using _AllocTraits = allocator_traits<_NodeAlloc>;

    public:
      using allocator_type = __alloc_rebind<_NodeAlloc, _Val>;

      allocator_type
      get_allocator() const noexcept
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(!this->empty()), false)) std::__glibcxx_assert_fail(); } while (false);
 return allocator_type(_M_alloc._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() { }

      ~_Node_handle_common()
      {
 if (!empty())
   _M_reset();
      }

      _Node_handle_common(_Node_handle_common&& __nh) noexcept
      : _M_ptr(__nh._M_ptr)
      {
 if (_M_ptr)
   _M_move(std::move(__nh));
      }

      _Node_handle_common&
      operator=(_Node_handle_common&& __nh) noexcept
      {
 if (empty())
   {
     if (!__nh.empty())
       _M_move(std::move(__nh));
   }
 else if (__nh.empty())
   _M_reset();
 else
   {

     _AllocTraits::destroy(*_M_alloc, _M_ptr->_M_valptr());
     _AllocTraits::deallocate(*_M_alloc, _M_ptr, 1);

     _M_alloc = __nh._M_alloc.release();
     _M_ptr = __nh._M_ptr;
     __nh._M_ptr = nullptr;
   }
 return *this;
      }

      _Node_handle_common(typename _AllocTraits::pointer __ptr,
     const _NodeAlloc& __alloc)
      : _M_ptr(__ptr), _M_alloc(__alloc)
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__ptr != nullptr), false)) std::__glibcxx_assert_fail(); } while (false);
      }

      void
      _M_swap(_Node_handle_common& __nh) noexcept
      {
 if (empty())
   {
     if (!__nh.empty())
       _M_move(std::move(__nh));
   }
 else if (__nh.empty())
   __nh._M_move(std::move(*this));
 else
   {
     using std::swap;
     swap(_M_ptr, __nh._M_ptr);
     _M_alloc.swap(__nh._M_alloc);
   }
      }

    private:



      void
      _M_move(_Node_handle_common&& __nh) noexcept
      {
 ::new (std::__addressof(_M_alloc)) _NodeAlloc(__nh._M_alloc.release());
 _M_ptr = __nh._M_ptr;
 __nh._M_ptr = nullptr;
      }




      void
      _M_reset() noexcept
      {
 _NodeAlloc __alloc = _M_alloc.release();
 _AllocTraits::destroy(__alloc, _M_ptr->_M_valptr());
 _AllocTraits::deallocate(__alloc, _M_ptr, 1);
 _M_ptr = nullptr;
      }




      void
      release() noexcept
      {
 _M_alloc.release();
 _M_ptr = nullptr;
      }

    protected:
      typename _AllocTraits::pointer _M_ptr;

    private:


      union _Optional_alloc
      {
 _Optional_alloc() { }
 ~_Optional_alloc() { }

 _Optional_alloc(_Optional_alloc&&) = delete;
 _Optional_alloc& operator=(_Optional_alloc&&) = delete;

 _Optional_alloc(const _NodeAlloc& __alloc) noexcept
 : _M_alloc(__alloc)
 { }


 void
 operator=(_NodeAlloc&& __alloc) noexcept
 {
   using _ATr = _AllocTraits;
   if constexpr (_ATr::propagate_on_container_move_assignment::value)
     _M_alloc = std::move(__alloc);
   else if constexpr (!_AllocTraits::is_always_equal::value)
     do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(_M_alloc == __alloc), false)) std::__glibcxx_assert_fail(); } while (false);
 }


 void
 swap(_Optional_alloc& __other) noexcept
 {
   using std::swap;
   if constexpr (_AllocTraits::propagate_on_container_swap::value)
     swap(_M_alloc, __other._M_alloc);
   else if constexpr (!_AllocTraits::is_always_equal::value)
     do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(_M_alloc == __other._M_alloc), false)) std::__glibcxx_assert_fail(); } while (false);
 }


 _NodeAlloc& operator*() noexcept { return _M_alloc; }


 _NodeAlloc release() noexcept
 {
   _NodeAlloc __tmp = std::move(_M_alloc);
   _M_alloc.~_NodeAlloc();
   return __tmp;
 }

 [[__no_unique_address__]] _NodeAlloc _M_alloc;
      };

      [[__no_unique_address__]] _Optional_alloc _M_alloc;

      template<typename _Key2, typename _Value2, typename _KeyOfValue,
        typename _Compare, typename _ValueAlloc>
 friend class _Rb_tree;

      template<typename _Key2, typename _Value2, typename _ValueAlloc,
        typename _ExtractKey, typename _Equal,
        typename _Hash, typename _RangeHash, typename _Unused,
        typename _RehashPolicy, typename _Traits>
 friend class _Hashtable;


    };


  template<typename _Key, typename _Value, typename _NodeAlloc>
    class _Node_handle : public _Node_handle_common<_Value, _NodeAlloc>
    {
    public:
      constexpr _Node_handle() noexcept = default;
      ~_Node_handle() = default;
      _Node_handle(_Node_handle&&) noexcept = default;

      _Node_handle&
      operator=(_Node_handle&&) noexcept = default;

      using key_type = _Key;
      using mapped_type = typename _Value::second_type;

      key_type&
      key() const noexcept
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(!this->empty()), false)) std::__glibcxx_assert_fail(); } while (false);
 return *_M_pkey;
      }

      mapped_type&
      mapped() const noexcept
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(!this->empty()), false)) std::__glibcxx_assert_fail(); } while (false);
 return *_M_pmapped;
      }

      void
      swap(_Node_handle& __nh) noexcept
      {
 this->_M_swap(__nh);
 using std::swap;
 swap(_M_pkey, __nh._M_pkey);
 swap(_M_pmapped, __nh._M_pmapped);
      }

      friend void
      swap(_Node_handle& __x, _Node_handle& __y)
      noexcept(noexcept(__x.swap(__y)))
      { __x.swap(__y); }

    private:
      using _AllocTraits = allocator_traits<_NodeAlloc>;

      _Node_handle(typename _AllocTraits::pointer __ptr,
     const _NodeAlloc& __alloc)
      : _Node_handle_common<_Value, _NodeAlloc>(__ptr, __alloc)
      {
 if (__ptr)
   {
     auto& __key = const_cast<_Key&>(__ptr->_M_valptr()->first);
     _M_pkey = _S_pointer_to(__key);
     _M_pmapped = _S_pointer_to(__ptr->_M_valptr()->second);
   }
 else
   {
     _M_pkey = nullptr;
     _M_pmapped = nullptr;
   }
      }

      template<typename _Tp>
 using __pointer
   = __ptr_rebind<typename _AllocTraits::pointer,
    remove_reference_t<_Tp>>;

      __pointer<_Key> _M_pkey = nullptr;
      __pointer<typename _Value::second_type> _M_pmapped = nullptr;

      template<typename _Tp>
 __pointer<_Tp>
 _S_pointer_to(_Tp& __obj)
 { return pointer_traits<__pointer<_Tp>>::pointer_to(__obj); }

      const key_type&
      _M_key() const noexcept { return key(); }

      template<typename _Key2, typename _Value2, typename _KeyOfValue,
        typename _Compare, typename _ValueAlloc>
 friend class _Rb_tree;

      template<typename _Key2, typename _Value2, typename _ValueAlloc,
        typename _ExtractKey, typename _Equal,
        typename _Hash, typename _RangeHash, typename _Unused,
        typename _RehashPolicy, typename _Traits>
 friend class _Hashtable;
    };


  template<typename _Value, typename _NodeAlloc>
    class _Node_handle<_Value, _Value, _NodeAlloc>
    : public _Node_handle_common<_Value, _NodeAlloc>
    {
    public:
      constexpr _Node_handle() noexcept = default;
      ~_Node_handle() = default;
      _Node_handle(_Node_handle&&) noexcept = default;

      _Node_handle&
      operator=(_Node_handle&&) noexcept = default;

      using value_type = _Value;

      value_type&
      value() const noexcept
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(!this->empty()), false)) std::__glibcxx_assert_fail(); } while (false);
 return *this->_M_ptr->_M_valptr();
      }

      void
      swap(_Node_handle& __nh) noexcept
      { this->_M_swap(__nh); }

      friend void
      swap(_Node_handle& __x, _Node_handle& __y)
      noexcept(noexcept(__x.swap(__y)))
      { __x.swap(__y); }

    private:
      using _AllocTraits = allocator_traits<_NodeAlloc>;

      _Node_handle(typename _AllocTraits::pointer __ptr,
     const _NodeAlloc& __alloc)
      : _Node_handle_common<_Value, _NodeAlloc>(__ptr, __alloc) { }

      const value_type&
      _M_key() const noexcept { return value(); }

      template<typename _Key, typename _Val, typename _KeyOfValue,
        typename _Compare, typename _Alloc>
 friend class _Rb_tree;

      template<typename _Key2, typename _Value2, typename _ValueAlloc,
        typename _ExtractKey, typename _Equal,
        typename _Hash, typename _RangeHash, typename _Unused,
        typename _RehashPolicy, typename _Traits>
 friend class _Hashtable;
    };


  template<typename _Iterator, typename _NodeHandle>
    struct _Node_insert_return
    {
      _Iterator position = _Iterator();
      bool inserted = false;
      _NodeHandle node;
    };




}
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/hashtable.h" 2 3


namespace std __attribute__ ((__visibility__ ("default")))
{



  template<typename _Tp, typename _Hash>
    using __cache_default
      = __not_<__and_<
         __is_fast_hash<_Hash>,

         __is_nothrow_invocable<const _Hash&, const _Tp&>>>;




  template<typename _Equal, typename _Hash, typename _Allocator>
    using _Hashtable_enable_default_ctor
      = _Enable_default_constructor<__and_<is_default_constructible<_Equal>,
           is_default_constructible<_Hash>,
           is_default_constructible<_Allocator>>{},
        __detail::_Hash_node_base>;
# 181 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/hashtable.h" 3
  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    class _Hashtable
    : public __detail::_Hashtable_base<_Key, _Value, _ExtractKey, _Equal,
           _Hash, _RangeHash, _Unused, _Traits>,
      public __detail::_Map_base<_Key, _Value, _Alloc, _ExtractKey, _Equal,
     _Hash, _RangeHash, _Unused,
     _RehashPolicy, _Traits>,
      public __detail::_Insert<_Key, _Value, _Alloc, _ExtractKey, _Equal,
          _Hash, _RangeHash, _Unused,
          _RehashPolicy, _Traits>,
      public __detail::_Rehash_base<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused,
        _RehashPolicy, _Traits>,
      public __detail::_Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal,
     _Hash, _RangeHash, _Unused,
     _RehashPolicy, _Traits>,
      private __detail::_Hashtable_alloc<
 __alloc_rebind<_Alloc,
         __detail::_Hash_node<_Value,
         _Traits::__hash_cached::value>>>,
      private _Hashtable_enable_default_ctor<_Equal, _Hash, _Alloc>
    {
      static_assert(is_same<typename remove_cv<_Value>::type, _Value>::value,
   "unordered container must have a non-const, non-volatile value_type");

      static_assert(is_same<typename _Alloc::value_type, _Value>{},
   "unordered container must have the same value_type as its allocator");


      using __traits_type = _Traits;
      using __hash_cached = typename __traits_type::__hash_cached;
      using __constant_iterators = typename __traits_type::__constant_iterators;
      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 __node_value_type =
 __detail::_Hash_node_value<_Value, __hash_cached::value>;
      using __node_ptr = typename __hashtable_alloc::__node_ptr;
      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 __node_base_ptr = typename __hashtable_alloc::__node_base_ptr;
      using __buckets_ptr = typename __hashtable_alloc::__buckets_ptr;

      using __insert_base = __detail::_Insert<_Key, _Value, _Alloc, _ExtractKey,
           _Equal, _Hash,
           _RangeHash, _Unused,
           _RehashPolicy, _Traits>;
      using __enable_default_ctor
 = _Hashtable_enable_default_ctor<_Equal, _Hash, _Alloc>;
      using __rehash_guard_t
 = __detail::_RehashStateGuard<_RehashPolicy>;

    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;

      using iterator = typename __insert_base::iterator;

      using const_iterator = typename __insert_base::const_iterator;

      using local_iterator = __detail::_Local_iterator<key_type, _Value,
   _ExtractKey, _Hash, _RangeHash, _Unused,
          __constant_iterators::value,
          __hash_cached::value>;

      using const_local_iterator = __detail::_Local_const_iterator<
   key_type, _Value,
   _ExtractKey, _Hash, _RangeHash, _Unused,
   __constant_iterators::value, __hash_cached::value>;

    private:
      using __rehash_type = _RehashPolicy;

      using __unique_keys = typename __traits_type::__unique_keys;

      using __hashtable_base = __detail::
 _Hashtable_base<_Key, _Value, _ExtractKey,
   _Equal, _Hash, _RangeHash, _Unused, _Traits>;

      using __hash_code_base = typename __hashtable_base::__hash_code_base;
      using __hash_code = typename __hashtable_base::__hash_code;
      using __ireturn_type = typename __insert_base::__ireturn_type;

      using __map_base = __detail::_Map_base<_Key, _Value, _Alloc, _ExtractKey,
          _Equal, _Hash, _RangeHash, _Unused,
          _RehashPolicy, _Traits>;

      using __rehash_base = __detail::_Rehash_base<_Key, _Value, _Alloc,
         _ExtractKey, _Equal,
         _Hash, _RangeHash, _Unused,
         _RehashPolicy, _Traits>;

      using __eq_base = __detail::_Equality<_Key, _Value, _Alloc, _ExtractKey,
         _Equal, _Hash, _RangeHash, _Unused,
         _RehashPolicy, _Traits>;

      using __reuse_or_alloc_node_gen_t =
 __detail::_ReuseOrAllocNode<__node_alloc_type>;
      using __alloc_node_gen_t =
 __detail::_AllocNode<__node_alloc_type>;
      using __node_builder_t =
 __detail::_NodeBuilder<_ExtractKey>;


      struct _Scoped_node
      {

 _Scoped_node(__node_ptr __n, __hashtable_alloc* __h)
 : _M_h(__h), _M_node(__n) { }


 template<typename... _Args>
   _Scoped_node(__hashtable_alloc* __h, _Args&&... __args)
   : _M_h(__h),
     _M_node(__h->_M_allocate_node(std::forward<_Args>(__args)...))
   { }


 ~_Scoped_node() { if (_M_node) _M_h->_M_deallocate_node(_M_node); };

 _Scoped_node(const _Scoped_node&) = delete;
 _Scoped_node& operator=(const _Scoped_node&) = delete;

 __hashtable_alloc* _M_h;
 __node_ptr _M_node;
      };

      template<typename _Ht>
 static constexpr
 __conditional_t<std::is_lvalue_reference<_Ht>::value,
   const value_type&, value_type&&>
 __fwd_value_for(value_type& __val) noexcept
 { return std::move(__val); }





      struct __hash_code_base_access : __hash_code_base
      { using __hash_code_base::_M_bucket_index; };


      static_assert(is_nothrow_default_constructible<_RangeHash>::value,
      "Functor used to map hash code to bucket index"
      " must be nothrow default constructible");
      static_assert(noexcept(
 std::declval<const _RangeHash&>()((std::size_t)0, (std::size_t)0)),
      "Functor used to map hash code to bucket index must be"
      " noexcept");


      static_assert(is_nothrow_default_constructible<_ExtractKey>::value,
      "_ExtractKey must be nothrow default constructible");
      static_assert(noexcept(
 std::declval<const _ExtractKey&>()(std::declval<_Value>())),
      "_ExtractKey functor must be noexcept invocable");

      template<typename _Keya, typename _Valuea, typename _Alloca,
        typename _ExtractKeya, typename _Equala,
        typename _Hasha, typename _RangeHasha, typename _Unuseda,
        typename _RehashPolicya, typename _Traitsa,
        bool _Unique_keysa>
 friend struct __detail::_Map_base;

      template<typename _Keya, typename _Valuea, typename _Alloca,
        typename _ExtractKeya, typename _Equala,
        typename _Hasha, typename _RangeHasha, typename _Unuseda,
        typename _RehashPolicya, typename _Traitsa>
 friend struct __detail::_Insert_base;

      template<typename _Keya, typename _Valuea, typename _Alloca,
        typename _ExtractKeya, typename _Equala,
        typename _Hasha, typename _RangeHasha, typename _Unuseda,
        typename _RehashPolicya, typename _Traitsa,
        bool _Constant_iteratorsa>
 friend struct __detail::_Insert;

      template<typename _Keya, typename _Valuea, typename _Alloca,
        typename _ExtractKeya, typename _Equala,
        typename _Hasha, typename _RangeHasha, typename _Unuseda,
        typename _RehashPolicya, typename _Traitsa,
        bool _Unique_keysa>
 friend struct __detail::_Equality;

    public:
      using size_type = typename __hashtable_base::size_type;
      using difference_type = typename __hashtable_base::difference_type;


      using node_type = _Node_handle<_Key, _Value, __node_alloc_type>;
      using insert_return_type = _Node_insert_return<iterator, node_type>;


    private:
      __buckets_ptr _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;







      __node_base_ptr _M_single_bucket = nullptr;

      void
      _M_update_bbegin()
      {
 if (auto __begin = _M_begin())
   _M_buckets[_M_bucket_index(*__begin)] = &_M_before_begin;
      }

      void
      _M_update_bbegin(__node_ptr __n)
      {
 _M_before_begin._M_nxt = __n;
 _M_update_bbegin();
      }

      bool
      _M_uses_single_bucket(__buckets_ptr __bkts) const
      { return __builtin_expect(__bkts == &_M_single_bucket, false); }

      bool
      _M_uses_single_bucket() const
      { return _M_uses_single_bucket(_M_buckets); }

      static constexpr size_t
      __small_size_threshold() noexcept
      {
 return
   __detail::_Hashtable_hash_traits<_Hash>::__small_size_threshold();
      }

      __hashtable_alloc&
      _M_base_alloc() { return *this; }

      __buckets_ptr
      _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(__buckets_ptr __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_ptr
      _M_bucket_begin(size_type __bkt) const
      {
 __node_base_ptr __n = _M_buckets[__bkt];
 return __n ? static_cast<__node_ptr>(__n->_M_nxt) : nullptr;
      }

      __node_ptr
      _M_begin() const
      { return static_cast<__node_ptr>(_M_before_begin._M_nxt); }



      template<typename _Ht>
 void
 _M_assign_elements(_Ht&&);

      template<typename _Ht, typename _NodeGenerator>
 void
 _M_assign(_Ht&&, const _NodeGenerator&);

      void
      _M_move_assign(_Hashtable&&, true_type);

      void
      _M_move_assign(_Hashtable&&, false_type);

      void
      _M_reset() noexcept;

      _Hashtable(const _Hash& __h, const _Equal& __eq,
   const allocator_type& __a)
      : __hashtable_base(__h, __eq),
 __hashtable_alloc(__node_alloc_type(__a)),
 __enable_default_ctor(_Enable_default_constructor_tag{})
      { }

      template<bool _No_realloc = true>
 static constexpr bool
 _S_nothrow_move()
 {





   if constexpr (_No_realloc)
     if constexpr (is_nothrow_copy_constructible<_Hash>())
       return is_nothrow_copy_constructible<_Equal>();
   return false;

 }

      _Hashtable(_Hashtable&& __ht, __node_alloc_type&& __a,
   true_type )
 noexcept(_S_nothrow_move());

      _Hashtable(_Hashtable&&, __node_alloc_type&&,
   false_type );

      template<typename _InputIterator>
 _Hashtable(_InputIterator __first, _InputIterator __last,
     size_type __bkt_count_hint,
     const _Hash&, const _Equal&, const allocator_type&,
     true_type __uks);

      template<typename _InputIterator>
 _Hashtable(_InputIterator __first, _InputIterator __last,
     size_type __bkt_count_hint,
     const _Hash&, const _Equal&, const allocator_type&,
     false_type __uks);

    public:

      _Hashtable() = default;

      _Hashtable(const _Hashtable&);

      _Hashtable(const _Hashtable&, const allocator_type&);

      explicit
      _Hashtable(size_type __bkt_count_hint,
   const _Hash& __hf = _Hash(),
   const key_equal& __eql = key_equal(),
   const allocator_type& __a = allocator_type());


      _Hashtable(_Hashtable&& __ht)
 noexcept(_S_nothrow_move())
      : _Hashtable(std::move(__ht), std::move(__ht._M_node_allocator()),
     true_type{})
      { }

      _Hashtable(_Hashtable&& __ht, const allocator_type& __a)
 noexcept(_S_nothrow_move<__node_alloc_traits::_S_always_equal()>())
      : _Hashtable(std::move(__ht), __node_alloc_type(__a),
     typename __node_alloc_traits::is_always_equal{})
      { }

      explicit
      _Hashtable(const allocator_type& __a)
      : __hashtable_alloc(__node_alloc_type(__a)),
 __enable_default_ctor(_Enable_default_constructor_tag{})
      { }

      template<typename _InputIterator>
 _Hashtable(_InputIterator __f, _InputIterator __l,
     size_type __bkt_count_hint = 0,
     const _Hash& __hf = _Hash(),
     const key_equal& __eql = key_equal(),
     const allocator_type& __a = allocator_type())
 : _Hashtable(__f, __l, __bkt_count_hint, __hf, __eql, __a,
       __unique_keys{})
 { }

      _Hashtable(initializer_list<value_type> __l,
   size_type __bkt_count_hint = 0,
   const _Hash& __hf = _Hash(),
   const key_equal& __eql = key_equal(),
   const allocator_type& __a = allocator_type())
      : _Hashtable(__l.begin(), __l.end(), __bkt_count_hint,
     __hf, __eql, __a, __unique_keys{})
      { }

      _Hashtable&
      operator=(const _Hashtable& __ht);

      _Hashtable&
      operator=(_Hashtable&& __ht)
      noexcept(__node_alloc_traits::_S_nothrow_move()
        && is_nothrow_move_assignable<_Hash>::value
        && is_nothrow_move_assignable<_Equal>::value)
      {
 constexpr bool __move_storage =
   __node_alloc_traits::_S_propagate_on_move_assign()
   || __node_alloc_traits::_S_always_equal();
 _M_move_assign(std::move(__ht), __bool_constant<__move_storage>());
 return *this;
      }

      _Hashtable&
      operator=(initializer_list<value_type> __l)
      {
 __reuse_or_alloc_node_gen_t __roan(_M_begin(), *this);
 _M_before_begin._M_nxt = nullptr;
 clear();


 auto __l_bkt_count = _M_rehash_policy._M_bkt_for_elements(__l.size());


 if (_M_bucket_count < __l_bkt_count)
   rehash(__l_bkt_count);

 this->_M_insert_range(__l.begin(), __l.end(), __roan, __unique_keys{});
 return *this;
      }

      ~_Hashtable() noexcept;

      void
      swap(_Hashtable&)
      noexcept(__and_<__is_nothrow_swappable<_Hash>,
        __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(this->_M_hash_code(__k)); }

      local_iterator
      begin(size_type __bkt)
      {
 return local_iterator(*this, _M_bucket_begin(__bkt),
         __bkt, _M_bucket_count);
      }

      local_iterator
      end(size_type __bkt)
      { return local_iterator(*this, nullptr, __bkt, _M_bucket_count); }

      const_local_iterator
      begin(size_type __bkt) const
      {
 return const_local_iterator(*this, _M_bucket_begin(__bkt),
        __bkt, _M_bucket_count);
      }

      const_local_iterator
      end(size_type __bkt) const
      { return const_local_iterator(*this, nullptr, __bkt, _M_bucket_count); }


      const_local_iterator
      cbegin(size_type __bkt) const
      {
 return const_local_iterator(*this, _M_bucket_begin(__bkt),
        __bkt, _M_bucket_count);
      }

      const_local_iterator
      cend(size_type __bkt) const
      { return const_local_iterator(*this, nullptr, __bkt, _M_bucket_count); }

      float
      load_factor() const noexcept
      {
 return static_cast<float>(size()) / static_cast<float>(bucket_count());
      }






      const _RehashPolicy&
      __rehash_policy() const
      { return _M_rehash_policy; }

      void
      __rehash_policy(const _RehashPolicy& __pol)
      { _M_rehash_policy = __pol; }


      iterator
      find(const key_type& __k);

      const_iterator
      find(const key_type& __k) const;

      size_type
      count(const key_type& __k) const;

      std::pair<iterator, iterator>
      equal_range(const key_type& __k);

      std::pair<const_iterator, const_iterator>
      equal_range(const key_type& __k) const;


      template<typename _Kt,
        typename = __has_is_transparent_t<_Hash, _Kt>,
        typename = __has_is_transparent_t<_Equal, _Kt>>
 iterator
 _M_find_tr(const _Kt& __k);

      template<typename _Kt,
        typename = __has_is_transparent_t<_Hash, _Kt>,
        typename = __has_is_transparent_t<_Equal, _Kt>>
 const_iterator
 _M_find_tr(const _Kt& __k) const;

      template<typename _Kt,
        typename = __has_is_transparent_t<_Hash, _Kt>,
        typename = __has_is_transparent_t<_Equal, _Kt>>
 size_type
 _M_count_tr(const _Kt& __k) const;

      template<typename _Kt,
        typename = __has_is_transparent_t<_Hash, _Kt>,
        typename = __has_is_transparent_t<_Equal, _Kt>>
 pair<iterator, iterator>
 _M_equal_range_tr(const _Kt& __k);

      template<typename _Kt,
        typename = __has_is_transparent_t<_Hash, _Kt>,
        typename = __has_is_transparent_t<_Equal, _Kt>>
 pair<const_iterator, const_iterator>
 _M_equal_range_tr(const _Kt& __k) const;


    private:

      size_type
      _M_bucket_index(const __node_value_type& __n) const noexcept
      { return __hash_code_base::_M_bucket_index(__n, _M_bucket_count); }

      size_type
      _M_bucket_index(__hash_code __c) const
      { return __hash_code_base::_M_bucket_index(__c, _M_bucket_count); }

      __node_base_ptr
      _M_find_before_node(const key_type&);



      __node_base_ptr
      _M_find_before_node(size_type, const key_type&, __hash_code) const;

      template<typename _Kt>
 __node_base_ptr
 _M_find_before_node_tr(size_type, const _Kt&, __hash_code) const;

      __node_ptr
      _M_find_node(size_type __bkt, const key_type& __key,
     __hash_code __c) const
      {
 __node_base_ptr __before_n = _M_find_before_node(__bkt, __key, __c);
 if (__before_n)
   return static_cast<__node_ptr>(__before_n->_M_nxt);
 return nullptr;
      }

      template<typename _Kt>
 __node_ptr
 _M_find_node_tr(size_type __bkt, const _Kt& __key,
   __hash_code __c) const
 {
   auto __before_n = _M_find_before_node_tr(__bkt, __key, __c);
   if (__before_n)
     return static_cast<__node_ptr>(__before_n->_M_nxt);
   return nullptr;
 }


      void
      _M_insert_bucket_begin(size_type __bkt, __node_ptr __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;
   }
      }


      void
      _M_remove_bucket_begin(size_type __bkt, __node_ptr __next_n,
        size_type __next_bkt)
      {
 if (!__next_n)
   _M_buckets[__bkt] = nullptr;
 else if (__next_bkt != __bkt)
   {
     _M_buckets[__next_bkt] = _M_buckets[__bkt];
     _M_buckets[__bkt] = nullptr;
   }
      }


      __node_base_ptr
      _M_get_previous_node(size_type __bkt, __node_ptr __n);

      pair<__node_ptr, __hash_code>
      _M_compute_hash_code(__node_ptr __hint, const key_type& __k) const;




      iterator
      _M_insert_unique_node(size_type __bkt, __hash_code,
       __node_ptr __n, size_type __n_elt = 1);



      iterator
      _M_insert_multi_node(__node_ptr __hint,
      __hash_code __code, __node_ptr __n);

      template<typename... _Args>
 std::pair<iterator, bool>
 _M_emplace(true_type __uks, _Args&&... __args);

      template<typename... _Args>
 iterator
 _M_emplace(false_type __uks, _Args&&... __args)
 { return _M_emplace(cend(), __uks, std::forward<_Args>(__args)...); }


      template<typename... _Args>
 iterator
 _M_emplace(const_iterator, true_type __uks, _Args&&... __args)
 { return _M_emplace(__uks, std::forward<_Args>(__args)...).first; }

      template<typename... _Args>
 iterator
 _M_emplace(const_iterator, false_type __uks, _Args&&... __args);

      template<typename _Kt, typename _Arg, typename _NodeGenerator>
 std::pair<iterator, bool>
 _M_insert_unique(_Kt&&, _Arg&&, const _NodeGenerator&);

      template<typename _Kt>
 static __conditional_t<
   __and_<__is_nothrow_invocable<_Hash&, const key_type&>,
   __not_<__is_nothrow_invocable<_Hash&, _Kt>>>::value,
   key_type, _Kt&&>
 _S_forward_key(_Kt&& __k)
 { return std::forward<_Kt>(__k); }

      static const key_type&
      _S_forward_key(const key_type& __k)
      { return __k; }

      static key_type&&
      _S_forward_key(key_type&& __k)
      { return std::move(__k); }

      template<typename _Arg, typename _NodeGenerator>
 std::pair<iterator, bool>
 _M_insert_unique_aux(_Arg&& __arg, const _NodeGenerator& __node_gen)
 {
   return _M_insert_unique(
     _S_forward_key(_ExtractKey{}(std::forward<_Arg>(__arg))),
     std::forward<_Arg>(__arg), __node_gen);
 }

      template<typename _Arg, typename _NodeGenerator>
 std::pair<iterator, bool>
 _M_insert(_Arg&& __arg, const _NodeGenerator& __node_gen,
    true_type )
 {
   using __to_value
     = __detail::_ConvertToValueType<_ExtractKey, value_type>;
   return _M_insert_unique_aux(
     __to_value{}(std::forward<_Arg>(__arg)), __node_gen);
 }

      template<typename _Arg, typename _NodeGenerator>
 iterator
 _M_insert(_Arg&& __arg, const _NodeGenerator& __node_gen,
    false_type __uks)
 {
   using __to_value
     = __detail::_ConvertToValueType<_ExtractKey, value_type>;
   return _M_insert(cend(),
     __to_value{}(std::forward<_Arg>(__arg)), __node_gen, __uks);
 }


      template<typename _Arg, typename _NodeGenerator>
 iterator
 _M_insert(const_iterator, _Arg&& __arg,
    const _NodeGenerator& __node_gen, true_type __uks)
 {
   return
     _M_insert(std::forward<_Arg>(__arg), __node_gen, __uks).first;
 }


      template<typename _Arg, typename _NodeGenerator>
 iterator
 _M_insert(const_iterator, _Arg&&,
    const _NodeGenerator&, false_type __uks);

      size_type
      _M_erase(true_type __uks, const key_type&);

      size_type
      _M_erase(false_type __uks, const key_type&);

      iterator
      _M_erase(size_type __bkt, __node_base_ptr __prev_n, __node_ptr __n);

    public:

      template<typename... _Args>
 __ireturn_type
 emplace(_Args&&... __args)
 { return _M_emplace(__unique_keys{}, std::forward<_Args>(__args)...); }

      template<typename... _Args>
 iterator
 emplace_hint(const_iterator __hint, _Args&&... __args)
 {
   return _M_emplace(__hint, __unique_keys{},
       std::forward<_Args>(__args)...);
 }




      iterator
      erase(const_iterator);


      iterator
      erase(iterator __it)
      { return erase(const_iterator(__it)); }

      size_type
      erase(const key_type& __k)
      { return _M_erase(__unique_keys{}, __k); }

      iterator
      erase(const_iterator, const_iterator);

      void
      clear() noexcept;



      void rehash(size_type __bkt_count);






      insert_return_type
      _M_reinsert_node(node_type&& __nh)
      {
 insert_return_type __ret;
 if (__nh.empty())
   __ret.position = end();
 else
   {
     do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(get_allocator() == __nh.get_allocator()), false)) std::__glibcxx_assert_fail(); } while (false);

     __node_ptr __n = nullptr;
     const key_type& __k = __nh._M_key();
     const size_type __size = size();
     if (__size <= __small_size_threshold())
       {
  for (__n = _M_begin(); __n; __n = __n->_M_next())
    if (this->_M_key_equals(__k, *__n))
      break;
       }

     __hash_code __code;
     size_type __bkt;
     if (!__n)
       {
  __code = this->_M_hash_code(__k);
  __bkt = _M_bucket_index(__code);
  if (__size > __small_size_threshold())
    __n = _M_find_node(__bkt, __k, __code);
       }

     if (__n)
       {
  __ret.node = std::move(__nh);
  __ret.position = iterator(__n);
  __ret.inserted = false;
       }
     else
       {
  __ret.position
    = _M_insert_unique_node(__bkt, __code, __nh._M_ptr);
  __nh.release();
  __ret.inserted = true;
       }
   }
 return __ret;
      }


      iterator
      _M_reinsert_node_multi(const_iterator __hint, node_type&& __nh)
      {
 if (__nh.empty())
   return end();

 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(get_allocator() == __nh.get_allocator()), false)) std::__glibcxx_assert_fail(); } while (false);

 const key_type& __k = __nh._M_key();
 auto __code = this->_M_hash_code(__k);
 auto __ret
   = _M_insert_multi_node(__hint._M_cur, __code, __nh._M_ptr);
 __nh.release();
 return __ret;
      }

    private:
      node_type
      _M_extract_node(size_t __bkt, __node_base_ptr __prev_n)
      {
 __node_ptr __n = static_cast<__node_ptr>(__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() };
      }



      template<typename _H2>
 __hash_code
 _M_src_hash_code(const _H2&, const key_type& __k,
    const __node_value_type& __src_n) const
 {
   if constexpr (std::is_same_v<_H2, _Hash>)
     if constexpr (std::is_empty_v<_Hash>)
       return this->_M_hash_code(__src_n);

   return this->_M_hash_code(__k);
 }

    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(__code);
 if (__node_base_ptr __prev_node = _M_find_before_node(__bkt, __k, __code))
   __nh = _M_extract_node(__bkt, __prev_node);
 return __nh;
      }


      template<typename _Compatible_Hashtable>
 void
 _M_merge_unique(_Compatible_Hashtable& __src)
 {
   static_assert(is_same_v<typename _Compatible_Hashtable::node_type,
       node_type>, "Node types are compatible");
   do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(get_allocator() == __src.get_allocator()), false)) std::__glibcxx_assert_fail(); } while (false);

   auto __n_elt = __src.size();
   for (auto __i = __src.cbegin(), __end = __src.cend(); __i != __end;)
     {
       auto __pos = __i++;
       const size_type __size = size();
       const key_type& __k = _ExtractKey{}(*__pos);
       if (__size <= __small_size_threshold())
  {
    bool __found = false;
    for (auto __n = _M_begin(); __n; __n = __n->_M_next())
      if (this->_M_key_equals(__k, *__n))
        {
   __found = true;
   break;
        }

    if (__found)
      {
        if (__n_elt != 1)
   --__n_elt;
        continue;
      }
  }

       __hash_code __code
  = _M_src_hash_code(__src.hash_function(), __k, *__pos._M_cur);
       size_type __bkt = _M_bucket_index(__code);
       if (__size <= __small_size_threshold()
    || _M_find_node(__bkt, __k, __code) == nullptr)
  {
    auto __nh = __src.extract(__pos);
    _M_insert_unique_node(__bkt, __code, __nh._M_ptr, __n_elt);
    __nh.release();
    __n_elt = 1;
  }
       else if (__n_elt != 1)
  --__n_elt;
     }
 }


      template<typename _Compatible_Hashtable>
 void
 _M_merge_multi(_Compatible_Hashtable& __src)
 {
   static_assert(is_same_v<typename _Compatible_Hashtable::node_type,
       node_type>, "Node types are compatible");
   do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(get_allocator() == __src.get_allocator()), false)) std::__glibcxx_assert_fail(); } while (false);

   __node_ptr __hint = nullptr;
   this->reserve(size() + __src.size());
   for (auto __i = __src.cbegin(), __end = __src.cend(); __i != __end;)
     {
       auto __pos = __i++;
       const key_type& __k = _ExtractKey{}(*__pos);
       __hash_code __code
  = _M_src_hash_code(__src.hash_function(), __k, *__pos._M_cur);
       auto __nh = __src.extract(__pos);
       __hint = _M_insert_multi_node(__hint, __code, __nh._M_ptr)._M_cur;
       __nh.release();
     }
 }


    private:

      void _M_rehash(size_type __bkt_count, true_type __uks);


      void _M_rehash(size_type __bkt_count, false_type __uks);
    };


  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    _Hashtable(size_type __bkt_count_hint,
        const _Hash& __h, const _Equal& __eq, const allocator_type& __a)
    : _Hashtable(__h, __eq, __a)
    {
      auto __bkt_count = _M_rehash_policy._M_next_bkt(__bkt_count_hint);
      if (__bkt_count > _M_bucket_count)
 {
   _M_buckets = _M_allocate_buckets(__bkt_count);
   _M_bucket_count = __bkt_count;
 }
    }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    template<typename _InputIterator>
      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
   _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
      _Hashtable(_InputIterator __f, _InputIterator __l,
   size_type __bkt_count_hint,
   const _Hash& __h, const _Equal& __eq,
   const allocator_type& __a, true_type )
      : _Hashtable(__bkt_count_hint, __h, __eq, __a)
      { this->insert(__f, __l); }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    template<typename _InputIterator>
      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
   _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
      _Hashtable(_InputIterator __f, _InputIterator __l,
   size_type __bkt_count_hint,
   const _Hash& __h, const _Equal& __eq,
   const allocator_type& __a, false_type __uks)
      : _Hashtable(__h, __eq, __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;
   }

 __alloc_node_gen_t __node_gen(*this);
 for (; __f != __l; ++__f)
   _M_insert(*__f, __node_gen, __uks);
      }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    auto
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    operator=(const _Hashtable& __ht)
    -> _Hashtable&
    {
      if (&__ht == this)
 return *this;

      if (__node_alloc_traits::_S_propagate_on_copy_assign())
 {
   auto& __this_alloc = this->_M_node_allocator();
   auto& __that_alloc = __ht._M_node_allocator();
   if (!__node_alloc_traits::_S_always_equal()
       && __this_alloc != __that_alloc)
     {

       this->_M_deallocate_nodes(_M_begin());
       _M_before_begin._M_nxt = nullptr;
       _M_deallocate_buckets();
       _M_buckets = nullptr;
       std::__alloc_on_copy(__this_alloc, __that_alloc);
       __hashtable_base::operator=(__ht);
       _M_bucket_count = __ht._M_bucket_count;
       _M_element_count = __ht._M_element_count;
       _M_rehash_policy = __ht._M_rehash_policy;
       __alloc_node_gen_t __alloc_node_gen(*this);
       try
  {
    _M_assign(__ht, __alloc_node_gen);
  }
       catch(...)
  {


    _M_reset();
    throw;
  }
       return *this;
     }
   std::__alloc_on_copy(__this_alloc, __that_alloc);
 }


      _M_assign_elements(__ht);
      return *this;
    }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    template<typename _Ht>
      void
      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
   _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
      _M_assign_elements(_Ht&& __ht)
      {
 __buckets_ptr __former_buckets = nullptr;
 std::size_t __former_bucket_count = _M_bucket_count;
 __rehash_guard_t __rehash_guard(_M_rehash_policy);

 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(__node_base_ptr));

 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);
     __rehash_guard._M_guarded_obj = nullptr;
   }
 catch(...)
   {
     if (__former_buckets)
       {

  _M_deallocate_buckets();
  _M_buckets = __former_buckets;
  _M_bucket_count = __former_bucket_count;
       }
     __builtin_memset(_M_buckets, 0,
        _M_bucket_count * sizeof(__node_base_ptr));
     throw;
   }
      }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    template<typename _Ht, typename _NodeGenerator>
      void
      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
   _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
      _M_assign(_Ht&& __ht, const _NodeGenerator& __node_gen)
      {
 __buckets_ptr __buckets = nullptr;
 if (!_M_buckets)
   _M_buckets = __buckets = _M_allocate_buckets(_M_bucket_count);

 try
   {
     if (!__ht._M_before_begin._M_nxt)
       return;



     __node_ptr __ht_n = __ht._M_begin();
     __node_ptr __this_n
       = __node_gen(__fwd_value_for<_Ht>(__ht_n->_M_v()));
     this->_M_copy_code(*__this_n, *__ht_n);
     _M_update_bbegin(__this_n);


     __node_ptr __prev_n = __this_n;
     for (__ht_n = __ht_n->_M_next(); __ht_n; __ht_n = __ht_n->_M_next())
       {
  __this_n = __node_gen(__fwd_value_for<_Ht>(__ht_n->_M_v()));
  __prev_n->_M_nxt = __this_n;
  this->_M_copy_code(*__this_n, *__ht_n);
  size_type __bkt = _M_bucket_index(*__this_n);
  if (!_M_buckets[__bkt])
    _M_buckets[__bkt] = __prev_n;
  __prev_n = __this_n;
       }
   }
 catch(...)
   {
     clear();
     if (__buckets)
       _M_deallocate_buckets();
     throw;
   }
      }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    void
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    _M_reset() noexcept
    {
      _M_rehash_policy._M_reset();
      _M_bucket_count = 1;
      _M_single_bucket = nullptr;
      _M_buckets = &_M_single_bucket;
      _M_before_begin._M_nxt = nullptr;
      _M_element_count = 0;
    }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    void
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    _M_move_assign(_Hashtable&& __ht, true_type)
    {
      if (__builtin_expect(std::__addressof(__ht) == this, false))
 return;

      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());


      _M_update_bbegin();
      __ht._M_reset();
    }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    void
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    _M_move_assign(_Hashtable&& __ht, false_type)
    {
      if (__ht._M_node_allocator() == this->_M_node_allocator())
 _M_move_assign(std::move(__ht), true_type{});
      else
 {

   _M_assign_elements(std::move(__ht));
   __ht.clear();
 }
    }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _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())),
      __enable_default_ctor(__ht),
      _M_buckets(nullptr),
      _M_bucket_count(__ht._M_bucket_count),
      _M_element_count(__ht._M_element_count),
      _M_rehash_policy(__ht._M_rehash_policy)
    {
      __alloc_node_gen_t __alloc_node_gen(*this);
      _M_assign(__ht, __alloc_node_gen);
    }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    _Hashtable(_Hashtable&& __ht, __node_alloc_type&& __a,
        true_type )
    noexcept(_S_nothrow_move())
    : __hashtable_base(__ht),
      __map_base(__ht),
      __rehash_base(__ht),
      __hashtable_alloc(std::move(__a)),
      __enable_default_ctor(__ht),
      _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;
 }


      _M_update_bbegin();

      __ht._M_reset();
    }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _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)),
      __enable_default_ctor(__ht),
      _M_buckets(),
      _M_bucket_count(__ht._M_bucket_count),
      _M_element_count(__ht._M_element_count),
      _M_rehash_policy(__ht._M_rehash_policy)
    {
      __alloc_node_gen_t __alloc_node_gen(*this);
      _M_assign(__ht, __alloc_node_gen);
    }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    _Hashtable(_Hashtable&& __ht, __node_alloc_type&& __a,
        false_type )
    : __hashtable_base(__ht),
      __map_base(__ht),
      __rehash_base(__ht),
      __hashtable_alloc(std::move(__a)),
      __enable_default_ctor(__ht),
      _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_update_bbegin(__ht._M_begin());

   __ht._M_reset();
 }
      else
 {
   __alloc_node_gen_t __alloc_gen(*this);

   using _Fwd_Ht = __conditional_t<
     __move_if_noexcept_cond<value_type>::value,
     const _Hashtable&, _Hashtable&&>;
   _M_assign(std::forward<_Fwd_Ht>(__ht), __alloc_gen);
   __ht.clear();
 }
    }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    ~_Hashtable() noexcept
    {



      static_assert(noexcept(declval<const __hash_code_base_access&>()
   ._M_bucket_index(declval<const __node_value_type&>(),
      (std::size_t)0)),
      "Cache the hash code or qualify your functors involved"
      " in hash code and bucket index computation with noexcept");

      clear();
      _M_deallocate_buckets();
    }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    void
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    swap(_Hashtable& __x)
    noexcept(__and_<__is_nothrow_swappable<_Hash>,
   __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);



      _M_update_bbegin();
      __x._M_update_bbegin();
    }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    auto
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    find(const key_type& __k)
    -> iterator
    {
      if (size() <= __small_size_threshold())
 {
   for (auto __it = _M_begin(); __it; __it = __it->_M_next())
     if (this->_M_key_equals(__k, *__it))
       return iterator(__it);
   return end();
 }

      __hash_code __code = this->_M_hash_code(__k);
      std::size_t __bkt = _M_bucket_index(__code);
      return iterator(_M_find_node(__bkt, __k, __code));
    }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    auto
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    find(const key_type& __k) const
    -> const_iterator
    {
      if (size() <= __small_size_threshold())
 {
   for (auto __it = _M_begin(); __it; __it = __it->_M_next())
     if (this->_M_key_equals(__k, *__it))
       return const_iterator(__it);
   return end();
 }

      __hash_code __code = this->_M_hash_code(__k);
      std::size_t __bkt = _M_bucket_index(__code);
      return const_iterator(_M_find_node(__bkt, __k, __code));
    }


  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    template<typename _Kt, typename, typename>
      auto
      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
   _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
      _M_find_tr(const _Kt& __k)
      -> iterator
      {
 if (size() <= __small_size_threshold())
   {
     for (auto __n = _M_begin(); __n; __n = __n->_M_next())
       if (this->_M_key_equals_tr(__k, *__n))
  return iterator(__n);
     return end();
   }

 __hash_code __code = this->_M_hash_code_tr(__k);
 std::size_t __bkt = _M_bucket_index(__code);
 return iterator(_M_find_node_tr(__bkt, __k, __code));
      }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    template<typename _Kt, typename, typename>
      auto
      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
   _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
      _M_find_tr(const _Kt& __k) const
      -> const_iterator
      {
 if (size() <= __small_size_threshold())
   {
     for (auto __n = _M_begin(); __n; __n = __n->_M_next())
       if (this->_M_key_equals_tr(__k, *__n))
  return const_iterator(__n);
     return end();
   }

 __hash_code __code = this->_M_hash_code_tr(__k);
 std::size_t __bkt = _M_bucket_index(__code);
 return const_iterator(_M_find_node_tr(__bkt, __k, __code));
      }


  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    auto
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    count(const key_type& __k) const
    -> size_type
    {
      auto __it = find(__k);
      if (!__it._M_cur)
 return 0;

      if (__unique_keys::value)
 return 1;

      size_type __result = 1;
      for (auto __ref = __it++;
    __it._M_cur && this->_M_node_equals(*__ref._M_cur, *__it._M_cur);
    ++__it)
 ++__result;

      return __result;
    }


  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    template<typename _Kt, typename, typename>
      auto
      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
   _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
      _M_count_tr(const _Kt& __k) const
      -> size_type
      {
 if (size() <= __small_size_threshold())
   {
     size_type __result = 0;
     for (auto __n = _M_begin(); __n; __n = __n->_M_next())
       {
  if (this->_M_key_equals_tr(__k, *__n))
    {
      ++__result;
      continue;
    }

  if (__result)
    break;
       }

     return __result;
   }

 __hash_code __code = this->_M_hash_code_tr(__k);
 std::size_t __bkt = _M_bucket_index(__code);
 auto __n = _M_find_node_tr(__bkt, __k, __code);
 if (!__n)
   return 0;

 iterator __it(__n);
 size_type __result = 1;
 for (++__it;
      __it._M_cur && this->_M_equals_tr(__k, __code, *__it._M_cur);
      ++__it)
   ++__result;

 return __result;
      }


  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    auto
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    equal_range(const key_type& __k)
    -> pair<iterator, iterator>
    {
      auto __ite = find(__k);
      if (!__ite._M_cur)
 return { __ite, __ite };

      auto __beg = __ite++;
      if (__unique_keys::value)
 return { __beg, __ite };

      while (__ite._M_cur && this->_M_node_equals(*__beg._M_cur, *__ite._M_cur))
 ++__ite;

      return { __beg, __ite };
    }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    auto
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    equal_range(const key_type& __k) const
    -> pair<const_iterator, const_iterator>
    {
      auto __ite = find(__k);
      if (!__ite._M_cur)
 return { __ite, __ite };

      auto __beg = __ite++;
      if (__unique_keys::value)
 return { __beg, __ite };

      while (__ite._M_cur && this->_M_node_equals(*__beg._M_cur, *__ite._M_cur))
 ++__ite;

      return { __beg, __ite };
    }


  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    template<typename _Kt, typename, typename>
      auto
      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
   _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
      _M_equal_range_tr(const _Kt& __k)
      -> pair<iterator, iterator>
      {
 if (size() <= __small_size_threshold())
   {
     __node_ptr __n, __beg = nullptr;
     for (__n = _M_begin(); __n; __n = __n->_M_next())
       {
  if (this->_M_key_equals_tr(__k, *__n))
    {
      if (!__beg)
        __beg = __n;
      continue;
    }

  if (__beg)
    break;
       }

     return { iterator(__beg), iterator(__n) };
   }

 __hash_code __code = this->_M_hash_code_tr(__k);
 std::size_t __bkt = _M_bucket_index(__code);
 auto __n = _M_find_node_tr(__bkt, __k, __code);
 iterator __ite(__n);
 if (!__n)
   return { __ite, __ite };

 auto __beg = __ite++;
 while (__ite._M_cur && this->_M_equals_tr(__k, __code, *__ite._M_cur))
   ++__ite;

 return { __beg, __ite };
      }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    template<typename _Kt, typename, typename>
      auto
      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
   _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
      _M_equal_range_tr(const _Kt& __k) const
      -> pair<const_iterator, const_iterator>
      {
 if (size() <= __small_size_threshold())
   {
     __node_ptr __n, __beg = nullptr;
     for (__n = _M_begin(); __n; __n = __n->_M_next())
       {
  if (this->_M_key_equals_tr(__k, *__n))
    {
      if (!__beg)
        __beg = __n;
      continue;
    }

  if (__beg)
    break;
       }

     return { const_iterator(__beg), const_iterator(__n) };
   }

 __hash_code __code = this->_M_hash_code_tr(__k);
 std::size_t __bkt = _M_bucket_index(__code);
 auto __n = _M_find_node_tr(__bkt, __k, __code);
 const_iterator __ite(__n);
 if (!__n)
   return { __ite, __ite };

 auto __beg = __ite++;
 while (__ite._M_cur && this->_M_equals_tr(__k, __code, *__ite._M_cur))
   ++__ite;

 return { __beg, __ite };
      }




  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    auto
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    _M_find_before_node(const key_type& __k)
    -> __node_base_ptr
    {
      __node_base_ptr __prev_p = &_M_before_begin;
      if (!__prev_p->_M_nxt)
 return nullptr;

      for (__node_ptr __p = static_cast<__node_ptr>(__prev_p->_M_nxt);
    __p != nullptr;
    __p = __p->_M_next())
 {
   if (this->_M_key_equals(__k, *__p))
     return __prev_p;

   __prev_p = __p;
 }

      return nullptr;
    }



  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    auto
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    _M_find_before_node(size_type __bkt, const key_type& __k,
   __hash_code __code) const
    -> __node_base_ptr
    {
      __node_base_ptr __prev_p = _M_buckets[__bkt];
      if (!__prev_p)
 return nullptr;

      for (__node_ptr __p = static_cast<__node_ptr>(__prev_p->_M_nxt);;
    __p = __p->_M_next())
 {
   if (this->_M_equals(__k, __code, *__p))
     return __prev_p;

   if (!__p->_M_nxt || _M_bucket_index(*__p->_M_next()) != __bkt)
     break;
   __prev_p = __p;
 }

      return nullptr;
    }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    template<typename _Kt>
      auto
      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
   _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
      _M_find_before_node_tr(size_type __bkt, const _Kt& __k,
        __hash_code __code) const
      -> __node_base_ptr
      {
 __node_base_ptr __prev_p = _M_buckets[__bkt];
 if (!__prev_p)
   return nullptr;

 for (__node_ptr __p = static_cast<__node_ptr>(__prev_p->_M_nxt);;
      __p = __p->_M_next())
   {
     if (this->_M_equals_tr(__k, __code, *__p))
       return __prev_p;

     if (!__p->_M_nxt || _M_bucket_index(*__p->_M_next()) != __bkt)
       break;
     __prev_p = __p;
   }

 return nullptr;
      }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    auto
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    _M_get_previous_node(size_type __bkt, __node_ptr __n)
    -> __node_base_ptr
    {
      __node_base_ptr __prev_n = _M_buckets[__bkt];
      while (__prev_n->_M_nxt != __n)
 __prev_n = __prev_n->_M_nxt;
      return __prev_n;
    }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    template<typename... _Args>
      auto
      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
   _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
      _M_emplace(true_type , _Args&&... __args)
      -> pair<iterator, bool>
      {

 _Scoped_node __node { this, std::forward<_Args>(__args)... };
 const key_type& __k = _ExtractKey{}(__node._M_node->_M_v());
 const size_type __size = size();
 if (__size <= __small_size_threshold())
   {
     for (auto __it = _M_begin(); __it; __it = __it->_M_next())
       if (this->_M_key_equals(__k, *__it))

  return { iterator(__it), false };
   }

 __hash_code __code = this->_M_hash_code(__k);
 size_type __bkt = _M_bucket_index(__code);
 if (__size > __small_size_threshold())
   if (__node_ptr __p = _M_find_node(__bkt, __k, __code))

     return { iterator(__p), false };


 auto __pos = _M_insert_unique_node(__bkt, __code, __node._M_node);
 __node._M_node = nullptr;
 return { __pos, true };
      }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    template<typename... _Args>
      auto
      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
   _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
      _M_emplace(const_iterator __hint, false_type ,
   _Args&&... __args)
      -> iterator
      {

 _Scoped_node __node { this, std::forward<_Args>(__args)... };
 const key_type& __k = _ExtractKey{}(__node._M_node->_M_v());

 auto __res = this->_M_compute_hash_code(__hint._M_cur, __k);
 auto __pos
   = _M_insert_multi_node(__res.first, __res.second, __node._M_node);
 __node._M_node = nullptr;
 return __pos;
      }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    auto
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    _M_compute_hash_code(__node_ptr __hint, const key_type& __k) const
    -> pair<__node_ptr, __hash_code>
    {
      if (size() <= __small_size_threshold())
 {
   if (__hint)
     {
       for (auto __it = __hint; __it; __it = __it->_M_next())
  if (this->_M_key_equals(__k, *__it))
    return { __it, this->_M_hash_code(*__it) };
     }

   for (auto __it = _M_begin(); __it != __hint; __it = __it->_M_next())
     if (this->_M_key_equals(__k, *__it))
       return { __it, this->_M_hash_code(*__it) };

   __hint = nullptr;
 }

      return { __hint, this->_M_hash_code(__k) };
    }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    auto
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    _M_insert_unique_node(size_type __bkt, __hash_code __code,
     __node_ptr __node, size_type __n_elt)
    -> iterator
    {
      __rehash_guard_t __rehash_guard(_M_rehash_policy);
      std::pair<bool, std::size_t> __do_rehash
 = _M_rehash_policy._M_need_rehash(_M_bucket_count, _M_element_count,
       __n_elt);

      if (__do_rehash.first)
 {
   _M_rehash(__do_rehash.second, true_type{});
   __bkt = _M_bucket_index(__code);
 }

      __rehash_guard._M_guarded_obj = nullptr;
      this->_M_store_code(*__node, __code);


      _M_insert_bucket_begin(__bkt, __node);
      ++_M_element_count;
      return iterator(__node);
    }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    auto
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    _M_insert_multi_node(__node_ptr __hint,
    __hash_code __code, __node_ptr __node)
    -> iterator
    {
      __rehash_guard_t __rehash_guard(_M_rehash_policy);
      std::pair<bool, std::size_t> __do_rehash
 = _M_rehash_policy._M_need_rehash(_M_bucket_count, _M_element_count, 1);

      if (__do_rehash.first)
 _M_rehash(__do_rehash.second, false_type{});

      __rehash_guard._M_guarded_obj = nullptr;
      this->_M_store_code(*__node, __code);
      const key_type& __k = _ExtractKey{}(__node->_M_v());
      size_type __bkt = _M_bucket_index(__code);



      __node_base_ptr __prev
 = __builtin_expect(__hint != nullptr, false)
   && this->_M_equals(__k, __code, *__hint)
     ? __hint
     : _M_find_before_node(__bkt, __k, __code);

      if (__prev)
 {

   __node->_M_nxt = __prev->_M_nxt;
   __prev->_M_nxt = __node;
   if (__builtin_expect(__prev == __hint, false))


     if (__node->_M_nxt
  && !this->_M_equals(__k, __code, *__node->_M_next()))
       {
  size_type __next_bkt = _M_bucket_index(*__node->_M_next());
  if (__next_bkt != __bkt)
    _M_buckets[__next_bkt] = __node;
       }
 }
      else



 _M_insert_bucket_begin(__bkt, __node);
      ++_M_element_count;
      return iterator(__node);
    }


  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    template<typename _Kt, typename _Arg, typename _NodeGenerator>
      auto
      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
   _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
      _M_insert_unique(_Kt&& __k, _Arg&& __v,
         const _NodeGenerator& __node_gen)
      -> pair<iterator, bool>
      {
 const size_type __size = size();
 if (__size <= __small_size_threshold())
   for (auto __it = _M_begin(); __it; __it = __it->_M_next())
     if (this->_M_key_equals_tr(__k, *__it))
       return { iterator(__it), false };

 __hash_code __code = this->_M_hash_code_tr(__k);
 size_type __bkt = _M_bucket_index(__code);

 if (__size > __small_size_threshold())
   if (__node_ptr __node = _M_find_node_tr(__bkt, __k, __code))
     return { iterator(__node), false };

 _Scoped_node __node {
   __node_builder_t::_S_build(std::forward<_Kt>(__k),
         std::forward<_Arg>(__v),
         __node_gen),
   this
 };
 auto __pos
   = _M_insert_unique_node(__bkt, __code, __node._M_node);
 __node._M_node = nullptr;
 return { __pos, true };
      }


  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    template<typename _Arg, typename _NodeGenerator>
      auto
      _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
   _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
      _M_insert(const_iterator __hint, _Arg&& __v,
  const _NodeGenerator& __node_gen,
  false_type )
      -> iterator
      {

 _Scoped_node __node{ __node_gen(std::forward<_Arg>(__v)), this };


 auto __res = this->_M_compute_hash_code(
   __hint._M_cur, _ExtractKey{}(__node._M_node->_M_v()));

 auto __pos
   = _M_insert_multi_node(__res.first, __res.second, __node._M_node);
 __node._M_node = nullptr;
 return __pos;
      }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    auto
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    erase(const_iterator __it)
    -> iterator
    {
      __node_ptr __n = __it._M_cur;
      std::size_t __bkt = _M_bucket_index(*__n);




      __node_base_ptr __prev_n = _M_get_previous_node(__bkt, __n);
      return _M_erase(__bkt, __prev_n, __n);
    }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    auto
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    _M_erase(size_type __bkt, __node_base_ptr __prev_n, __node_ptr __n)
    -> iterator
    {
      if (__prev_n == _M_buckets[__bkt])
 _M_remove_bucket_begin(__bkt, __n->_M_next(),
   __n->_M_nxt ? _M_bucket_index(*__n->_M_next()) : 0);
      else if (__n->_M_nxt)
 {
   size_type __next_bkt = _M_bucket_index(*__n->_M_next());
   if (__next_bkt != __bkt)
     _M_buckets[__next_bkt] = __prev_n;
 }

      __prev_n->_M_nxt = __n->_M_nxt;
      iterator __result(__n->_M_next());
      this->_M_deallocate_node(__n);
      --_M_element_count;

      return __result;
    }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    auto
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    _M_erase(true_type , const key_type& __k)
    -> size_type
    {
      __node_base_ptr __prev_n;
      __node_ptr __n;
      std::size_t __bkt;
      if (size() <= __small_size_threshold())
 {
   __prev_n = _M_find_before_node(__k);
   if (!__prev_n)
     return 0;


   __n = static_cast<__node_ptr>(__prev_n->_M_nxt);
   __bkt = _M_bucket_index(*__n);
 }
      else
 {
   __hash_code __code = this->_M_hash_code(__k);
   __bkt = _M_bucket_index(__code);


   __prev_n = _M_find_before_node(__bkt, __k, __code);
   if (!__prev_n)
     return 0;


   __n = static_cast<__node_ptr>(__prev_n->_M_nxt);
 }

      _M_erase(__bkt, __prev_n, __n);
      return 1;
    }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    auto
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    _M_erase(false_type , const key_type& __k)
    -> size_type
    {
      std::size_t __bkt;
      __node_base_ptr __prev_n;
      __node_ptr __n;
      if (size() <= __small_size_threshold())
 {
   __prev_n = _M_find_before_node(__k);
   if (!__prev_n)
     return 0;


   __n = static_cast<__node_ptr>(__prev_n->_M_nxt);
   __bkt = _M_bucket_index(*__n);
 }
      else
 {
   __hash_code __code = this->_M_hash_code(__k);
   __bkt = _M_bucket_index(__code);


   __prev_n = _M_find_before_node(__bkt, __k, __code);
   if (!__prev_n)
     return 0;

   __n = static_cast<__node_ptr>(__prev_n->_M_nxt);
 }







      __node_ptr __n_last = __n->_M_next();
      while (__n_last && this->_M_node_equals(*__n, *__n_last))
 __n_last = __n_last->_M_next();

      std::size_t __n_last_bkt = __n_last ? _M_bucket_index(*__n_last) : __bkt;


      size_type __result = 0;
      do
 {
   __node_ptr __p = __n->_M_next();
   this->_M_deallocate_node(__n);
   __n = __p;
   ++__result;
 }
      while (__n != __n_last);

      _M_element_count -= __result;
      if (__prev_n == _M_buckets[__bkt])
 _M_remove_bucket_begin(__bkt, __n_last, __n_last_bkt);
      else if (__n_last_bkt != __bkt)
 _M_buckets[__n_last_bkt] = __prev_n;
      __prev_n->_M_nxt = __n_last;
      return __result;
    }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    auto
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    erase(const_iterator __first, const_iterator __last)
    -> iterator
    {
      __node_ptr __n = __first._M_cur;
      __node_ptr __last_n = __last._M_cur;
      if (__n == __last_n)
 return iterator(__n);

      std::size_t __bkt = _M_bucket_index(*__n);

      __node_base_ptr __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_ptr __tmp = __n;
       __n = __n->_M_next();
       this->_M_deallocate_node(__tmp);
       --_M_element_count;
       if (!__n)
  break;
       __n_bkt = _M_bucket_index(*__n);
     }
   while (__n != __last_n && __n_bkt == __bkt);
   if (__is_bucket_begin)
     _M_remove_bucket_begin(__bkt, __n, __n_bkt);
   if (__n == __last_n)
     break;
   __is_bucket_begin = true;
   __bkt = __n_bkt;
 }

      if (__n && (__n_bkt != __bkt || __is_bucket_begin))
 _M_buckets[__n_bkt] = __prev_n;
      __prev_n->_M_nxt = __n;
      return iterator(__n);
    }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    void
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    clear() noexcept
    {
      this->_M_deallocate_nodes(_M_begin());
      __builtin_memset(_M_buckets, 0,
         _M_bucket_count * sizeof(__node_base_ptr));
      _M_element_count = 0;
      _M_before_begin._M_nxt = nullptr;
    }

  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    void
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    rehash(size_type __bkt_count)
    {
      __rehash_guard_t __rehash_guard(_M_rehash_policy);
      __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, __unique_keys{});
   __rehash_guard._M_guarded_obj = nullptr;
 }
    }


  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    void
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    _M_rehash(size_type __bkt_count, true_type )
    {
      __buckets_ptr __new_buckets = _M_allocate_buckets(__bkt_count);
      __node_ptr __p = _M_begin();
      _M_before_begin._M_nxt = nullptr;
      std::size_t __bbegin_bkt = 0;
      while (__p)
 {
   __node_ptr __next = __p->_M_next();
   std::size_t __bkt
     = __hash_code_base::_M_bucket_index(*__p, __bkt_count);
   if (!__new_buckets[__bkt])
     {
       __p->_M_nxt = _M_before_begin._M_nxt;
       _M_before_begin._M_nxt = __p;
       __new_buckets[__bkt] = &_M_before_begin;
       if (__p->_M_nxt)
  __new_buckets[__bbegin_bkt] = __p;
       __bbegin_bkt = __bkt;
     }
   else
     {
       __p->_M_nxt = __new_buckets[__bkt]->_M_nxt;
       __new_buckets[__bkt]->_M_nxt = __p;
     }

   __p = __next;
 }

      _M_deallocate_buckets();
      _M_bucket_count = __bkt_count;
      _M_buckets = __new_buckets;
    }



  template<typename _Key, typename _Value, typename _Alloc,
    typename _ExtractKey, typename _Equal,
    typename _Hash, typename _RangeHash, typename _Unused,
    typename _RehashPolicy, typename _Traits>
    void
    _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal,
        _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>::
    _M_rehash(size_type __bkt_count, false_type )
    {
      __buckets_ptr __new_buckets = _M_allocate_buckets(__bkt_count);
      __node_ptr __p = _M_begin();
      _M_before_begin._M_nxt = nullptr;
      std::size_t __bbegin_bkt = 0;
      std::size_t __prev_bkt = 0;
      __node_ptr __prev_p = nullptr;
      bool __check_bucket = false;

      while (__p)
 {
   __node_ptr __next = __p->_M_next();
   std::size_t __bkt
     = __hash_code_base::_M_bucket_index(*__p, __bkt_count);

   if (__prev_p && __prev_bkt == __bkt)
     {



       __p->_M_nxt = __prev_p->_M_nxt;
       __prev_p->_M_nxt = __p;






       __check_bucket = true;
     }
   else
     {
       if (__check_bucket)
  {


    if (__prev_p->_M_nxt)
      {
        std::size_t __next_bkt
   = __hash_code_base::_M_bucket_index(
     *__prev_p->_M_next(), __bkt_count);
        if (__next_bkt != __prev_bkt)
   __new_buckets[__next_bkt] = __prev_p;
      }
    __check_bucket = false;
  }

       if (!__new_buckets[__bkt])
  {
    __p->_M_nxt = _M_before_begin._M_nxt;
    _M_before_begin._M_nxt = __p;
    __new_buckets[__bkt] = &_M_before_begin;
    if (__p->_M_nxt)
      __new_buckets[__bbegin_bkt] = __p;
    __bbegin_bkt = __bkt;
  }
       else
  {
    __p->_M_nxt = __new_buckets[__bkt]->_M_nxt;
    __new_buckets[__bkt]->_M_nxt = __p;
  }
     }
   __prev_p = __p;
   __prev_bkt = __bkt;
   __p = __next;
 }

      if (__check_bucket && __prev_p->_M_nxt)
 {
   std::size_t __next_bkt
     = __hash_code_base::_M_bucket_index(*__prev_p->_M_next(),
      __bkt_count);
   if (__next_bkt != __prev_bkt)
     __new_buckets[__next_bkt] = __prev_p;
 }

      _M_deallocate_buckets();
      _M_bucket_count = __bkt_count;
      _M_buckets = __new_buckets;
    }


  template<typename, typename, typename> class _Hash_merge_helper { };




  template<typename _Hash>
    using _RequireNotAllocatorOrIntegral
      = __enable_if_t<!__or_<is_integral<_Hash>, __is_allocator<_Hash>>::value>;




}
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_map.h" 2 3




namespace std __attribute__ ((__visibility__ ("default")))
{




  template<bool _Cache>
    using __umap_traits = __detail::_Hashtable_traits<_Cache, false, true>;

  template<typename _Key,
    typename _Tp,
    typename _Hash = hash<_Key>,
    typename _Pred = std::equal_to<_Key>,
    typename _Alloc = std::allocator<std::pair<const _Key, _Tp> >,
    typename _Tr = __umap_traits<__cache_default<_Key, _Hash>::value>>
    using __umap_hashtable = _Hashtable<_Key, std::pair<const _Key, _Tp>,
                                        _Alloc, __detail::_Select1st,
            _Pred, _Hash,
            __detail::_Mod_range_hashing,
            __detail::_Default_ranged_hash,
            __detail::_Prime_rehash_policy, _Tr>;


  template<bool _Cache>
    using __ummap_traits = __detail::_Hashtable_traits<_Cache, false, false>;

  template<typename _Key,
    typename _Tp,
    typename _Hash = hash<_Key>,
    typename _Pred = std::equal_to<_Key>,
    typename _Alloc = std::allocator<std::pair<const _Key, _Tp> >,
    typename _Tr = __ummap_traits<__cache_default<_Key, _Hash>::value>>
    using __ummap_hashtable = _Hashtable<_Key, std::pair<const _Key, _Tp>,
      _Alloc, __detail::_Select1st,
      _Pred, _Hash,
      __detail::_Mod_range_hashing,
      __detail::_Default_ranged_hash,
      __detail::_Prime_rehash_policy, _Tr>;

  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
    class unordered_multimap;
# 105 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_map.h" 3
  template<typename _Key, typename _Tp,
    typename _Hash = hash<_Key>,
    typename _Pred = equal_to<_Key>,
    typename _Alloc = allocator<std::pair<const _Key, _Tp>>>
    class unordered_map
    {
      typedef __umap_hashtable<_Key, _Tp, _Hash, _Pred, _Alloc> _Hashtable;
      _Hashtable _M_h;

    public:



      typedef typename _Hashtable::key_type key_type;
      typedef typename _Hashtable::value_type value_type;
      typedef typename _Hashtable::mapped_type mapped_type;
      typedef typename _Hashtable::hasher hasher;
      typedef typename _Hashtable::key_equal key_equal;
      typedef typename _Hashtable::allocator_type allocator_type;




      typedef typename _Hashtable::pointer pointer;
      typedef typename _Hashtable::const_pointer const_pointer;
      typedef typename _Hashtable::reference reference;
      typedef typename _Hashtable::const_reference const_reference;
      typedef typename _Hashtable::iterator iterator;
      typedef typename _Hashtable::const_iterator const_iterator;
      typedef typename _Hashtable::local_iterator local_iterator;
      typedef typename _Hashtable::const_local_iterator const_local_iterator;
      typedef typename _Hashtable::size_type size_type;
      typedef typename _Hashtable::difference_type difference_type;



      using node_type = typename _Hashtable::node_type;
      using insert_return_type = typename _Hashtable::insert_return_type;





      unordered_map() = default;
# 157 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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)
      { }
# 178 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_map.h" 3
      template<typename _InputIterator>
 unordered_map(_InputIterator __first, _InputIterator __last,
        size_type __n = 0,
        const hasher& __hf = hasher(),
        const key_equal& __eql = key_equal(),
        const allocator_type& __a = allocator_type())
 : _M_h(__first, __last, __n, __hf, __eql, __a)
 { }


      unordered_map(const unordered_map&) = default;


      unordered_map(unordered_map&&) = default;





      explicit
      unordered_map(const allocator_type& __a)
 : _M_h(__a)
      { }






      unordered_map(const unordered_map& __umap,
      const allocator_type& __a)
      : _M_h(__umap._M_h, __a)
      { }






      unordered_map(unordered_map&& __umap,
      const allocator_type& __a)
 noexcept( noexcept(_Hashtable(std::move(__umap._M_h), __a)) )
      : _M_h(std::move(__umap._M_h), __a)
      { }
# 234 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_map.h" 3
      unordered_map(initializer_list<value_type> __l,
      size_type __n = 0,
      const hasher& __hf = hasher(),
      const key_equal& __eql = key_equal(),
      const allocator_type& __a = allocator_type())
      : _M_h(__l, __n, __hf, __eql, __a)
      { }

      unordered_map(size_type __n, const allocator_type& __a)
      : unordered_map(__n, hasher(), key_equal(), __a)
      { }

      unordered_map(size_type __n, const hasher& __hf,
      const allocator_type& __a)
      : unordered_map(__n, __hf, key_equal(), __a)
      { }

      template<typename _InputIterator>
 unordered_map(_InputIterator __first, _InputIterator __last,
        size_type __n,
        const allocator_type& __a)
 : unordered_map(__first, __last, __n, hasher(), key_equal(), __a)
 { }

      template<typename _InputIterator>
 unordered_map(_InputIterator __first, _InputIterator __last,
        size_type __n, const hasher& __hf,
        const allocator_type& __a)
   : unordered_map(__first, __last, __n, __hf, key_equal(), __a)
 { }

      unordered_map(initializer_list<value_type> __l,
      size_type __n,
      const allocator_type& __a)
      : unordered_map(__l, __n, hasher(), key_equal(), __a)
      { }

      unordered_map(initializer_list<value_type> __l,
      size_type __n, const hasher& __hf,
      const allocator_type& __a)
      : unordered_map(__l, __n, __hf, key_equal(), __a)
      { }


      unordered_map&
      operator=(const unordered_map&) = default;


      unordered_map&
      operator=(unordered_map&&) = default;
# 296 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_map.h" 3
      unordered_map&
      operator=(initializer_list<value_type> __l)
      {
 _M_h = __l;
 return *this;
      }


      allocator_type
      get_allocator() const noexcept
      { return _M_h.get_allocator(); }




      [[__nodiscard__]] bool
      empty() const noexcept
      { return _M_h.empty(); }


      size_type
      size() const noexcept
      { return _M_h.size(); }


      size_type
      max_size() const noexcept
      { return _M_h.max_size(); }







      iterator
      begin() noexcept
      { return _M_h.begin(); }






      const_iterator
      begin() const noexcept
      { return _M_h.begin(); }

      const_iterator
      cbegin() const noexcept
      { return _M_h.begin(); }






      iterator
      end() noexcept
      { return _M_h.end(); }






      const_iterator
      end() const noexcept
      { return _M_h.end(); }

      const_iterator
      cend() const noexcept
      { return _M_h.end(); }
# 393 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_map.h" 3
      template<typename... _Args>
 std::pair<iterator, bool>
 emplace(_Args&&... __args)
 { return _M_h.emplace(std::forward<_Args>(__args)...); }
# 424 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_map.h" 3
      template<typename... _Args>
 iterator
 emplace_hint(const_iterator __pos, _Args&&... __args)
 { return _M_h.emplace_hint(__pos, std::forward<_Args>(__args)...); }



      node_type
      extract(const_iterator __pos)
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__pos != end()), false)) std::__glibcxx_assert_fail(); } while (false);
 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; }
# 477 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_map.h" 3
      template <typename... _Args>
 pair<iterator, bool>
 try_emplace(const key_type& __k, _Args&&... __args)
 {
   return _M_h.try_emplace(cend(), __k, std::forward<_Args>(__args)...);
 }


      template <typename... _Args>
 pair<iterator, bool>
 try_emplace(key_type&& __k, _Args&&... __args)
 {
   return _M_h.try_emplace(cend(), std::move(__k),
      std::forward<_Args>(__args)...);
 }
# 521 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_map.h" 3
      template <typename... _Args>
 iterator
 try_emplace(const_iterator __hint, const key_type& __k,
      _Args&&... __args)
 {
   return _M_h.try_emplace(__hint, __k,
      std::forward<_Args>(__args)...).first;
 }


      template <typename... _Args>
 iterator
 try_emplace(const_iterator __hint, key_type&& __k, _Args&&... __args)
 {
   return _M_h.try_emplace(__hint, std::move(__k),
      std::forward<_Args>(__args)...).first;
 }
# 558 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_map.h" 3
      std::pair<iterator, bool>
      insert(const value_type& __x)
      { return _M_h.insert(__x); }



      std::pair<iterator, bool>
      insert(value_type&& __x)
      { return _M_h.insert(std::move(__x)); }

      template<typename _Pair>
 __enable_if_t<is_constructible<value_type, _Pair&&>::value,
        pair<iterator, bool>>
 insert(_Pair&& __x)
        { return _M_h.emplace(std::forward<_Pair>(__x)); }
# 597 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_map.h" 3
      iterator
      insert(const_iterator __hint, const value_type& __x)
      { return _M_h.insert(__hint, __x); }



      iterator
      insert(const_iterator __hint, value_type&& __x)
      { return _M_h.insert(__hint, std::move(__x)); }

      template<typename _Pair>
 __enable_if_t<is_constructible<value_type, _Pair&&>::value, iterator>
 insert(const_iterator __hint, _Pair&& __x)
 { return _M_h.emplace_hint(__hint, std::forward<_Pair>(__x)); }
# 622 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_map.h" 3
      template<typename _InputIterator>
 void
 insert(_InputIterator __first, _InputIterator __last)
 { _M_h.insert(__first, __last); }
# 634 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_map.h" 3
      void
      insert(initializer_list<value_type> __l)
      { _M_h.insert(__l); }
# 660 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_map.h" 3
      template <typename _Obj>
 pair<iterator, bool>
 insert_or_assign(const key_type& __k, _Obj&& __obj)
 {
   auto __ret = _M_h.try_emplace(cend(), __k,
     std::forward<_Obj>(__obj));
   if (!__ret.second)
     __ret.first->second = std::forward<_Obj>(__obj);
   return __ret;
 }


      template <typename _Obj>
 pair<iterator, bool>
 insert_or_assign(key_type&& __k, _Obj&& __obj)
 {
   auto __ret = _M_h.try_emplace(cend(), std::move(__k),
     std::forward<_Obj>(__obj));
   if (!__ret.second)
     __ret.first->second = std::forward<_Obj>(__obj);
   return __ret;
 }
# 709 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_map.h" 3
      template <typename _Obj>
 iterator
 insert_or_assign(const_iterator __hint, const key_type& __k,
    _Obj&& __obj)
 {
   auto __ret = _M_h.try_emplace(__hint, __k, std::forward<_Obj>(__obj));
   if (!__ret.second)
     __ret.first->second = std::forward<_Obj>(__obj);
   return __ret.first;
 }


      template <typename _Obj>
 iterator
 insert_or_assign(const_iterator __hint, key_type&& __k, _Obj&& __obj)
 {
   auto __ret = _M_h.try_emplace(__hint, std::move(__k),
     std::forward<_Obj>(__obj));
   if (!__ret.second)
     __ret.first->second = std::forward<_Obj>(__obj);
   return __ret.first;
 }
# 747 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_map.h" 3
      iterator
      erase(const_iterator __position)
      { return _M_h.erase(__position); }


      iterator
      erase(iterator __position)
      { return _M_h.erase(__position); }
# 769 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_map.h" 3
      size_type
      erase(const key_type& __x)
      { return _M_h.erase(__x); }
# 787 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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(); }
# 811 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_map.h" 3
      void
      swap(unordered_map& __x)
      noexcept( noexcept(_M_h.swap(__x._M_h)) )
      { _M_h.swap(__x._M_h); }


      template<typename, typename, typename>
 friend class std::_Hash_merge_helper;

      template<typename _H2, typename _P2>
 void
 merge(unordered_map<_Key, _Tp, _H2, _P2, _Alloc>& __source)
 {
   using _Merge_helper = _Hash_merge_helper<unordered_map, _H2, _P2>;
   _M_h._M_merge_unique(_Merge_helper::_S_get_table(__source));
 }

      template<typename _H2, typename _P2>
 void
 merge(unordered_map<_Key, _Tp, _H2, _P2, _Alloc>&& __source)
 { merge(__source); }

      template<typename _H2, typename _P2>
 void
 merge(unordered_multimap<_Key, _Tp, _H2, _P2, _Alloc>& __source)
 {
   using _Merge_helper = _Hash_merge_helper<unordered_map, _H2, _P2>;
   _M_h._M_merge_unique(_Merge_helper::_S_get_table(__source));
 }

      template<typename _H2, typename _P2>
 void
 merge(unordered_multimap<_Key, _Tp, _H2, _P2, _Alloc>&& __source)
 { merge(__source); }






      hasher
      hash_function() const
      { return _M_h.hash_function(); }



      key_equal
      key_eq() const
      { return _M_h.key_eq(); }
# 875 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_map.h" 3
      iterator
      find(const key_type& __x)
      { return _M_h.find(__x); }


      template<typename _Kt>
 auto
 find(const _Kt& __x) -> decltype(_M_h._M_find_tr(__x))
 { return _M_h._M_find_tr(__x); }


      const_iterator
      find(const key_type& __x) const
      { return _M_h.find(__x); }


      template<typename _Kt>
 auto
 find(const _Kt& __x) const -> decltype(_M_h._M_find_tr(__x))
 { return _M_h._M_find_tr(__x); }
# 908 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_map.h" 3
      size_type
      count(const key_type& __x) const
      { return _M_h.count(__x); }


      template<typename _Kt>
 auto
 count(const _Kt& __x) const -> decltype(_M_h._M_count_tr(__x))
 { return _M_h._M_count_tr(__x); }
# 927 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_map.h" 3
      bool
      contains(const key_type& __x) const
      { return _M_h.find(__x) != _M_h.end(); }

      template<typename _Kt>
 auto
 contains(const _Kt& __x) const
 -> decltype(_M_h._M_find_tr(__x), void(), true)
 { return _M_h._M_find_tr(__x) != _M_h.end(); }
# 948 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_map.h" 3
      std::pair<iterator, iterator>
      equal_range(const key_type& __x)
      { return _M_h.equal_range(__x); }


      template<typename _Kt>
 auto
 equal_range(const _Kt& __x)
 -> decltype(_M_h._M_equal_range_tr(__x))
 { return _M_h._M_equal_range_tr(__x); }


      std::pair<const_iterator, const_iterator>
      equal_range(const key_type& __x) const
      { return _M_h.equal_range(__x); }


      template<typename _Kt>
 auto
 equal_range(const _Kt& __x) const
 -> decltype(_M_h._M_equal_range_tr(__x))
 { return _M_h._M_equal_range_tr(__x); }
# 986 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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)]; }
# 1003 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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); }
# 1059 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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); }
# 1074 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_map.h" 3
      local_iterator
      end(size_type __n)
      { return _M_h.end(__n); }
# 1085 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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); }
# 1122 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_map.h" 3
      void
      rehash(size_type __n)
      { _M_h.rehash(__n); }
# 1133 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_map.h" 3
      void
      reserve(size_type __n)
      { _M_h.reserve(__n); }

      template<typename _Key1, typename _Tp1, typename _Hash1, typename _Pred1,
        typename _Alloc1>
        friend bool
 operator==(const unordered_map<_Key1, _Tp1, _Hash1, _Pred1, _Alloc1>&,
     const unordered_map<_Key1, _Tp1, _Hash1, _Pred1, _Alloc1>&);
    };



  template<typename _InputIterator,
    typename _Hash = hash<__iter_key_t<_InputIterator>>,
    typename _Pred = equal_to<__iter_key_t<_InputIterator>>,
    typename _Allocator = allocator<__iter_to_alloc_t<_InputIterator>>,
    typename = _RequireInputIter<_InputIterator>,
    typename = _RequireNotAllocatorOrIntegral<_Hash>,
    typename = _RequireNotAllocator<_Pred>,
    typename = _RequireAllocator<_Allocator>>
    unordered_map(_InputIterator, _InputIterator,
    typename unordered_map<int, int>::size_type = {},
    _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())
    -> unordered_map<__iter_key_t<_InputIterator>,
       __iter_val_t<_InputIterator>,
       _Hash, _Pred, _Allocator>;

  template<typename _Key, typename _Tp, typename _Hash = hash<_Key>,
    typename _Pred = equal_to<_Key>,
    typename _Allocator = allocator<pair<const _Key, _Tp>>,
    typename = _RequireNotAllocatorOrIntegral<_Hash>,
    typename = _RequireNotAllocator<_Pred>,
    typename = _RequireAllocator<_Allocator>>
    unordered_map(initializer_list<pair<_Key, _Tp>>,
    typename unordered_map<int, int>::size_type = {},
    _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())
    -> unordered_map<_Key, _Tp, _Hash, _Pred, _Allocator>;

  template<typename _InputIterator, typename _Allocator,
    typename = _RequireInputIter<_InputIterator>,
    typename = _RequireAllocator<_Allocator>>
    unordered_map(_InputIterator, _InputIterator,
    typename unordered_map<int, int>::size_type, _Allocator)
    -> unordered_map<__iter_key_t<_InputIterator>,
       __iter_val_t<_InputIterator>,
       hash<__iter_key_t<_InputIterator>>,
       equal_to<__iter_key_t<_InputIterator>>,
       _Allocator>;

  template<typename _InputIterator, typename _Allocator,
    typename = _RequireInputIter<_InputIterator>,
    typename = _RequireAllocator<_Allocator>>
    unordered_map(_InputIterator, _InputIterator, _Allocator)
    -> unordered_map<__iter_key_t<_InputIterator>,
       __iter_val_t<_InputIterator>,
       hash<__iter_key_t<_InputIterator>>,
       equal_to<__iter_key_t<_InputIterator>>,
       _Allocator>;

  template<typename _InputIterator, typename _Hash, typename _Allocator,
    typename = _RequireInputIter<_InputIterator>,
    typename = _RequireNotAllocatorOrIntegral<_Hash>,
    typename = _RequireAllocator<_Allocator>>
    unordered_map(_InputIterator, _InputIterator,
    typename unordered_map<int, int>::size_type,
    _Hash, _Allocator)
    -> unordered_map<__iter_key_t<_InputIterator>,
       __iter_val_t<_InputIterator>, _Hash,
       equal_to<__iter_key_t<_InputIterator>>, _Allocator>;

  template<typename _Key, typename _Tp, typename _Allocator,
    typename = _RequireAllocator<_Allocator>>
    unordered_map(initializer_list<pair<_Key, _Tp>>,
    typename unordered_map<int, int>::size_type,
    _Allocator)
    -> unordered_map<_Key, _Tp, hash<_Key>, equal_to<_Key>, _Allocator>;

  template<typename _Key, typename _Tp, typename _Allocator,
    typename = _RequireAllocator<_Allocator>>
    unordered_map(initializer_list<pair<_Key, _Tp>>, _Allocator)
    -> unordered_map<_Key, _Tp, hash<_Key>, equal_to<_Key>, _Allocator>;

  template<typename _Key, typename _Tp, typename _Hash, typename _Allocator,
    typename = _RequireNotAllocatorOrIntegral<_Hash>,
    typename = _RequireAllocator<_Allocator>>
    unordered_map(initializer_list<pair<_Key, _Tp>>,
    typename unordered_map<int, int>::size_type,
    _Hash, _Allocator)
    -> unordered_map<_Key, _Tp, _Hash, equal_to<_Key>, _Allocator>;
# 1251 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_map.h" 3
  template<typename _Key, typename _Tp,
    typename _Hash = hash<_Key>,
    typename _Pred = equal_to<_Key>,
    typename _Alloc = allocator<std::pair<const _Key, _Tp>>>
    class unordered_multimap
    {
      typedef __ummap_hashtable<_Key, _Tp, _Hash, _Pred, _Alloc> _Hashtable;
      _Hashtable _M_h;

    public:



      typedef typename _Hashtable::key_type key_type;
      typedef typename _Hashtable::value_type value_type;
      typedef typename _Hashtable::mapped_type mapped_type;
      typedef typename _Hashtable::hasher hasher;
      typedef typename _Hashtable::key_equal key_equal;
      typedef typename _Hashtable::allocator_type allocator_type;




      typedef typename _Hashtable::pointer pointer;
      typedef typename _Hashtable::const_pointer const_pointer;
      typedef typename _Hashtable::reference reference;
      typedef typename _Hashtable::const_reference const_reference;
      typedef typename _Hashtable::iterator iterator;
      typedef typename _Hashtable::const_iterator const_iterator;
      typedef typename _Hashtable::local_iterator local_iterator;
      typedef typename _Hashtable::const_local_iterator const_local_iterator;
      typedef typename _Hashtable::size_type size_type;
      typedef typename _Hashtable::difference_type difference_type;



      using node_type = typename _Hashtable::node_type;





      unordered_multimap() = default;
# 1302 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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)
      { }
# 1323 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_map.h" 3
      template<typename _InputIterator>
 unordered_multimap(_InputIterator __first, _InputIterator __last,
      size_type __n = 0,
      const hasher& __hf = hasher(),
      const key_equal& __eql = key_equal(),
      const allocator_type& __a = allocator_type())
 : _M_h(__first, __last, __n, __hf, __eql, __a)
 { }


      unordered_multimap(const unordered_multimap&) = default;


      unordered_multimap(unordered_multimap&&) = default;





      explicit
      unordered_multimap(const allocator_type& __a)
      : _M_h(__a)
      { }






      unordered_multimap(const unordered_multimap& __ummap,
    const allocator_type& __a)
      : _M_h(__ummap._M_h, __a)
      { }






      unordered_multimap(unordered_multimap&& __ummap,
    const allocator_type& __a)
 noexcept( noexcept(_Hashtable(std::move(__ummap._M_h), __a)) )
      : _M_h(std::move(__ummap._M_h), __a)
      { }
# 1379 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_map.h" 3
      unordered_multimap(initializer_list<value_type> __l,
    size_type __n = 0,
    const hasher& __hf = hasher(),
    const key_equal& __eql = key_equal(),
    const allocator_type& __a = allocator_type())
      : _M_h(__l, __n, __hf, __eql, __a)
      { }

      unordered_multimap(size_type __n, const allocator_type& __a)
      : unordered_multimap(__n, hasher(), key_equal(), __a)
      { }

      unordered_multimap(size_type __n, const hasher& __hf,
    const allocator_type& __a)
      : unordered_multimap(__n, __hf, key_equal(), __a)
      { }

      template<typename _InputIterator>
 unordered_multimap(_InputIterator __first, _InputIterator __last,
      size_type __n,
      const allocator_type& __a)
 : unordered_multimap(__first, __last, __n, hasher(), key_equal(), __a)
 { }

      template<typename _InputIterator>
 unordered_multimap(_InputIterator __first, _InputIterator __last,
      size_type __n, const hasher& __hf,
      const allocator_type& __a)
 : unordered_multimap(__first, __last, __n, __hf, key_equal(), __a)
 { }

      unordered_multimap(initializer_list<value_type> __l,
    size_type __n,
    const allocator_type& __a)
      : unordered_multimap(__l, __n, hasher(), key_equal(), __a)
      { }

      unordered_multimap(initializer_list<value_type> __l,
    size_type __n, const hasher& __hf,
    const allocator_type& __a)
      : unordered_multimap(__l, __n, __hf, key_equal(), __a)
      { }


      unordered_multimap&
      operator=(const unordered_multimap&) = default;


      unordered_multimap&
      operator=(unordered_multimap&&) = default;
# 1441 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_map.h" 3
      unordered_multimap&
      operator=(initializer_list<value_type> __l)
      {
 _M_h = __l;
 return *this;
      }


      allocator_type
      get_allocator() const noexcept
      { return _M_h.get_allocator(); }




      [[__nodiscard__]] bool
      empty() const noexcept
      { return _M_h.empty(); }


      size_type
      size() const noexcept
      { return _M_h.size(); }


      size_type
      max_size() const noexcept
      { return _M_h.max_size(); }







      iterator
      begin() noexcept
      { return _M_h.begin(); }






      const_iterator
      begin() const noexcept
      { return _M_h.begin(); }

      const_iterator
      cbegin() const noexcept
      { return _M_h.begin(); }






      iterator
      end() noexcept
      { return _M_h.end(); }






      const_iterator
      end() const noexcept
      { return _M_h.end(); }

      const_iterator
      cend() const noexcept
      { return _M_h.end(); }
# 1533 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_map.h" 3
      template<typename... _Args>
 iterator
 emplace(_Args&&... __args)
 { return _M_h.emplace(std::forward<_Args>(__args)...); }
# 1560 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_map.h" 3
      template<typename... _Args>
 iterator
 emplace_hint(const_iterator __pos, _Args&&... __args)
 { return _M_h.emplace_hint(__pos, std::forward<_Args>(__args)...); }
# 1575 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_map.h" 3
      iterator
      insert(const value_type& __x)
      { return _M_h.insert(__x); }

      iterator
      insert(value_type&& __x)
      { return _M_h.insert(std::move(__x)); }

      template<typename _Pair>
 __enable_if_t<is_constructible<value_type, _Pair&&>::value, iterator>
 insert(_Pair&& __x)
        { return _M_h.emplace(std::forward<_Pair>(__x)); }
# 1609 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_map.h" 3
      iterator
      insert(const_iterator __hint, const value_type& __x)
      { return _M_h.insert(__hint, __x); }



      iterator
      insert(const_iterator __hint, value_type&& __x)
      { return _M_h.insert(__hint, std::move(__x)); }

      template<typename _Pair>
 __enable_if_t<is_constructible<value_type, _Pair&&>::value, iterator>
 insert(const_iterator __hint, _Pair&& __x)
        { return _M_h.emplace_hint(__hint, std::forward<_Pair>(__x)); }
# 1634 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_map.h" 3
      template<typename _InputIterator>
 void
 insert(_InputIterator __first, _InputIterator __last)
 { _M_h.insert(__first, __last); }
# 1647 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_map.h" 3
      void
      insert(initializer_list<value_type> __l)
      { _M_h.insert(__l); }



      node_type
      extract(const_iterator __pos)
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__pos != end()), false)) std::__glibcxx_assert_fail(); } while (false);
 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)); }
# 1690 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_map.h" 3
      iterator
      erase(const_iterator __position)
      { return _M_h.erase(__position); }


      iterator
      erase(iterator __position)
      { return _M_h.erase(__position); }
# 1711 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_map.h" 3
      size_type
      erase(const key_type& __x)
      { return _M_h.erase(__x); }
# 1730 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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(); }
# 1754 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_map.h" 3
      void
      swap(unordered_multimap& __x)
      noexcept( noexcept(_M_h.swap(__x._M_h)) )
      { _M_h.swap(__x._M_h); }


      template<typename, typename, typename>
 friend class std::_Hash_merge_helper;

      template<typename _H2, typename _P2>
 void
 merge(unordered_multimap<_Key, _Tp, _H2, _P2, _Alloc>& __source)
 {
   using _Merge_helper
     = _Hash_merge_helper<unordered_multimap, _H2, _P2>;
   _M_h._M_merge_multi(_Merge_helper::_S_get_table(__source));
 }

      template<typename _H2, typename _P2>
 void
 merge(unordered_multimap<_Key, _Tp, _H2, _P2, _Alloc>&& __source)
 { merge(__source); }

      template<typename _H2, typename _P2>
 void
 merge(unordered_map<_Key, _Tp, _H2, _P2, _Alloc>& __source)
 {
   using _Merge_helper
     = _Hash_merge_helper<unordered_multimap, _H2, _P2>;
   _M_h._M_merge_multi(_Merge_helper::_S_get_table(__source));
 }

      template<typename _H2, typename _P2>
 void
 merge(unordered_map<_Key, _Tp, _H2, _P2, _Alloc>&& __source)
 { merge(__source); }






      hasher
      hash_function() const
      { return _M_h.hash_function(); }



      key_equal
      key_eq() const
      { return _M_h.key_eq(); }
# 1820 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_map.h" 3
      iterator
      find(const key_type& __x)
      { return _M_h.find(__x); }


      template<typename _Kt>
 auto
 find(const _Kt& __x) -> decltype(_M_h._M_find_tr(__x))
 { return _M_h._M_find_tr(__x); }


      const_iterator
      find(const key_type& __x) const
      { return _M_h.find(__x); }


      template<typename _Kt>
 auto
 find(const _Kt& __x) const -> decltype(_M_h._M_find_tr(__x))
 { return _M_h._M_find_tr(__x); }
# 1849 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_map.h" 3
      size_type
      count(const key_type& __x) const
      { return _M_h.count(__x); }


      template<typename _Kt>
 auto
 count(const _Kt& __x) const -> decltype(_M_h._M_count_tr(__x))
 { return _M_h._M_count_tr(__x); }
# 1868 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_map.h" 3
      bool
      contains(const key_type& __x) const
      { return _M_h.find(__x) != _M_h.end(); }

      template<typename _Kt>
 auto
 contains(const _Kt& __x) const
 -> decltype(_M_h._M_find_tr(__x), void(), true)
 { return _M_h._M_find_tr(__x) != _M_h.end(); }
# 1887 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_map.h" 3
      std::pair<iterator, iterator>
      equal_range(const key_type& __x)
      { return _M_h.equal_range(__x); }


      template<typename _Kt>
 auto
 equal_range(const _Kt& __x)
 -> decltype(_M_h._M_equal_range_tr(__x))
 { return _M_h._M_equal_range_tr(__x); }


      std::pair<const_iterator, const_iterator>
      equal_range(const key_type& __x) const
      { return _M_h.equal_range(__x); }


      template<typename _Kt>
 auto
 equal_range(const _Kt& __x) const
 -> decltype(_M_h._M_equal_range_tr(__x))
 { return _M_h._M_equal_range_tr(__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); }
# 1959 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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); }
# 1974 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_map.h" 3
      local_iterator
      end(size_type __n)
      { return _M_h.end(__n); }
# 1985 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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); }
# 2022 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_map.h" 3
      void
      rehash(size_type __n)
      { _M_h.rehash(__n); }
# 2033 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_map.h" 3
      void
      reserve(size_type __n)
      { _M_h.reserve(__n); }

      template<typename _Key1, typename _Tp1, typename _Hash1, typename _Pred1,
        typename _Alloc1>
        friend bool
 operator==(const unordered_multimap<_Key1, _Tp1,
         _Hash1, _Pred1, _Alloc1>&,
     const unordered_multimap<_Key1, _Tp1,
         _Hash1, _Pred1, _Alloc1>&);
    };



  template<typename _InputIterator,
    typename _Hash = hash<__iter_key_t<_InputIterator>>,
    typename _Pred = equal_to<__iter_key_t<_InputIterator>>,
    typename _Allocator = allocator<__iter_to_alloc_t<_InputIterator>>,
    typename = _RequireInputIter<_InputIterator>,
    typename = _RequireNotAllocatorOrIntegral<_Hash>,
    typename = _RequireNotAllocator<_Pred>,
    typename = _RequireAllocator<_Allocator>>
    unordered_multimap(_InputIterator, _InputIterator,
         unordered_multimap<int, int>::size_type = {},
         _Hash = _Hash(), _Pred = _Pred(),
         _Allocator = _Allocator())
    -> unordered_multimap<__iter_key_t<_InputIterator>,
     __iter_val_t<_InputIterator>, _Hash, _Pred,
     _Allocator>;

  template<typename _Key, typename _Tp, typename _Hash = hash<_Key>,
    typename _Pred = equal_to<_Key>,
    typename _Allocator = allocator<pair<const _Key, _Tp>>,
    typename = _RequireNotAllocatorOrIntegral<_Hash>,
    typename = _RequireNotAllocator<_Pred>,
    typename = _RequireAllocator<_Allocator>>
    unordered_multimap(initializer_list<pair<_Key, _Tp>>,
         unordered_multimap<int, int>::size_type = {},
         _Hash = _Hash(), _Pred = _Pred(),
         _Allocator = _Allocator())
    -> unordered_multimap<_Key, _Tp, _Hash, _Pred, _Allocator>;

  template<typename _InputIterator, typename _Allocator,
    typename = _RequireInputIter<_InputIterator>,
    typename = _RequireAllocator<_Allocator>>
    unordered_multimap(_InputIterator, _InputIterator,
         unordered_multimap<int, int>::size_type, _Allocator)
    -> unordered_multimap<__iter_key_t<_InputIterator>,
     __iter_val_t<_InputIterator>,
     hash<__iter_key_t<_InputIterator>>,
     equal_to<__iter_key_t<_InputIterator>>, _Allocator>;

  template<typename _InputIterator, typename _Allocator,
    typename = _RequireInputIter<_InputIterator>,
    typename = _RequireAllocator<_Allocator>>
    unordered_multimap(_InputIterator, _InputIterator, _Allocator)
    -> unordered_multimap<__iter_key_t<_InputIterator>,
     __iter_val_t<_InputIterator>,
     hash<__iter_key_t<_InputIterator>>,
     equal_to<__iter_key_t<_InputIterator>>, _Allocator>;

  template<typename _InputIterator, typename _Hash, typename _Allocator,
    typename = _RequireInputIter<_InputIterator>,
    typename = _RequireNotAllocatorOrIntegral<_Hash>,
    typename = _RequireAllocator<_Allocator>>
    unordered_multimap(_InputIterator, _InputIterator,
         unordered_multimap<int, int>::size_type, _Hash,
         _Allocator)
    -> unordered_multimap<__iter_key_t<_InputIterator>,
     __iter_val_t<_InputIterator>, _Hash,
     equal_to<__iter_key_t<_InputIterator>>, _Allocator>;

  template<typename _Key, typename _Tp, typename _Allocator,
    typename = _RequireAllocator<_Allocator>>
    unordered_multimap(initializer_list<pair<_Key, _Tp>>,
         unordered_multimap<int, int>::size_type,
         _Allocator)
    -> unordered_multimap<_Key, _Tp, hash<_Key>, equal_to<_Key>, _Allocator>;

  template<typename _Key, typename _Tp, typename _Allocator,
    typename = _RequireAllocator<_Allocator>>
    unordered_multimap(initializer_list<pair<_Key, _Tp>>, _Allocator)
    -> unordered_multimap<_Key, _Tp, hash<_Key>, equal_to<_Key>, _Allocator>;

  template<typename _Key, typename _Tp, typename _Hash, typename _Allocator,
    typename = _RequireNotAllocatorOrIntegral<_Hash>,
    typename = _RequireAllocator<_Allocator>>
    unordered_multimap(initializer_list<pair<_Key, _Tp>>,
         unordered_multimap<int, int>::size_type,
         _Hash, _Allocator)
    -> unordered_multimap<_Key, _Tp, _Hash, equal_to<_Key>, _Allocator>;



  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
    inline void
    swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
  unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
    noexcept(noexcept(__x.swap(__y)))
    { __x.swap(__y); }

  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
    inline void
    swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
  unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
    noexcept(noexcept(__x.swap(__y)))
    { __x.swap(__y); }

  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
    inline bool
    operator==(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
        const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
    { return __x._M_h._M_equal(__y._M_h); }
# 2156 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_map.h" 3
  template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
    inline bool
    operator==(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
        const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
    { return __x._M_h._M_equal(__y._M_h); }
# 2174 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_map.h" 3
  template<typename _Key, typename _Val, typename _Hash1, typename _Eq1,
    typename _Alloc, typename _Hash2, typename _Eq2>
    struct _Hash_merge_helper<
      std::unordered_map<_Key, _Val, _Hash1, _Eq1, _Alloc>,
      _Hash2, _Eq2>
    {
    private:
      template<typename... _Tp>
 using unordered_map = std::unordered_map<_Tp...>;
      template<typename... _Tp>
 using unordered_multimap = std::unordered_multimap<_Tp...>;

      friend unordered_map<_Key, _Val, _Hash1, _Eq1, _Alloc>;

      static auto&
      _S_get_table(unordered_map<_Key, _Val, _Hash2, _Eq2, _Alloc>& __map)
      { return __map._M_h; }

      static auto&
      _S_get_table(unordered_multimap<_Key, _Val, _Hash2, _Eq2, _Alloc>& __map)
      { return __map._M_h; }
    };


  template<typename _Key, typename _Val, typename _Hash1, typename _Eq1,
    typename _Alloc, typename _Hash2, typename _Eq2>
    struct _Hash_merge_helper<
      std::unordered_multimap<_Key, _Val, _Hash1, _Eq1, _Alloc>,
      _Hash2, _Eq2>
    {
    private:
      template<typename... _Tp>
 using unordered_map = std::unordered_map<_Tp...>;
      template<typename... _Tp>
 using unordered_multimap = std::unordered_multimap<_Tp...>;

      friend unordered_multimap<_Key, _Val, _Hash1, _Eq1, _Alloc>;

      static auto&
      _S_get_table(unordered_map<_Key, _Val, _Hash2, _Eq2, _Alloc>& __map)
      { return __map._M_h; }

      static auto&
      _S_get_table(unordered_multimap<_Key, _Val, _Hash2, _Eq2, _Alloc>& __map)
      { return __map._M_h; }
    };



}
# 42 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/unordered_map" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/range_access.h" 1 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/range_access.h" 3






namespace std __attribute__ ((__visibility__ ("default")))
{







  template<typename _Container>
    [[__nodiscard__, __gnu__::__always_inline__]]
    inline constexpr auto
    begin(_Container& __cont) -> decltype(__cont.begin())
    { return __cont.begin(); }






  template<typename _Container>
    [[__nodiscard__, __gnu__::__always_inline__]]
    inline constexpr auto
    begin(const _Container& __cont) -> decltype(__cont.begin())
    { return __cont.begin(); }






  template<typename _Container>
    [[__nodiscard__, __gnu__::__always_inline__]]
    inline constexpr auto
    end(_Container& __cont) -> decltype(__cont.end())
    { return __cont.end(); }






  template<typename _Container>
    [[__nodiscard__, __gnu__::__always_inline__]]
    inline constexpr auto
    end(const _Container& __cont) -> decltype(__cont.end())
    { return __cont.end(); }





  template<typename _Tp, size_t _Nm>
    [[__nodiscard__, __gnu__::__always_inline__]]
    inline constexpr _Tp*
    begin(_Tp (&__arr)[_Nm]) noexcept
    { return __arr; }






  template<typename _Tp, size_t _Nm>
    [[__nodiscard__, __gnu__::__always_inline__]]
    inline constexpr _Tp*
    end(_Tp (&__arr)[_Nm]) noexcept
    { return __arr + _Nm; }



  template<typename _Tp> class valarray;

  template<typename _Tp> _Tp* begin(valarray<_Tp>&) noexcept;
  template<typename _Tp> const _Tp* begin(const valarray<_Tp>&) noexcept;
  template<typename _Tp> _Tp* end(valarray<_Tp>&) noexcept;
  template<typename _Tp> const _Tp* end(const valarray<_Tp>&) noexcept;






  template<typename _Container>
    [[__nodiscard__, __gnu__::__always_inline__]]
    constexpr auto
    cbegin(const _Container& __cont) noexcept(noexcept(std::begin(__cont)))
      -> decltype(std::begin(__cont))
    { return std::begin(__cont); }






  template<typename _Container>
    [[__nodiscard__, __gnu__::__always_inline__]]
    constexpr auto
    cend(const _Container& __cont) noexcept(noexcept(std::end(__cont)))
      -> decltype(std::end(__cont))
    { return std::end(__cont); }






  template<typename _Container>
    [[__nodiscard__, __gnu__::__always_inline__]]
    inline constexpr auto
    rbegin(_Container& __cont) -> decltype(__cont.rbegin())
    { return __cont.rbegin(); }






  template<typename _Container>
    [[__nodiscard__, __gnu__::__always_inline__]]
    inline constexpr auto
    rbegin(const _Container& __cont) -> decltype(__cont.rbegin())
    { return __cont.rbegin(); }






  template<typename _Container>
    [[__nodiscard__, __gnu__::__always_inline__]]
    inline constexpr auto
    rend(_Container& __cont) -> decltype(__cont.rend())
    { return __cont.rend(); }






  template<typename _Container>
    [[__nodiscard__, __gnu__::__always_inline__]]
    inline constexpr auto
    rend(const _Container& __cont) -> decltype(__cont.rend())
    { return __cont.rend(); }






  template<typename _Tp, size_t _Nm>
    [[__nodiscard__]]
    inline constexpr reverse_iterator<_Tp*>
    rbegin(_Tp (&__arr)[_Nm]) noexcept
    { return reverse_iterator<_Tp*>(__arr + _Nm); }






  template<typename _Tp, size_t _Nm>
    [[__nodiscard__]]
    inline constexpr reverse_iterator<_Tp*>
    rend(_Tp (&__arr)[_Nm]) noexcept
    { return reverse_iterator<_Tp*>(__arr); }






  template<typename _Tp>
    [[__nodiscard__]]
    inline constexpr reverse_iterator<const _Tp*>
    rbegin(initializer_list<_Tp> __il) noexcept
    { return reverse_iterator<const _Tp*>(__il.end()); }






  template<typename _Tp>
    [[__nodiscard__]]
    inline constexpr reverse_iterator<const _Tp*>
    rend(initializer_list<_Tp> __il) noexcept
    { return reverse_iterator<const _Tp*>(__il.begin()); }






  template<typename _Container>
    [[__nodiscard__, __gnu__::__always_inline__]]
    inline constexpr auto
    crbegin(const _Container& __cont) -> decltype(std::rbegin(__cont))
    { return std::rbegin(__cont); }






  template<typename _Container>
    [[__nodiscard__, __gnu__::__always_inline__]]
    inline constexpr auto
    crend(const _Container& __cont) -> decltype(std::rend(__cont))
    { return std::rend(__cont); }
# 259 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/range_access.h" 3
  template <typename _Container>
    [[nodiscard, __gnu__::__always_inline__]]
    constexpr auto
    size(const _Container& __cont) noexcept(noexcept(__cont.size()))
    -> decltype(__cont.size())
    { return __cont.size(); }




  template <typename _Tp, size_t _Nm>
    [[nodiscard, __gnu__::__always_inline__]]
    constexpr size_t
    size(const _Tp (&)[_Nm]) noexcept
    { return _Nm; }





  template <typename _Container>
    [[nodiscard, __gnu__::__always_inline__]]
    constexpr auto
    empty(const _Container& __cont) noexcept(noexcept(__cont.empty()))
    -> decltype(__cont.empty())
    { return __cont.empty(); }




  template <typename _Tp, size_t _Nm>
    [[nodiscard, __gnu__::__always_inline__]]
    constexpr bool
    empty(const _Tp (&)[_Nm]) noexcept
    { return false; }





  template <typename _Tp>
    [[nodiscard, __gnu__::__always_inline__]]
    constexpr bool
    empty(initializer_list<_Tp> __il) noexcept
    { return __il.size() == 0;}





  template <typename _Container>
    [[nodiscard, __gnu__::__always_inline__]]
    constexpr auto
    data(_Container& __cont) noexcept(noexcept(__cont.data()))
    -> decltype(__cont.data())
    { return __cont.data(); }





  template <typename _Container>
    [[nodiscard, __gnu__::__always_inline__]]
    constexpr auto
    data(const _Container& __cont) noexcept(noexcept(__cont.data()))
    -> decltype(__cont.data())
    { return __cont.data(); }





  template <typename _Tp, size_t _Nm>
    [[nodiscard, __gnu__::__always_inline__]]
    constexpr _Tp*
    data(_Tp (&__array)[_Nm]) noexcept
    { return __array; }





  template <typename _Tp>
    [[nodiscard, __gnu__::__always_inline__]]
    constexpr const _Tp*
    data(initializer_list<_Tp> __il) noexcept
    { return __il.begin(); }



  template<typename _Container>
    [[nodiscard, __gnu__::__always_inline__]]
    constexpr auto
    ssize(const _Container& __cont)
    noexcept(noexcept(__cont.size()))
    -> common_type_t<ptrdiff_t, make_signed_t<decltype(__cont.size())>>
    {
      using type = make_signed_t<decltype(__cont.size())>;
      return static_cast<common_type_t<ptrdiff_t, type>>(__cont.size());
    }

  template<typename _Tp, ptrdiff_t _Num>
    [[nodiscard, __gnu__::__always_inline__]]
    constexpr ptrdiff_t
    ssize(const _Tp (&)[_Num]) noexcept
    { return _Num; }


}
# 43 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/unordered_map" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/erase_if.h" 1 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/erase_if.h" 3





namespace std
{


  namespace __detail
  {
    template<typename _Container, typename _UnsafeContainer,
      typename _Predicate>
      typename _Container::size_type
      __erase_nodes_if(_Container& __cont, _UnsafeContainer& __ucont,
         _Predicate __pred)
      {
 typename _Container::size_type __num = 0;
 for (auto __iter = __ucont.begin(), __last = __ucont.end();
      __iter != __last;)
   {
     if (__pred(*__iter))
       {
  __iter = __cont.erase(__iter);
  ++__num;
       }
     else
       ++__iter;
   }
 return __num;
      }
  }


}
# 44 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/unordered_map" 2 3
# 55 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/unordered_map" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 56 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/unordered_map" 2 3


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/memory_resource.h" 1 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/memory_resource.h" 3




# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstddef" 1 3
# 43 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstddef" 3







# 1 "/usr/bin/../lib/clang/18/include/stddef.h" 1 3
# 72 "/usr/bin/../lib/clang/18/include/stddef.h" 3
# 1 "/usr/bin/../lib/clang/18/include/__stddef_ptrdiff_t.h" 1 3
# 18 "/usr/bin/../lib/clang/18/include/__stddef_ptrdiff_t.h" 3
typedef long int ptrdiff_t;
# 73 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3




# 1 "/usr/bin/../lib/clang/18/include/__stddef_size_t.h" 1 3
# 18 "/usr/bin/../lib/clang/18/include/__stddef_size_t.h" 3
typedef long unsigned int size_t;
# 78 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3
# 87 "/usr/bin/../lib/clang/18/include/stddef.h" 3
# 1 "/usr/bin/../lib/clang/18/include/__stddef_wchar_t.h" 1 3
# 88 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3




# 1 "/usr/bin/../lib/clang/18/include/__stddef_null.h" 1 3
# 93 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3




# 1 "/usr/bin/../lib/clang/18/include/__stddef_nullptr_t.h" 1 3
# 98 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3
# 107 "/usr/bin/../lib/clang/18/include/stddef.h" 3
# 1 "/usr/bin/../lib/clang/18/include/__stddef_max_align_t.h" 1 3
# 19 "/usr/bin/../lib/clang/18/include/__stddef_max_align_t.h" 3
typedef struct {
  long long __clang_max_align_nonce1
      __attribute__((__aligned__(__alignof__(long long))));
  long double __clang_max_align_nonce2
      __attribute__((__aligned__(__alignof__(long double))));
} max_align_t;
# 108 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3




# 1 "/usr/bin/../lib/clang/18/include/__stddef_offsetof.h" 1 3
# 113 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3
# 51 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstddef" 2 3


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 54 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstddef" 2 3

extern "C++"
{

namespace std
{

  using ::max_align_t;
}



namespace std
{


  enum class byte : unsigned char {};

  template<typename _IntegerType> struct __byte_operand { };
  template<> struct __byte_operand<bool> { using __type = byte; };
  template<> struct __byte_operand<char> { using __type = byte; };
  template<> struct __byte_operand<signed char> { using __type = byte; };
  template<> struct __byte_operand<unsigned char> { using __type = byte; };
  template<> struct __byte_operand<wchar_t> { using __type = byte; };

  template<> struct __byte_operand<char8_t> { using __type = byte; };

  template<> struct __byte_operand<char16_t> { using __type = byte; };
  template<> struct __byte_operand<char32_t> { using __type = byte; };
  template<> struct __byte_operand<short> { using __type = byte; };
  template<> struct __byte_operand<unsigned short> { using __type = byte; };
  template<> struct __byte_operand<int> { using __type = byte; };
  template<> struct __byte_operand<unsigned int> { using __type = byte; };
  template<> struct __byte_operand<long> { using __type = byte; };
  template<> struct __byte_operand<unsigned long> { using __type = byte; };
  template<> struct __byte_operand<long long> { using __type = byte; };
  template<> struct __byte_operand<unsigned long long> { using __type = byte; };

  template<> struct __byte_operand<__int128>
  { using __type = byte; };
  template<> struct __byte_operand<unsigned __int128>
  { using __type = byte; };
# 109 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstddef" 3
  template<typename _IntegerType>
    struct __byte_operand<const _IntegerType>
    : __byte_operand<_IntegerType> { };
  template<typename _IntegerType>
    struct __byte_operand<volatile _IntegerType>
    : __byte_operand<_IntegerType> { };
  template<typename _IntegerType>
    struct __byte_operand<const volatile _IntegerType>
    : __byte_operand<_IntegerType> { };

  template<typename _IntegerType>
    using __byte_op_t = typename __byte_operand<_IntegerType>::__type;

  template<typename _IntegerType>
    [[__gnu__::__always_inline__]]
    constexpr __byte_op_t<_IntegerType>
    operator<<(byte __b, _IntegerType __shift) noexcept
    { return (byte)(unsigned char)((unsigned)__b << __shift); }

  template<typename _IntegerType>
    [[__gnu__::__always_inline__]]
    constexpr __byte_op_t<_IntegerType>
    operator>>(byte __b, _IntegerType __shift) noexcept
    { return (byte)(unsigned char)((unsigned)__b >> __shift); }

  [[__gnu__::__always_inline__]]
  constexpr byte
  operator|(byte __l, byte __r) noexcept
  { return (byte)(unsigned char)((unsigned)__l | (unsigned)__r); }

  [[__gnu__::__always_inline__]]
  constexpr byte
  operator&(byte __l, byte __r) noexcept
  { return (byte)(unsigned char)((unsigned)__l & (unsigned)__r); }

  [[__gnu__::__always_inline__]]
  constexpr byte
  operator^(byte __l, byte __r) noexcept
  { return (byte)(unsigned char)((unsigned)__l ^ (unsigned)__r); }

  [[__gnu__::__always_inline__]]
  constexpr byte
  operator~(byte __b) noexcept
  { return (byte)(unsigned char)~(unsigned)__b; }

  template<typename _IntegerType>
    [[__gnu__::__always_inline__]]
    constexpr __byte_op_t<_IntegerType>&
    operator<<=(byte& __b, _IntegerType __shift) noexcept
    { return __b = __b << __shift; }

  template<typename _IntegerType>
    [[__gnu__::__always_inline__]]
    constexpr __byte_op_t<_IntegerType>&
    operator>>=(byte& __b, _IntegerType __shift) noexcept
    { return __b = __b >> __shift; }

  [[__gnu__::__always_inline__]]
  constexpr byte&
  operator|=(byte& __l, byte __r) noexcept
  { return __l = __l | __r; }

  [[__gnu__::__always_inline__]]
  constexpr byte&
  operator&=(byte& __l, byte __r) noexcept
  { return __l = __l & __r; }

  [[__gnu__::__always_inline__]]
  constexpr byte&
  operator^=(byte& __l, byte __r) noexcept
  { return __l = __l ^ __r; }

  template<typename _IntegerType>
    [[nodiscard,__gnu__::__always_inline__]]
    constexpr _IntegerType
    to_integer(__byte_op_t<_IntegerType> __b) noexcept
    { return _IntegerType(__b); }


}

}
# 39 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/memory_resource.h" 2 3


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/uses_allocator_args.h" 1 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/uses_allocator_args.h" 3

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 36 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/uses_allocator_args.h" 2 3







namespace std __attribute__ ((__visibility__ ("default")))
{


  template<typename _Tp>
    concept _Std_pair = __is_pair<remove_cv_t<_Tp>>;




  template<typename _Tp, typename _Alloc, typename... _Args>
    constexpr auto
    uses_allocator_construction_args(const _Alloc& __a,
         _Args&&... __args) noexcept
    requires (! _Std_pair<_Tp>)
    {
      if constexpr (uses_allocator_v<remove_cv_t<_Tp>, _Alloc>)
 {
   if constexpr (is_constructible_v<_Tp, allocator_arg_t,
        const _Alloc&, _Args...>)
     {
       return tuple<allocator_arg_t, const _Alloc&, _Args&&...>(
    allocator_arg, __a, std::forward<_Args>(__args)...);
     }
   else
     {
       static_assert(is_constructible_v<_Tp, _Args..., const _Alloc&>,
    "construction with an allocator must be possible"
    " if uses_allocator is true");

       return tuple<_Args&&..., const _Alloc&>(
    std::forward<_Args>(__args)..., __a);
     }
 }
      else
 {
   static_assert(is_constructible_v<_Tp, _Args...>);

   return tuple<_Args&&...>(std::forward<_Args>(__args)...);
 }
    }

  template<_Std_pair _Tp, typename _Alloc, typename _Tuple1, typename _Tuple2>
    constexpr auto
    uses_allocator_construction_args(const _Alloc& __a, piecewise_construct_t,
         _Tuple1&& __x, _Tuple2&& __y) noexcept;

  template<_Std_pair _Tp, typename _Alloc>
    constexpr auto
    uses_allocator_construction_args(const _Alloc&) noexcept;

  template<_Std_pair _Tp, typename _Alloc, typename _Up, typename _Vp>
    constexpr auto
    uses_allocator_construction_args(const _Alloc&, _Up&&, _Vp&&) noexcept;

  template<_Std_pair _Tp, typename _Alloc, typename _Up, typename _Vp>
    constexpr auto
    uses_allocator_construction_args(const _Alloc&,
         const pair<_Up, _Vp>&) noexcept;

  template<_Std_pair _Tp, typename _Alloc, typename _Up, typename _Vp>
    constexpr auto
    uses_allocator_construction_args(const _Alloc&, pair<_Up, _Vp>&&) noexcept;


  template<_Std_pair _Tp, typename _Alloc, typename _Up, typename _Vp>
    constexpr auto
    uses_allocator_construction_args(const _Alloc&,
         pair<_Up, _Vp>&) noexcept;

  template<_Std_pair _Tp, typename _Alloc, typename _Up, typename _Vp>
    constexpr auto
    uses_allocator_construction_args(const _Alloc&, const pair<_Up, _Vp>&&) noexcept;


  template<_Std_pair _Tp, typename _Alloc, typename _Tuple1, typename _Tuple2>
    constexpr auto
    uses_allocator_construction_args(const _Alloc& __a, piecewise_construct_t,
         _Tuple1&& __x, _Tuple2&& __y) noexcept
    {
      using _Tp1 = typename _Tp::first_type;
      using _Tp2 = typename _Tp::second_type;

      return std::make_tuple(piecewise_construct,
   std::apply([&__a](auto&&... __args1) {
       return std::uses_allocator_construction_args<_Tp1>(
    __a, std::forward<decltype(__args1)>(__args1)...);
   }, std::forward<_Tuple1>(__x)),
   std::apply([&__a](auto&&... __args2) {
       return std::uses_allocator_construction_args<_Tp2>(
    __a, std::forward<decltype(__args2)>(__args2)...);
   }, std::forward<_Tuple2>(__y)));
    }

  template<_Std_pair _Tp, typename _Alloc>
    constexpr auto
    uses_allocator_construction_args(const _Alloc& __a) noexcept
    {
      using _Tp1 = typename _Tp::first_type;
      using _Tp2 = typename _Tp::second_type;

      return std::make_tuple(piecewise_construct,
   std::uses_allocator_construction_args<_Tp1>(__a),
   std::uses_allocator_construction_args<_Tp2>(__a));
    }

  template<_Std_pair _Tp, typename _Alloc, typename _Up, typename _Vp>
    constexpr auto
    uses_allocator_construction_args(const _Alloc& __a, _Up&& __u, _Vp&& __v)
      noexcept
    {
      using _Tp1 = typename _Tp::first_type;
      using _Tp2 = typename _Tp::second_type;

      return std::make_tuple(piecewise_construct,
   std::uses_allocator_construction_args<_Tp1>(__a,
     std::forward<_Up>(__u)),
   std::uses_allocator_construction_args<_Tp2>(__a,
     std::forward<_Vp>(__v)));
    }

  template<_Std_pair _Tp, typename _Alloc, typename _Up, typename _Vp>
    constexpr auto
    uses_allocator_construction_args(const _Alloc& __a,
         const pair<_Up, _Vp>& __pr) noexcept
    {
      using _Tp1 = typename _Tp::first_type;
      using _Tp2 = typename _Tp::second_type;

      return std::make_tuple(piecewise_construct,
   std::uses_allocator_construction_args<_Tp1>(__a, __pr.first),
   std::uses_allocator_construction_args<_Tp2>(__a, __pr.second));
    }

  template<_Std_pair _Tp, typename _Alloc, typename _Up, typename _Vp>
    constexpr auto
    uses_allocator_construction_args(const _Alloc& __a,
         pair<_Up, _Vp>&& __pr) noexcept
    {
      using _Tp1 = typename _Tp::first_type;
      using _Tp2 = typename _Tp::second_type;




      return std::make_tuple(piecewise_construct,
   std::uses_allocator_construction_args<_Tp1>(__a,
     std::get<0>(std::move(__pr))),
   std::uses_allocator_construction_args<_Tp2>(__a,
     std::get<1>(std::move(__pr))));
    }


  template<_Std_pair _Tp, typename _Alloc, typename _Up, typename _Vp>
    constexpr auto
    uses_allocator_construction_args(const _Alloc& __a,
         pair<_Up, _Vp>& __pr) noexcept
    {
      using _Tp1 = typename _Tp::first_type;
      using _Tp2 = typename _Tp::second_type;

      return std::make_tuple(piecewise_construct,
   std::uses_allocator_construction_args<_Tp1>(__a, __pr.first),
   std::uses_allocator_construction_args<_Tp2>(__a, __pr.second));
    }

  template<_Std_pair _Tp, typename _Alloc, typename _Up, typename _Vp>
    constexpr auto
    uses_allocator_construction_args(const _Alloc& __a,
         const pair<_Up, _Vp>&& __pr) noexcept
    {
      using _Tp1 = typename _Tp::first_type;
      using _Tp2 = typename _Tp::second_type;

      return std::make_tuple(piecewise_construct,
   std::uses_allocator_construction_args<_Tp1>(__a,
     std::get<0>(std::move(__pr))),
   std::uses_allocator_construction_args<_Tp2>(__a,
     std::get<1>(std::move(__pr))));
    }


  template<typename _Tp, typename _Alloc, typename... _Args>
    constexpr _Tp
    make_obj_using_allocator(const _Alloc& __a, _Args&&... __args)
    {
      return std::make_from_tuple<_Tp>(
   std::uses_allocator_construction_args<_Tp>(__a,
     std::forward<_Args>(__args)...));
    }

  template<typename _Tp, typename _Alloc, typename... _Args>
    constexpr _Tp*
    uninitialized_construct_using_allocator(_Tp* __p, const _Alloc& __a,
         _Args&&... __args)
    {
      return std::apply([&](auto&&... __xs) {
 return std::construct_at(__p, std::forward<decltype(__xs)>(__xs)...);
      }, std::uses_allocator_construction_args<_Tp>(__a,
 std::forward<_Args>(__args)...));
    }


}
# 42 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/memory_resource.h" 2 3








namespace std __attribute__ ((__visibility__ ("default")))
{

namespace pmr
{






  class memory_resource
  {
    static constexpr size_t _S_max_align = alignof(max_align_t);

  public:
    memory_resource() = default;
    memory_resource(const memory_resource&) = default;
    virtual ~memory_resource();

    memory_resource& operator=(const memory_resource&) = default;

    [[nodiscard]]
    void*
    allocate(size_t __bytes, size_t __alignment = _S_max_align)
    __attribute__((__returns_nonnull__,__alloc_size__(2),__alloc_align__(3)))
    { return ::operator new(__bytes, do_allocate(__bytes, __alignment)); }

    void
    deallocate(void* __p, size_t __bytes, size_t __alignment = _S_max_align)
    __attribute__((__nonnull__))
    { return do_deallocate(__p, __bytes, __alignment); }

    [[nodiscard]]
    bool
    is_equal(const memory_resource& __other) const noexcept
    { return do_is_equal(__other); }

  private:
    virtual void*
    do_allocate(size_t __bytes, size_t __alignment) = 0;

    virtual void
    do_deallocate(void* __p, size_t __bytes, size_t __alignment) = 0;

    virtual bool
    do_is_equal(const memory_resource& __other) const noexcept = 0;
  };

  [[nodiscard]]
  inline bool
  operator==(const memory_resource& __a, const memory_resource& __b) noexcept
  { return &__a == &__b || __a.is_equal(__b); }
# 119 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/memory_resource.h" 3
  template<typename _Tp>
    class polymorphic_allocator
    {


      template<typename _Up>
 struct __not_pair { using type = void; };

      template<typename _Up1, typename _Up2>
 struct __not_pair<pair<_Up1, _Up2>> { };

    public:
      using value_type = _Tp;

      polymorphic_allocator() noexcept
      {
 extern memory_resource* get_default_resource() noexcept
   __attribute__((__returns_nonnull__));
 _M_resource = get_default_resource();
      }

      polymorphic_allocator(memory_resource* __r) noexcept
      __attribute__((__nonnull__))
      : _M_resource(__r)
      { ; }

      polymorphic_allocator(const polymorphic_allocator& __other) = default;

      template<typename _Up>
 polymorphic_allocator(const polymorphic_allocator<_Up>& __x) noexcept
 : _M_resource(__x.resource())
 { }

      polymorphic_allocator&
      operator=(const polymorphic_allocator&) = delete;

      [[nodiscard]]
      _Tp*
      allocate(size_t __n)
      __attribute__((__returns_nonnull__))
      {
 if ((__gnu_cxx::__int_traits<size_t>::__max / sizeof(_Tp)) < __n)
   std::__throw_bad_array_new_length();
 return static_cast<_Tp*>(_M_resource->allocate(__n * sizeof(_Tp),
             alignof(_Tp)));
      }

      void
      deallocate(_Tp* __p, size_t __n) noexcept
      __attribute__((__nonnull__))
      { _M_resource->deallocate(__p, __n * sizeof(_Tp), alignof(_Tp)); }


      [[nodiscard]] void*
      allocate_bytes(size_t __nbytes,
       size_t __alignment = alignof(max_align_t))
      { return _M_resource->allocate(__nbytes, __alignment); }

      void
      deallocate_bytes(void* __p, size_t __nbytes,
         size_t __alignment = alignof(max_align_t))
      { _M_resource->deallocate(__p, __nbytes, __alignment); }

      template<typename _Up>
 [[nodiscard]] _Up*
 allocate_object(size_t __n = 1)
 {
   if ((__gnu_cxx::__int_traits<size_t>::__max / sizeof(_Up)) < __n)
     std::__throw_bad_array_new_length();
   return static_cast<_Up*>(allocate_bytes(__n * sizeof(_Up),
        alignof(_Up)));
 }

      template<typename _Up>
 void
 deallocate_object(_Up* __p, size_t __n = 1)
 { deallocate_bytes(__p, __n * sizeof(_Up), alignof(_Up)); }

      template<typename _Up, typename... _CtorArgs>
 [[nodiscard]] _Up*
 new_object(_CtorArgs&&... __ctor_args)
 {
   _Up* __p = allocate_object<_Up>();
   try
     {
       construct(__p, std::forward<_CtorArgs>(__ctor_args)...);
     }
   catch(...)
     {
       deallocate_object(__p);
       throw;
     }
   return __p;
 }

      template<typename _Up>
 void
 delete_object(_Up* __p)
 {
   __p->~_Up();
   deallocate_object(__p);
 }
# 297 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/memory_resource.h" 3
      template<typename _Tp1, typename... _Args>
 __attribute__((__nonnull__))
 void
 construct(_Tp1* __p, _Args&&... __args)
 {
   std::uninitialized_construct_using_allocator(__p, *this,
       std::forward<_Args>(__args)...);
 }


      template<typename _Up>
 __attribute__ ((__deprecated__ ("use '" "allocator_traits::destroy" "' instead")))
 __attribute__((__nonnull__))
 void
 destroy(_Up* __p)
 { __p->~_Up(); }

      polymorphic_allocator
      select_on_container_copy_construction() const noexcept
      { return polymorphic_allocator(); }

      memory_resource*
      resource() const noexcept
      __attribute__((__returns_nonnull__))
      { return _M_resource; }



      [[nodiscard]]
      friend bool
      operator==(const polymorphic_allocator& __a,
   const polymorphic_allocator& __b) noexcept
      { return *__a.resource() == *__b.resource(); }
# 339 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/memory_resource.h" 3
    private:
# 366 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/memory_resource.h" 3
      memory_resource* _M_resource;
    };

  template<typename _Tp1, typename _Tp2>
    [[nodiscard]]
    inline bool
    operator==(const polymorphic_allocator<_Tp1>& __a,
        const polymorphic_allocator<_Tp2>& __b) noexcept
    { return *__a.resource() == *__b.resource(); }
# 385 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/memory_resource.h" 3
}

  template<typename _Alloc> struct allocator_traits;


  template<typename _Tp>
    struct allocator_traits<pmr::polymorphic_allocator<_Tp>>
    {

      using allocator_type = pmr::polymorphic_allocator<_Tp>;


      using value_type = _Tp;


      using pointer = _Tp*;


      using const_pointer = const _Tp*;


      using void_pointer = void*;


      using const_void_pointer = const void*;


      using difference_type = std::ptrdiff_t;


      using size_type = std::size_t;





      using propagate_on_container_copy_assignment = false_type;
      using propagate_on_container_move_assignment = false_type;
      using propagate_on_container_swap = false_type;

      static allocator_type
      select_on_container_copy_construction(const allocator_type&) noexcept
      { return allocator_type(); }



      using is_always_equal = false_type;

      template<typename _Up>
 using rebind_alloc = pmr::polymorphic_allocator<_Up>;

      template<typename _Up>
 using rebind_traits = allocator_traits<pmr::polymorphic_allocator<_Up>>;
# 446 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/memory_resource.h" 3
      [[nodiscard]] static pointer
      allocate(allocator_type& __a, size_type __n)
      { return __a.allocate(__n); }
# 461 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/memory_resource.h" 3
      [[nodiscard]] static pointer
      allocate(allocator_type& __a, size_type __n, const_void_pointer)
      { return __a.allocate(__n); }
# 473 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/memory_resource.h" 3
      static void
      deallocate(allocator_type& __a, pointer __p, size_type __n)
      { __a.deallocate(__p, __n); }
# 488 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/memory_resource.h" 3
      template<typename _Up, typename... _Args>
 static void
 construct(allocator_type& __a, _Up* __p, _Args&&... __args)
 { __a.construct(__p, std::forward<_Args>(__args)...); }
# 500 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/memory_resource.h" 3
      template<typename _Up>
 static constexpr void
 destroy(allocator_type&, _Up* __p)
 noexcept(is_nothrow_destructible<_Up>::value)
 { __p->~_Up(); }





      static constexpr size_type
      max_size(const allocator_type&) noexcept
      { return size_t(-1) / sizeof(value_type); }
    };


}
# 59 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/unordered_map" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{

  namespace pmr
  {
    template<typename _Key, typename _Tp, typename _Hash = std::hash<_Key>,
      typename _Pred = std::equal_to<_Key>>
      using unordered_map
 = std::unordered_map<_Key, _Tp, _Hash, _Pred,
        polymorphic_allocator<pair<const _Key, _Tp>>>;
    template<typename _Key, typename _Tp, typename _Hash = std::hash<_Key>,
      typename _Pred = std::equal_to<_Key>>
      using unordered_multimap
 = std::unordered_multimap<_Key, _Tp, _Hash, _Pred,
      polymorphic_allocator<pair<const _Key, _Tp>>>;
  }

}



namespace std __attribute__ ((__visibility__ ("default")))
{

  template<typename _Key, typename _Tp, typename _Hash, typename _CPred,
    typename _Alloc, typename _Predicate>
    inline typename unordered_map<_Key, _Tp, _Hash, _CPred, _Alloc>::size_type
    erase_if(unordered_map<_Key, _Tp, _Hash, _CPred, _Alloc>& __cont,
      _Predicate __pred)
    {
      std::unordered_map<_Key, _Tp, _Hash, _CPred, _Alloc>&
 __ucont = __cont;
      return __detail::__erase_nodes_if(__cont, __ucont, __pred);
    }

  template<typename _Key, typename _Tp, typename _Hash, typename _CPred,
    typename _Alloc, typename _Predicate>
    inline typename unordered_multimap<_Key, _Tp, _Hash, _CPred, _Alloc>::
      size_type
    erase_if(unordered_multimap<_Key, _Tp, _Hash, _CPred, _Alloc>& __cont,
      _Predicate __pred)
    {
      std::unordered_multimap<_Key, _Tp, _Hash, _CPred, _Alloc>&
 __ucont = __cont;
      return __detail::__erase_nodes_if(__cont, __ucont, __pred);
    }

}
# 25 "/home/avi/scylla-maint/seastar/include/seastar/rpc/rpc.hh" 2
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/unordered_set" 1 3
# 33 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/unordered_set" 3








# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_set.h" 1 3
# 38 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_set.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{




  template<bool _Cache>
    using __uset_traits = __detail::_Hashtable_traits<_Cache, true, true>;

  template<typename _Value,
    typename _Hash = hash<_Value>,
    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<bool _Cache>
    using __umset_traits = __detail::_Hashtable_traits<_Cache, true, false>;

  template<typename _Value,
    typename _Hash = hash<_Value>,
    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 _Value, class _Hash, class _Pred, class _Alloc>
    class unordered_multiset;
# 100 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_set.h" 3
  template<typename _Value,
    typename _Hash = hash<_Value>,
    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;
# 151 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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)
      { }
# 172 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_set.h" 3
      template<typename _InputIterator>
 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)
 noexcept( noexcept(_Hashtable(std::move(__uset._M_h), __a)) )
      : _M_h(std::move(__uset._M_h), __a)
      { }
# 228 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_set.h" 3
      unordered_set(initializer_list<value_type> __l,
      size_type __n = 0,
      const hasher& __hf = hasher(),
      const key_equal& __eql = key_equal(),
      const allocator_type& __a = allocator_type())
      : _M_h(__l, __n, __hf, __eql, __a)
      { }

      unordered_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<typename _InputIterator>
 unordered_set(_InputIterator __first, _InputIterator __last,
        size_type __n,
        const allocator_type& __a)
 : unordered_set(__first, __last, __n, hasher(), key_equal(), __a)
 { }

      template<typename _InputIterator>
 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<value_type> __l,
      size_type __n,
      const allocator_type& __a)
      : unordered_set(__l, __n, hasher(), key_equal(), __a)
      { }

      unordered_set(initializer_list<value_type> __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;
# 290 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_set.h" 3
      unordered_set&
      operator=(initializer_list<value_type> __l)
      {
 _M_h = __l;
 return *this;
      }


      allocator_type
      get_allocator() const noexcept
      { return _M_h.get_allocator(); }




      [[__nodiscard__]] bool
      empty() const noexcept
      { return _M_h.empty(); }


      size_type
      size() const noexcept
      { return _M_h.size(); }


      size_type
      max_size() const noexcept
      { return _M_h.max_size(); }
# 326 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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(); }
# 382 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_set.h" 3
      template<typename... _Args>
 std::pair<iterator, bool>
 emplace(_Args&&... __args)
 { return _M_h.emplace(std::forward<_Args>(__args)...); }
# 408 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_set.h" 3
      template<typename... _Args>
 iterator
 emplace_hint(const_iterator __pos, _Args&&... __args)
 { return _M_h.emplace_hint(__pos, std::forward<_Args>(__args)...); }
# 427 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_set.h" 3
      std::pair<iterator, bool>
      insert(const value_type& __x)
      { return _M_h.insert(__x); }

      std::pair<iterator, bool>
      insert(value_type&& __x)
      { return _M_h.insert(std::move(__x)); }
# 456 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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)); }
# 474 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_set.h" 3
      template<typename _InputIterator>
 void
 insert(_InputIterator __first, _InputIterator __last)
 { _M_h.insert(__first, __last); }
# 486 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_set.h" 3
      void
      insert(initializer_list<value_type> __l)
      { _M_h.insert(__l); }



      node_type
      extract(const_iterator __pos)
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__pos != end()), false)) std::__glibcxx_assert_fail(); } while (false);
 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; }
# 529 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_set.h" 3
      iterator
      erase(const_iterator __position)
      { return _M_h.erase(__position); }


      iterator
      erase(iterator __position)
      { return _M_h.erase(__position); }
# 551 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_set.h" 3
      size_type
      erase(const key_type& __x)
      { return _M_h.erase(__x); }
# 569 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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(); }
# 592 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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<typename, typename, typename>
 friend class std::_Hash_merge_helper;

      template<typename _H2, typename _P2>
 void
 merge(unordered_set<_Value, _H2, _P2, _Alloc>& __source)
 {
   using _Merge_helper = _Hash_merge_helper<unordered_set, _H2, _P2>;
   _M_h._M_merge_unique(_Merge_helper::_S_get_table(__source));
 }

      template<typename _H2, typename _P2>
 void
 merge(unordered_set<_Value, _H2, _P2, _Alloc>&& __source)
 { merge(__source); }

      template<typename _H2, typename _P2>
 void
 merge(unordered_multiset<_Value, _H2, _P2, _Alloc>& __source)
 {
   using _Merge_helper = _Hash_merge_helper<unordered_set, _H2, _P2>;
   _M_h._M_merge_unique(_Merge_helper::_S_get_table(__source));
 }

      template<typename _H2, typename _P2>
 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(); }
# 656 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_set.h" 3
      iterator
      find(const key_type& __x)
      { return _M_h.find(__x); }


      template<typename _Kt>
 auto
 find(const _Kt& __k)
 -> decltype(_M_h._M_find_tr(__k))
 { return _M_h._M_find_tr(__k); }


      const_iterator
      find(const key_type& __x) const
      { return _M_h.find(__x); }


      template<typename _Kt>
 auto
 find(const _Kt& __k) const
 -> decltype(_M_h._M_find_tr(__k))
 { return _M_h._M_find_tr(__k); }
# 691 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_set.h" 3
      size_type
      count(const key_type& __x) const
      { return _M_h.count(__x); }


      template<typename _Kt>
 auto
 count(const _Kt& __k) const
 -> decltype(_M_h._M_count_tr(__k))
 { return _M_h._M_count_tr(__k); }
# 711 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_set.h" 3
      bool
      contains(const key_type& __x) const
      { return _M_h.find(__x) != _M_h.end(); }

      template<typename _Kt>
 auto
 contains(const _Kt& __k) const
 -> decltype(_M_h._M_find_tr(__k), void(), true)
 { return _M_h._M_find_tr(__k) != _M_h.end(); }
# 732 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_set.h" 3
      std::pair<iterator, iterator>
      equal_range(const key_type& __x)
      { return _M_h.equal_range(__x); }


      template<typename _Kt>
 auto
 equal_range(const _Kt& __k)
 -> decltype(_M_h._M_equal_range_tr(__k))
 { return _M_h._M_equal_range_tr(__k); }


      std::pair<const_iterator, const_iterator>
      equal_range(const key_type& __x) const
      { return _M_h.equal_range(__x); }


      template<typename _Kt>
 auto
 equal_range(const _Kt& __k) const
 -> decltype(_M_h._M_equal_range_tr(__k))
 { return _M_h._M_equal_range_tr(__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); }
# 794 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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); }
# 814 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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); }
# 855 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_set.h" 3
      void
      rehash(size_type __n)
      { _M_h.rehash(__n); }
# 866 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_set.h" 3
      void
      reserve(size_type __n)
      { _M_h.reserve(__n); }

      template<typename _Value1, typename _Hash1, typename _Pred1,
        typename _Alloc1>
        friend bool
        operator==(const unordered_set<_Value1, _Hash1, _Pred1, _Alloc1>&,
     const unordered_set<_Value1, _Hash1, _Pred1, _Alloc1>&);
    };



  template<typename _InputIterator,
    typename _Hash =
      hash<typename iterator_traits<_InputIterator>::value_type>,
    typename _Pred =
      equal_to<typename iterator_traits<_InputIterator>::value_type>,
    typename _Allocator =
      allocator<typename iterator_traits<_InputIterator>::value_type>,
    typename = _RequireInputIter<_InputIterator>,
    typename = _RequireNotAllocatorOrIntegral<_Hash>,
    typename = _RequireNotAllocator<_Pred>,
    typename = _RequireAllocator<_Allocator>>
    unordered_set(_InputIterator, _InputIterator,
    unordered_set<int>::size_type = {},
    _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())
    -> unordered_set<typename iterator_traits<_InputIterator>::value_type,
       _Hash, _Pred, _Allocator>;

  template<typename _Tp, typename _Hash = hash<_Tp>,
    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<int>::size_type = {},
    _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())
    -> unordered_set<_Tp, _Hash, _Pred, _Allocator>;

  template<typename _InputIterator, typename _Allocator,
    typename = _RequireInputIter<_InputIterator>,
    typename = _RequireAllocator<_Allocator>>
    unordered_set(_InputIterator, _InputIterator,
    unordered_set<int>::size_type, _Allocator)
    -> unordered_set<typename iterator_traits<_InputIterator>::value_type,
       hash<
         typename iterator_traits<_InputIterator>::value_type>,
       equal_to<
         typename iterator_traits<_InputIterator>::value_type>,
       _Allocator>;

  template<typename _InputIterator, typename _Hash, typename _Allocator,
    typename = _RequireInputIter<_InputIterator>,
    typename = _RequireNotAllocatorOrIntegral<_Hash>,
    typename = _RequireAllocator<_Allocator>>
    unordered_set(_InputIterator, _InputIterator,
    unordered_set<int>::size_type,
    _Hash, _Allocator)
    -> unordered_set<typename iterator_traits<_InputIterator>::value_type,
       _Hash,
       equal_to<
         typename iterator_traits<_InputIterator>::value_type>,
       _Allocator>;

  template<typename _Tp, typename _Allocator,
    typename = _RequireAllocator<_Allocator>>
    unordered_set(initializer_list<_Tp>,
    unordered_set<int>::size_type, _Allocator)
    -> unordered_set<_Tp, hash<_Tp>, equal_to<_Tp>, _Allocator>;

  template<typename _Tp, typename _Hash, typename _Allocator,
    typename = _RequireNotAllocatorOrIntegral<_Hash>,
    typename = _RequireAllocator<_Allocator>>
    unordered_set(initializer_list<_Tp>,
    unordered_set<int>::size_type, _Hash, _Allocator)
    -> unordered_set<_Tp, _Hash, equal_to<_Tp>, _Allocator>;
# 968 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_set.h" 3
  template<typename _Value,
    typename _Hash = hash<_Value>,
    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;
# 1018 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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)
      { }
# 1039 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_set.h" 3
      template<typename _InputIterator>
 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;
# 1065 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_set.h" 3
      unordered_multiset(initializer_list<value_type> __l,
    size_type __n = 0,
    const hasher& __hf = hasher(),
    const key_equal& __eql = key_equal(),
    const allocator_type& __a = allocator_type())
      : _M_h(__l, __n, __hf, __eql, __a)
      { }


      unordered_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)
 noexcept( noexcept(_Hashtable(std::move(__umset._M_h), __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<typename _InputIterator>
 unordered_multiset(_InputIterator __first, _InputIterator __last,
      size_type __n,
      const allocator_type& __a)
 : unordered_multiset(__first, __last, __n, hasher(), key_equal(), __a)
 { }

      template<typename _InputIterator>
 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<value_type> __l,
    size_type __n,
    const allocator_type& __a)
      : unordered_multiset(__l, __n, hasher(), key_equal(), __a)
      { }

      unordered_multiset(initializer_list<value_type> __l,
    size_type __n, const hasher& __hf,
    const allocator_type& __a)
      : unordered_multiset(__l, __n, __hf, key_equal(), __a)
      { }
# 1157 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_set.h" 3
      unordered_multiset&
      operator=(initializer_list<value_type> __l)
      {
 _M_h = __l;
 return *this;
      }


      allocator_type
      get_allocator() const noexcept
      { return _M_h.get_allocator(); }




      [[__nodiscard__]] bool
      empty() const noexcept
      { return _M_h.empty(); }


      size_type
      size() const noexcept
      { return _M_h.size(); }


      size_type
      max_size() const noexcept
      { return _M_h.max_size(); }
# 1193 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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(); }
# 1241 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_set.h" 3
      template<typename... _Args>
 iterator
 emplace(_Args&&... __args)
 { return _M_h.emplace(std::forward<_Args>(__args)...); }
# 1263 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_set.h" 3
      template<typename... _Args>
 iterator
 emplace_hint(const_iterator __pos, _Args&&... __args)
 { return _M_h.emplace_hint(__pos, std::forward<_Args>(__args)...); }
# 1276 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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)); }
# 1302 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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)); }
# 1319 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_set.h" 3
      template<typename _InputIterator>
 void
 insert(_InputIterator __first, _InputIterator __last)
 { _M_h.insert(__first, __last); }
# 1331 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_set.h" 3
      void
      insert(initializer_list<value_type> __l)
      { _M_h.insert(__l); }



      node_type
      extract(const_iterator __pos)
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__pos != end()), false)) std::__glibcxx_assert_fail(); } while (false);
 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)); }
# 1375 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_set.h" 3
      iterator
      erase(const_iterator __position)
      { return _M_h.erase(__position); }


      iterator
      erase(iterator __position)
      { return _M_h.erase(__position); }
# 1398 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_set.h" 3
      size_type
      erase(const key_type& __x)
      { return _M_h.erase(__x); }
# 1418 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_set.h" 3
      iterator
      erase(const_iterator __first, const_iterator __last)
      { return _M_h.erase(__first, __last); }
# 1429 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_set.h" 3
      void
      clear() noexcept
      { _M_h.clear(); }
# 1442 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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<typename, typename, typename>
 friend class std::_Hash_merge_helper;

      template<typename _H2, typename _P2>
 void
 merge(unordered_multiset<_Value, _H2, _P2, _Alloc>& __source)
 {
   using _Merge_helper
     = _Hash_merge_helper<unordered_multiset, _H2, _P2>;
   _M_h._M_merge_multi(_Merge_helper::_S_get_table(__source));
 }

      template<typename _H2, typename _P2>
 void
 merge(unordered_multiset<_Value, _H2, _P2, _Alloc>&& __source)
 { merge(__source); }

      template<typename _H2, typename _P2>
 void
 merge(unordered_set<_Value, _H2, _P2, _Alloc>& __source)
 {
   using _Merge_helper
     = _Hash_merge_helper<unordered_multiset, _H2, _P2>;
   _M_h._M_merge_multi(_Merge_helper::_S_get_table(__source));
 }

      template<typename _H2, typename _P2>
 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(); }
# 1508 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_set.h" 3
      iterator
      find(const key_type& __x)
      { return _M_h.find(__x); }


      template<typename _Kt>
 auto
 find(const _Kt& __x)
 -> decltype(_M_h._M_find_tr(__x))
 { return _M_h._M_find_tr(__x); }


      const_iterator
      find(const key_type& __x) const
      { return _M_h.find(__x); }


      template<typename _Kt>
 auto
 find(const _Kt& __x) const
 -> decltype(_M_h._M_find_tr(__x))
 { return _M_h._M_find_tr(__x); }
# 1539 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_set.h" 3
      size_type
      count(const key_type& __x) const
      { return _M_h.count(__x); }


      template<typename _Kt>
 auto
 count(const _Kt& __x) const -> decltype(_M_h._M_count_tr(__x))
 { return _M_h._M_count_tr(__x); }
# 1558 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_set.h" 3
      bool
      contains(const key_type& __x) const
      { return _M_h.find(__x) != _M_h.end(); }

      template<typename _Kt>
 auto
 contains(const _Kt& __x) const
 -> decltype(_M_h._M_find_tr(__x), void(), true)
 { return _M_h._M_find_tr(__x) != _M_h.end(); }
# 1577 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_set.h" 3
      std::pair<iterator, iterator>
      equal_range(const key_type& __x)
      { return _M_h.equal_range(__x); }


      template<typename _Kt>
 auto
 equal_range(const _Kt& __x)
 -> decltype(_M_h._M_equal_range_tr(__x))
 { return _M_h._M_equal_range_tr(__x); }


      std::pair<const_iterator, const_iterator>
      equal_range(const key_type& __x) const
      { return _M_h.equal_range(__x); }


      template<typename _Kt>
 auto
 equal_range(const _Kt& __x) const
 -> decltype(_M_h._M_equal_range_tr(__x))
 { return _M_h._M_equal_range_tr(__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); }
# 1639 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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); }
# 1659 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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); }
# 1700 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_set.h" 3
      void
      rehash(size_type __n)
      { _M_h.rehash(__n); }
# 1711 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_set.h" 3
      void
      reserve(size_type __n)
      { _M_h.reserve(__n); }

      template<typename _Value1, typename _Hash1, typename _Pred1,
        typename _Alloc1>
        friend bool
      operator==(const unordered_multiset<_Value1, _Hash1, _Pred1, _Alloc1>&,
   const unordered_multiset<_Value1, _Hash1, _Pred1, _Alloc1>&);
    };




  template<typename _InputIterator,
    typename _Hash =
      hash<typename iterator_traits<_InputIterator>::value_type>,
    typename _Pred =
      equal_to<typename iterator_traits<_InputIterator>::value_type>,
    typename _Allocator =
      allocator<typename iterator_traits<_InputIterator>::value_type>,
    typename = _RequireInputIter<_InputIterator>,
    typename = _RequireNotAllocatorOrIntegral<_Hash>,
    typename = _RequireNotAllocator<_Pred>,
    typename = _RequireAllocator<_Allocator>>
    unordered_multiset(_InputIterator, _InputIterator,
         unordered_multiset<int>::size_type = {},
         _Hash = _Hash(), _Pred = _Pred(),
         _Allocator = _Allocator())
    -> unordered_multiset<typename iterator_traits<_InputIterator>::value_type,
                          _Hash, _Pred, _Allocator>;

  template<typename _Tp, typename _Hash = hash<_Tp>,
    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<int>::size_type = {},
         _Hash = _Hash(), _Pred = _Pred(),
         _Allocator = _Allocator())
    -> unordered_multiset<_Tp, _Hash, _Pred, _Allocator>;

  template<typename _InputIterator, typename _Allocator,
    typename = _RequireInputIter<_InputIterator>,
    typename = _RequireAllocator<_Allocator>>
    unordered_multiset(_InputIterator, _InputIterator,
         unordered_multiset<int>::size_type, _Allocator)
    -> unordered_multiset<typename iterator_traits<_InputIterator>::value_type,
     hash<typename
          iterator_traits<_InputIterator>::value_type>,
     equal_to<typename
       iterator_traits<_InputIterator>::value_type>,
     _Allocator>;

  template<typename _InputIterator, typename _Hash, typename _Allocator,
    typename = _RequireInputIter<_InputIterator>,
    typename = _RequireNotAllocatorOrIntegral<_Hash>,
    typename = _RequireAllocator<_Allocator>>
    unordered_multiset(_InputIterator, _InputIterator,
         unordered_multiset<int>::size_type,
         _Hash, _Allocator)
    -> unordered_multiset<typename
     iterator_traits<_InputIterator>::value_type,
     _Hash,
     equal_to<
       typename
       iterator_traits<_InputIterator>::value_type>,
     _Allocator>;

  template<typename _Tp, typename _Allocator,
    typename = _RequireAllocator<_Allocator>>
    unordered_multiset(initializer_list<_Tp>,
         unordered_multiset<int>::size_type, _Allocator)
    -> unordered_multiset<_Tp, hash<_Tp>, equal_to<_Tp>, _Allocator>;

  template<typename _Tp, typename _Hash, typename _Allocator,
    typename = _RequireNotAllocatorOrIntegral<_Hash>,
    typename = _RequireAllocator<_Allocator>>
    unordered_multiset(initializer_list<_Tp>,
         unordered_multiset<int>::size_type, _Hash, _Allocator)
    -> unordered_multiset<_Tp, _Hash, equal_to<_Tp>, _Allocator>;



  template<class _Value, class _Hash, class _Pred, class _Alloc>
    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<class _Value, class _Hash, class _Pred, class _Alloc>
    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<class _Value, class _Hash, class _Pred, class _Alloc>
    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); }
# 1825 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_set.h" 3
  template<class _Value, class _Hash, class _Pred, class _Alloc>
    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); }
# 1843 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unordered_set.h" 3
  template<typename _Val, typename _Hash1, typename _Eq1, typename _Alloc,
    typename _Hash2, typename _Eq2>
    struct _Hash_merge_helper<
      std::unordered_set<_Val, _Hash1, _Eq1, _Alloc>, _Hash2, _Eq2>
    {
    private:
      template<typename... _Tp>
 using unordered_set = std::unordered_set<_Tp...>;
      template<typename... _Tp>
 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<typename _Val, typename _Hash1, typename _Eq1, typename _Alloc,
    typename _Hash2, typename _Eq2>
    struct _Hash_merge_helper<
      std::unordered_multiset<_Val, _Hash1, _Eq1, _Alloc>,
      _Hash2, _Eq2>
    {
    private:
      template<typename... _Tp>
 using unordered_set = std::unordered_set<_Tp...>;
      template<typename... _Tp>
 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; }
    };



}
# 42 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/unordered_set" 2 3
# 53 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/unordered_set" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 54 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/unordered_set" 2 3



namespace std __attribute__ ((__visibility__ ("default")))
{

  namespace pmr
  {
    template<typename _Key, typename _Hash = std::hash<_Key>,
      typename _Pred = std::equal_to<_Key>>
      using unordered_set
 = std::unordered_set<_Key, _Hash, _Pred,
        polymorphic_allocator<_Key>>;
    template<typename _Key, typename _Hash = std::hash<_Key>,
      typename _Pred = std::equal_to<_Key>>
      using unordered_multiset
 = std::unordered_multiset<_Key, _Hash, _Pred,
      polymorphic_allocator<_Key>>;
  }

}



namespace std __attribute__ ((__visibility__ ("default")))
{

  template<typename _Key, typename _Hash, typename _CPred, typename _Alloc,
    typename _Predicate>
    inline typename unordered_set<_Key, _Hash, _CPred, _Alloc>::size_type
    erase_if(unordered_set<_Key, _Hash, _CPred, _Alloc>& __cont,
      _Predicate __pred)
    {
      std::unordered_set<_Key, _Hash, _CPred, _Alloc>&
 __ucont = __cont;
      return __detail::__erase_nodes_if(__cont, __ucont, __pred);
    }

  template<typename _Key, typename _Hash, typename _CPred, typename _Alloc,
    typename _Predicate>
    inline typename unordered_multiset<_Key, _Hash, _CPred, _Alloc>::size_type
    erase_if(unordered_multiset<_Key, _Hash, _CPred, _Alloc>& __cont,
      _Predicate __pred)
    {
      std::unordered_multiset<_Key, _Hash, _CPred, _Alloc>&
 __ucont = __cont;
      return __detail::__erase_nodes_if(__cont, __ucont, __pred);
    }

}
# 26 "/home/avi/scylla-maint/seastar/include/seastar/rpc/rpc.hh" 2
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/list" 1 3
# 59 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/list" 3






# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_list.h" 1 3
# 64 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_list.h" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/allocated_ptr.h" 1 3
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/allocated_ptr.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{




  template<typename _Alloc>
    struct __allocated_ptr
    {
      using pointer = typename allocator_traits<_Alloc>::pointer;
      using value_type = typename allocator_traits<_Alloc>::value_type;


      __allocated_ptr(_Alloc& __a, pointer __ptr) noexcept
      : _M_alloc(std::__addressof(__a)), _M_ptr(__ptr)
      { }


      template<typename _Ptr,
        typename _Req = _Require<is_same<_Ptr, value_type*>>>
      __allocated_ptr(_Alloc& __a, _Ptr __ptr)
      : _M_alloc(std::__addressof(__a)),
 _M_ptr(pointer_traits<pointer>::pointer_to(*__ptr))
      { }


      __allocated_ptr(__allocated_ptr&& __gd) noexcept
      : _M_alloc(__gd._M_alloc), _M_ptr(__gd._M_ptr)
      { __gd._M_ptr = nullptr; }


      ~__allocated_ptr()
      {
 if (_M_ptr != nullptr)
   std::allocator_traits<_Alloc>::deallocate(*_M_alloc, _M_ptr, 1);
      }


      __allocated_ptr&
      operator=(std::nullptr_t) noexcept
      {
 _M_ptr = nullptr;
 return *this;
      }


      value_type* get() { return std::__to_address(_M_ptr); }

    private:
      _Alloc* _M_alloc;
      pointer _M_ptr;
    };


  template<typename _Alloc>
    __allocated_ptr<_Alloc>
    __allocate_guarded(_Alloc& __a)
    {
      return { __a, std::allocator_traits<_Alloc>::allocate(__a, 1) };
    }



}
# 65 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_list.h" 2 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; }
    };


    struct _Scratch_list : _List_node_base
    {
      _Scratch_list() { _M_next = _M_prev = this; }

      bool empty() const { return _M_next == this; }

      void swap(_List_node_base& __l) { _List_node_base::swap(*this, __l); }

      template<typename _Iter, typename _Cmp>
 struct _Ptr_cmp
 {
   _Cmp _M_cmp;

   bool
   operator()(__detail::_List_node_base* __lhs,
       __detail::_List_node_base* __rhs)
   { return _M_cmp(*_Iter(__lhs), *_Iter(__rhs)); }
 };

      template<typename _Iter>
 struct _Ptr_cmp<_Iter, void>
 {
   bool
   operator()(__detail::_List_node_base* __lhs,
       __detail::_List_node_base* __rhs) const
   { return *_Iter(__lhs) < *_Iter(__rhs); }
 };


      template<typename _Cmp>
 void
 merge(_List_node_base& __x, _Cmp __comp)
 {
   _List_node_base* __first1 = _M_next;
   _List_node_base* const __last1 = this;
   _List_node_base* __first2 = __x._M_next;
   _List_node_base* const __last2 = std::__addressof(__x);

   while (__first1 != __last1 && __first2 != __last2)
     {
       if (__comp(__first2, __first1))
  {
    _List_node_base* __next = __first2->_M_next;
    __first1->_M_transfer(__first2, __next);
    __first2 = __next;
  }
       else
  __first1 = __first1->_M_next;
     }
   if (__first2 != __last2)
     this->_M_transfer(__first2, __last2);
 }


      void _M_take_one(_List_node_base* __i)
      { this->_M_transfer(__i, __i->_M_next); }


      void _M_put_all(_List_node_base* __i)
      {
 if (!empty())
   __i->_M_transfer(_M_next, this);
      }
    };

  }




  template<typename _Tp>
    struct _List_node : public __detail::_List_node_base
    {

      __gnu_cxx::__aligned_membuf<_Tp> _M_storage;
      _Tp* _M_valptr() { return _M_storage._M_ptr(); }
      _Tp const* _M_valptr() const { return _M_storage._M_ptr(); }





    };






  template<typename _Tp>
    struct _List_iterator
    {
      typedef _List_iterator<_Tp> _Self;
      typedef _List_node<_Tp> _Node;

      typedef ptrdiff_t difference_type;
      typedef std::bidirectional_iterator_tag iterator_category;
      typedef _Tp value_type;
      typedef _Tp* pointer;
      typedef _Tp& reference;

      _List_iterator() noexcept
      : _M_node() { }

      explicit
      _List_iterator(__detail::_List_node_base* __x) noexcept
      : _M_node(__x) { }

      _Self
      _M_const_cast() const noexcept
      { return *this; }


      [[__nodiscard__]]
      reference
      operator*() const noexcept
      { return *static_cast<_Node*>(_M_node)->_M_valptr(); }

      [[__nodiscard__]]
      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;
      }

      [[__nodiscard__]]
      friend bool
      operator==(const _Self& __x, const _Self& __y) noexcept
      { return __x._M_node == __y._M_node; }
# 329 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_list.h" 3
      __detail::_List_node_base* _M_node;
    };






  template<typename _Tp>
    struct _List_const_iterator
    {
      typedef _List_const_iterator<_Tp> _Self;
      typedef const _List_node<_Tp> _Node;
      typedef _List_iterator<_Tp> iterator;

      typedef ptrdiff_t difference_type;
      typedef std::bidirectional_iterator_tag iterator_category;
      typedef _Tp value_type;
      typedef const _Tp* pointer;
      typedef const _Tp& reference;

      _List_const_iterator() noexcept
      : _M_node() { }

      explicit
      _List_const_iterator(const __detail::_List_node_base* __x)
      noexcept
      : _M_node(__x) { }

      _List_const_iterator(const iterator& __x) noexcept
      : _M_node(__x._M_node) { }

      iterator
      _M_const_cast() const noexcept
      { return iterator(const_cast<__detail::_List_node_base*>(_M_node)); }


      [[__nodiscard__]]
      reference
      operator*() const noexcept
      { return *static_cast<_Node*>(_M_node)->_M_valptr(); }

      [[__nodiscard__]]
      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;
      }

      [[__nodiscard__]]
      friend bool
      operator==(const _Self& __x, const _Self& __y) noexcept
      { return __x._M_node == __y._M_node; }
# 419 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_list.h" 3
      const __detail::_List_node_base* _M_node;
    };

namespace __cxx11 {

  template<typename _Tp, typename _Alloc>
    class _List_base
    {
    protected:
      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
 rebind<_Tp>::other _Tp_alloc_type;
      typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tp_alloc_traits;
      typedef typename _Tp_alloc_traits::template
 rebind<_List_node<_Tp> >::other _Node_alloc_type;
      typedef __gnu_cxx::__alloc_traits<_Node_alloc_type> _Node_alloc_traits;


      static size_t
      _S_distance(const __detail::_List_node_base* __first,
    const __detail::_List_node_base* __last)
      {
 size_t __n = 0;
 while (__first != __last)
   {
     __first = __first->_M_next;
     ++__n;
   }
 return __n;
      }


      struct _List_impl
      : public _Node_alloc_type
      {
 __detail::_List_node_header _M_node;

 _List_impl() noexcept(is_nothrow_default_constructible<_Node_alloc_type>::value)

 : _Node_alloc_type()
 { }

 _List_impl(const _Node_alloc_type& __a) noexcept
 : _Node_alloc_type(__a)
 { }


 _List_impl(_List_impl&&) = default;

 _List_impl(_Node_alloc_type&& __a, _List_impl&& __x)
 : _Node_alloc_type(std::move(__a)), _M_node(std::move(__x._M_node))
 { }

 _List_impl(_Node_alloc_type&& __a) noexcept
 : _Node_alloc_type(std::move(__a))
 { }

      };

      _List_impl _M_impl;


      size_t _M_get_size() const { return _M_impl._M_node._M_size; }

      void _M_set_size(size_t __n) { _M_impl._M_node._M_size = __n; }

      void _M_inc_size(size_t __n) { _M_impl._M_node._M_size += __n; }

      void _M_dec_size(size_t __n) { _M_impl._M_node._M_size -= __n; }


      size_t
      _M_distance(const __detail::_List_node_base* __first,
    const __detail::_List_node_base* __last) const
      { return _S_distance(__first, __last); }


      size_t _M_node_count() const { return _M_get_size(); }
# 516 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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(); }
    };
# 631 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_list.h" 3
  template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
    class list : protected _List_base<_Tp, _Alloc>
    {
# 644 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_list.h" 3
      static_assert(is_same<typename remove_cv<_Tp>::type, _Tp>::value,
   "std::list must have a non-const, non-volatile value_type");

      static_assert(is_same<typename _Alloc::value_type, _Tp>::value,
   "std::list must have the same value_type as its allocator");



      typedef _List_base<_Tp, _Alloc> _Base;
      typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;
      typedef typename _Base::_Tp_alloc_traits _Tp_alloc_traits;
      typedef typename _Base::_Node_alloc_type _Node_alloc_type;
      typedef typename _Base::_Node_alloc_traits _Node_alloc_traits;

    public:
      typedef _Tp value_type;
      typedef typename _Tp_alloc_traits::pointer pointer;
      typedef typename _Tp_alloc_traits::const_pointer const_pointer;
      typedef typename _Tp_alloc_traits::reference reference;
      typedef typename _Tp_alloc_traits::const_reference const_reference;
      typedef _List_iterator<_Tp> iterator;
      typedef _List_const_iterator<_Tp> const_iterator;
      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
      typedef std::reverse_iterator<iterator> reverse_iterator;
      typedef size_t size_type;
      typedef ptrdiff_t difference_type;
      typedef _Alloc allocator_type;

    protected:


      typedef _List_node<_Tp> _Node;

      using _Base::_M_impl;
      using _Base::_M_put_node;
      using _Base::_M_get_node;
      using _Base::_M_get_Node_allocator;
# 706 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_list.h" 3
      template<typename... _Args>
 _Node*
 _M_create_node(_Args&&... __args)
 {
   auto __p = this->_M_get_node();
   auto& __alloc = _M_get_Node_allocator();
   __allocated_ptr<_Node_alloc_type> __guard{__alloc, __p};
   _Node_alloc_traits::construct(__alloc, __p->_M_valptr(),
     std::forward<_Args>(__args)...);
   __guard = nullptr;
   return __p;
 }



      static size_t
      _S_distance(const_iterator __first, const_iterator __last)
      { return std::distance(__first, __last); }


      size_t
      _M_node_count() const
      { return this->_M_get_size(); }
# 741 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_list.h" 3
    public:







      list() = default;
# 758 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_list.h" 3
      explicit
      list(const allocator_type& __a) noexcept
      : _Base(_Node_alloc_type(__a)) { }
# 771 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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); }
# 784 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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); }
# 811 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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()); }
# 824 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_list.h" 3
      list(list&&) = default;
# 834 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_list.h" 3
      list(initializer_list<value_type> __l,
    const allocator_type& __a = allocator_type())
      : _Base(_Node_alloc_type(__a))
      { _M_initialize_dispatch(__l.begin(), __l.end(), __false_type()); }

      list(const list& __x, const __type_identity_t<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 __type_identity_t<allocator_type>& __a)
      noexcept(_Node_alloc_traits::_S_always_equal())
      : list(std::move(__x), __a,
      typename _Node_alloc_traits::is_always_equal{})
      { }
# 877 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_list.h" 3
      template<typename _InputIterator,
        typename = std::_RequireInputIter<_InputIterator>>
 list(_InputIterator __first, _InputIterator __last,
      const allocator_type& __a = allocator_type())
 : _Base(_Node_alloc_type(__a))
 { _M_initialize_dispatch(__first, __last, __false_type()); }
# 903 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_list.h" 3
      ~list() = default;
# 914 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_list.h" 3
      list&
      operator=(const list& __x);
# 928 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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;
      }
# 946 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_list.h" 3
      list&
      operator=(initializer_list<value_type> __l)
      {
 this->assign(__l.begin(), __l.end());
 return *this;
      }
# 964 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_list.h" 3
      void
      assign(size_type __n, const value_type& __val)
      { _M_fill_assign(__n, __val); }
# 981 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_list.h" 3
      template<typename _InputIterator,
        typename = std::_RequireInputIter<_InputIterator>>
 void
 assign(_InputIterator __first, _InputIterator __last)
 { _M_assign_dispatch(__first, __last, __false_type()); }
# 1005 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_list.h" 3
      void
      assign(initializer_list<value_type> __l)
      { this->_M_assign_dispatch(__l.begin(), __l.end(), __false_type()); }



      allocator_type
      get_allocator() const noexcept
      { return allocator_type(_Base::_M_get_Node_allocator()); }






      [[__nodiscard__]]
      iterator
      begin() noexcept
      { return iterator(this->_M_impl._M_node._M_next); }






      [[__nodiscard__]]
      const_iterator
      begin() const noexcept
      { return const_iterator(this->_M_impl._M_node._M_next); }






      [[__nodiscard__]]
      iterator
      end() noexcept
      { return iterator(&this->_M_impl._M_node); }






      [[__nodiscard__]]
      const_iterator
      end() const noexcept
      { return const_iterator(&this->_M_impl._M_node); }






      [[__nodiscard__]]
      reverse_iterator
      rbegin() noexcept
      { return reverse_iterator(end()); }






      [[__nodiscard__]]
      const_reverse_iterator
      rbegin() const noexcept
      { return const_reverse_iterator(end()); }






      [[__nodiscard__]]
      reverse_iterator
      rend() noexcept
      { return reverse_iterator(begin()); }






      [[__nodiscard__]]
      const_reverse_iterator
      rend() const noexcept
      { return const_reverse_iterator(begin()); }







      [[__nodiscard__]]
      const_iterator
      cbegin() const noexcept
      { return const_iterator(this->_M_impl._M_node._M_next); }






      [[__nodiscard__]]
      const_iterator
      cend() const noexcept
      { return const_iterator(&this->_M_impl._M_node); }






      [[__nodiscard__]]
      const_reverse_iterator
      crbegin() const noexcept
      { return const_reverse_iterator(end()); }






      [[__nodiscard__]]
      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; }


      [[__nodiscard__]]
      size_type
      size() const noexcept
      { return _M_node_count(); }


      [[__nodiscard__]]
      size_type
      max_size() const noexcept
      { return _Node_alloc_traits::max_size(_M_get_Node_allocator()); }
# 1168 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_list.h" 3
      void
      resize(size_type __new_size);
# 1181 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_list.h" 3
      void
      resize(size_type __new_size, const value_type& __x);
# 1203 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_list.h" 3
      [[__nodiscard__]]
      reference
      front() noexcept
      { return *begin(); }





      [[__nodiscard__]]
      const_reference
      front() const noexcept
      { return *begin(); }





      [[__nodiscard__]]
      reference
      back() noexcept
      {
 iterator __tmp = end();
 --__tmp;
 return *__tmp;
      }





      [[__nodiscard__]]
      const_reference
      back() const noexcept
      {
 const_iterator __tmp = end();
 --__tmp;
 return *__tmp;
      }
# 1254 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_list.h" 3
      void
      push_front(const value_type& __x)
      { this->_M_insert(begin(), __x); }


      void
      push_front(value_type&& __x)
      { this->_M_insert(begin(), std::move(__x)); }

      template<typename... _Args>

 reference



 emplace_front(_Args&&... __args)
 {
   this->_M_insert(begin(), std::forward<_Args>(__args)...);

   return front();

 }
# 1290 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_list.h" 3
      void
      pop_front() noexcept
      { this->_M_erase(begin()); }
# 1304 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_list.h" 3
      void
      push_back(const value_type& __x)
      { this->_M_insert(end(), __x); }


      void
      push_back(value_type&& __x)
      { this->_M_insert(end(), std::move(__x)); }

      template<typename... _Args>

 reference



 emplace_back(_Args&&... __args)
 {
   this->_M_insert(end(), std::forward<_Args>(__args)...);

 return back();

 }
# 1339 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_list.h" 3
      void
      pop_back() noexcept
      { this->_M_erase(iterator(this->_M_impl._M_node._M_prev)); }
# 1356 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_list.h" 3
      template<typename... _Args>
 iterator
 emplace(const_iterator __position, _Args&&... __args);
# 1371 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_list.h" 3
      iterator
      insert(const_iterator __position, const value_type& __x);
# 1401 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_list.h" 3
      iterator
      insert(const_iterator __position, value_type&& __x)
      { return emplace(__position, std::move(__x)); }
# 1420 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_list.h" 3
      iterator
      insert(const_iterator __p, initializer_list<value_type> __l)
      { return this->insert(__p, __l.begin(), __l.end()); }
# 1440 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_list.h" 3
      iterator
      insert(const_iterator __position, size_type __n, const value_type& __x);
# 1479 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_list.h" 3
      template<typename _InputIterator,
        typename = std::_RequireInputIter<_InputIterator>>
 iterator
 insert(const_iterator __position, _InputIterator __first,
        _InputIterator __last);
# 1523 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_list.h" 3
      iterator

      erase(const_iterator __position) noexcept;
# 1548 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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();
      }
# 1571 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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();
      }
# 1610 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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)); }
# 1646 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_list.h" 3
      void
      splice(const_iterator __position, list&& __x, const_iterator __i) noexcept
# 1661 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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);
      }
# 1688 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_list.h" 3
      void
      splice(const_iterator __position, list& __x, const_iterator __i) noexcept
      { splice(__position, std::move(__x), __i); }
# 1707 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_list.h" 3
      void
      splice(const_iterator __position, list&& __x, const_iterator __first,
      const_iterator __last) noexcept
# 1727 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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());
   }
      }
# 1757 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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:
# 1785 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_list.h" 3
      __attribute__((__abi_tag__("__cxx20")))
      __remove_return_type
      remove(const _Tp& __value);
# 1800 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_list.h" 3
      template<typename _Predicate>
 __remove_return_type
 remove_if(_Predicate);
# 1814 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_list.h" 3
      __attribute__((__abi_tag__("__cxx20")))
      __remove_return_type
      unique();
# 1830 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_list.h" 3
      template<typename _BinaryPredicate>
 __remove_return_type
 unique(_BinaryPredicate);
# 1846 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_list.h" 3
      void
      merge(list&& __x);

      void
      merge(list& __x)
      { merge(std::move(__x)); }
# 1871 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_list.h" 3
      template<typename _StrictWeakOrdering>
 void
 merge(list&& __x, _StrictWeakOrdering __comp);

      template<typename _StrictWeakOrdering>
 void
 merge(list& __x, _StrictWeakOrdering __comp)
 { merge(std::move(__x), __comp); }
# 1890 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_list.h" 3
      void
      reverse() noexcept
      { this->_M_impl._M_node._M_reverse(); }







      void
      sort();







      template<typename _StrictWeakOrdering>
 void
 sort(_StrictWeakOrdering);

    protected:






      template<typename _Integer>
 void
 _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type)
 { _M_fill_initialize(static_cast<size_type>(__n), __x); }


      template<typename _InputIterator>
 void
 _M_initialize_dispatch(_InputIterator __first, _InputIterator __last,
          __false_type)
 {
   for (; __first != __last; ++__first)

     emplace_back(*__first);



 }



      void
      _M_fill_initialize(size_type __n, const value_type& __x)
      {
 for (; __n; --__n)
   push_back(__x);
      }



      void
      _M_default_initialize(size_type __n)
      {
 for (; __n; --__n)
   emplace_back();
      }


      void
      _M_default_append(size_type __n);
# 1968 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_list.h" 3
      template<typename _Integer>
 void
 _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
 { _M_fill_assign(__n, __val); }


      template<typename _InputIterator>
 void
 _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
      __false_type);



      void
      _M_fill_assign(size_type __n, const value_type& __val);



      void
      _M_transfer(iterator __position, iterator __first, iterator __last)
      { __position._M_node->_M_transfer(__first._M_node, __last._M_node); }
# 2000 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_list.h" 3
     template<typename... _Args>
       void
       _M_insert(iterator __position, _Args&&... __args)
       {
  _Node* __tmp = _M_create_node(std::forward<_Args>(__args)...);
  __tmp->_M_hook(__position._M_node);
  this->_M_inc_size(1);
       }



      void
      _M_erase(iterator __position) noexcept
      {
 this->_M_dec_size(1);
 __position._M_node->_M_unhook();
 _Node* __n = static_cast<_Node*>(__position._M_node);

 _Node_alloc_traits::destroy(_M_get_Node_allocator(), __n->_M_valptr());




 _M_put_node(__n);
      }


      void
      _M_check_equal_allocators(const list& __x) noexcept
      {
 if (_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->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{});
      }




      struct _Finalize_merge
      {
 explicit
 _Finalize_merge(list& __dest, list& __src, const iterator& __src_next)
 : _M_dest(__dest), _M_src(__src), _M_next(__src_next)
 { }

 ~_Finalize_merge()
 {



   const size_t __num_unmerged = std::distance(_M_next, _M_src.end());
   const size_t __orig_size = _M_src._M_get_size();
   _M_dest._M_inc_size(__orig_size - __num_unmerged);
   _M_src._M_set_size(__num_unmerged);
 }

 list& _M_dest;
 list& _M_src;
 const iterator& _M_next;


 _Finalize_merge(const _Finalize_merge&) = delete;

      };





    };


  template<typename _InputIterator, typename _ValT
      = typename iterator_traits<_InputIterator>::value_type,
    typename _Allocator = allocator<_ValT>,
    typename = _RequireInputIter<_InputIterator>,
    typename = _RequireAllocator<_Allocator>>
    list(_InputIterator, _InputIterator, _Allocator = _Allocator())
      -> list<_ValT, _Allocator>;


}
# 2119 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_list.h" 3
  template<typename _Tp, typename _Alloc>
    [[__nodiscard__]]
    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;
    }
# 2155 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_list.h" 3
  template<typename _Tp, typename _Alloc>
    [[nodiscard]]
    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);
    }
# 2213 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_list.h" 3
  template<typename _Tp, typename _Alloc>
    inline void
    swap(list<_Tp, _Alloc>& __x, list<_Tp, _Alloc>& __y)
    noexcept(noexcept(__x.swap(__y)))
    { __x.swap(__y); }






  template<typename _Tp>
    inline ptrdiff_t
    __distance(std::_List_iterator<_Tp> __first,
        std::_List_iterator<_Tp> __last,
        input_iterator_tag __tag)
    {
      typedef std::_List_const_iterator<_Tp> _CIter;
      return std::__distance(_CIter(__first), _CIter(__last), __tag);
    }

  template<typename _Tp>
    inline ptrdiff_t
    __distance(std::_List_const_iterator<_Tp> __first,
        std::_List_const_iterator<_Tp> __last,
        input_iterator_tag)
    {
      typedef __detail::_List_node_header _Sentinel;
      std::_List_const_iterator<_Tp> __beyond = __last;
      ++__beyond;
      const bool __whole = __first == __beyond;
      if (__builtin_constant_p (__whole) && __whole)
 return static_cast<const _Sentinel*>(__last._M_node)->_M_size;

      ptrdiff_t __n = 0;
      while (__first != __last)
 {
   ++__first;
   ++__n;
 }
      return __n;
    }



}
# 66 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/list" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/list.tcc" 1 3
# 59 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/list.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{



  template<typename _Tp, typename _Alloc>
    void
    _List_base<_Tp, _Alloc>::
    _M_clear() noexcept
    {
      typedef _List_node<_Tp> _Node;
      __detail::_List_node_base* __cur = _M_impl._M_node._M_next;
      while (__cur != &_M_impl._M_node)
 {
   _Node* __tmp = static_cast<_Node*>(__cur);
   __cur = __tmp->_M_next;
   _Tp* __val = __tmp->_M_valptr();

   _Node_alloc_traits::destroy(_M_get_Node_allocator(), __val);



   _M_put_node(__tmp);
 }
    }


  template<typename _Tp, typename _Alloc>
    template<typename... _Args>
      typename list<_Tp, _Alloc>::iterator
      list<_Tp, _Alloc>::
      emplace(const_iterator __position, _Args&&... __args)
      {
 _Node* __tmp = _M_create_node(std::forward<_Args>(__args)...);
 __tmp->_M_hook(__position._M_const_cast()._M_node);
 this->_M_inc_size(1);
 return iterator(__tmp);
      }


  template<typename _Tp, typename _Alloc>
    typename list<_Tp, _Alloc>::iterator
    list<_Tp, _Alloc>::

    insert(const_iterator __position, const value_type& __x)



    {
      _Node* __tmp = _M_create_node(__x);
      __tmp->_M_hook(__position._M_const_cast()._M_node);
      this->_M_inc_size(1);
      return iterator(__tmp);
    }


  template<typename _Tp, typename _Alloc>
    typename list<_Tp, _Alloc>::iterator
    list<_Tp, _Alloc>::
    insert(const_iterator __position, size_type __n, const value_type& __x)
    {
      if (__n)
 {
   list __tmp(__n, __x, get_allocator());
   iterator __it = __tmp.begin();
   splice(__position, __tmp);
   return __it;
 }
      return __position._M_const_cast();
    }

  template<typename _Tp, typename _Alloc>
    template<typename _InputIterator, typename>
      typename list<_Tp, _Alloc>::iterator
      list<_Tp, _Alloc>::
      insert(const_iterator __position, _InputIterator __first,
      _InputIterator __last)
      {
 list __tmp(__first, __last, get_allocator());
 if (!__tmp.empty())
   {
     iterator __it = __tmp.begin();
     splice(__position, __tmp);
     return __it;
   }
 return __position._M_const_cast();
      }


  template<typename _Tp, typename _Alloc>
    typename list<_Tp, _Alloc>::iterator
    list<_Tp, _Alloc>::

    erase(const_iterator __position) noexcept



    {
      iterator __ret = iterator(__position._M_node->_M_next);
      _M_erase(__position._M_const_cast());
      return __ret;
    }
# 173 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/list.tcc" 3
  template<typename _Tp, typename _Alloc>
    typename list<_Tp, _Alloc>::const_iterator
    list<_Tp, _Alloc>::
    _M_resize_pos(size_type& __new_size) const
    {
      const_iterator __i;

      const size_type __len = size();
      if (__new_size < __len)
 {
   if (__new_size <= __len / 2)
     {
       __i = begin();
       std::advance(__i, __new_size);
     }
   else
     {
       __i = end();
       ptrdiff_t __num_erase = __len - __new_size;
       std::advance(__i, -__num_erase);
     }
   __new_size = 0;
   return __i;
 }
      else
 __i = end();





      __new_size -= __len;
      return __i;
    }


  template<typename _Tp, typename _Alloc>
    void
    list<_Tp, _Alloc>::
    _M_default_append(size_type __n)
    {
      size_type __i = 0;
      try
 {
   for (; __i < __n; ++__i)
     emplace_back();
 }
      catch(...)
 {
   for (; __i; --__i)
     pop_back();
   throw;
 }
    }

  template<typename _Tp, typename _Alloc>
    void
    list<_Tp, _Alloc>::
    resize(size_type __new_size)
    {
      const_iterator __i = _M_resize_pos(__new_size);
      if (__new_size)
 _M_default_append(__new_size);
      else
        erase(__i, end());
    }

  template<typename _Tp, typename _Alloc>
    void
    list<_Tp, _Alloc>::
    resize(size_type __new_size, const value_type& __x)
    {
      const_iterator __i = _M_resize_pos(__new_size);
      if (__new_size)
        insert(end(), __new_size, __x);
      else
        erase(__i, end());
    }
# 265 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/list.tcc" 3
  template<typename _Tp, typename _Alloc>
    list<_Tp, _Alloc>&
    list<_Tp, _Alloc>::
    operator=(const list& __x)
    {
      if (this != std::__addressof(__x))
 {

   if (_Node_alloc_traits::_S_propagate_on_copy_assign())
     {
              auto& __this_alloc = this->_M_get_Node_allocator();
              auto& __that_alloc = __x._M_get_Node_allocator();
              if (!_Node_alloc_traits::_S_always_equal()
           && __this_alloc != __that_alloc)
         {

    clear();
  }
       std::__alloc_on_copy(__this_alloc, __that_alloc);
            }

   _M_assign_dispatch(__x.begin(), __x.end(), __false_type());
 }
      return *this;
    }

  template<typename _Tp, typename _Alloc>
    void
    list<_Tp, _Alloc>::
    _M_fill_assign(size_type __n, const value_type& __val)
    {
      iterator __i = begin();
      for (; __i != end() && __n > 0; ++__i, --__n)
        *__i = __val;
      if (__n > 0)
        insert(end(), __n, __val);
      else
        erase(__i, end());
    }

  template<typename _Tp, typename _Alloc>
    template <typename _InputIterator>
      void
      list<_Tp, _Alloc>::
      _M_assign_dispatch(_InputIterator __first2, _InputIterator __last2,
    __false_type)
      {
        iterator __first1 = begin();
        iterator __last1 = end();
        for (; __first1 != __last1 && __first2 != __last2;
      ++__first1, (void)++__first2)
          *__first1 = *__first2;
        if (__first2 == __last2)
          erase(__first1, __last1);
        else
          insert(__last1, __first2, __last2);
      }







  template<typename _Tp, typename _Alloc>
    typename list<_Tp, _Alloc>::__remove_return_type
    list<_Tp, _Alloc>::
    remove(const value_type& __value)
    {



      list __to_destroy(get_allocator());
      iterator __first = begin();
      iterator __last = end();
      while (__first != __last)
 {
   iterator __next = __first;
   ++__next;
   if (*__first == __value)
     {



       __to_destroy.splice(__to_destroy.begin(), *this, __first);



     }

   __first = __next;
 }




 return __to_destroy.size();

    }

  template<typename _Tp, typename _Alloc>
    typename list<_Tp, _Alloc>::__remove_return_type
    list<_Tp, _Alloc>::
    unique()
    {
      iterator __first = begin();
      iterator __last = end();
      if (__first == __last)
 return 0;



      list __to_destroy(get_allocator());
      iterator __next = __first;
      while (++__next != __last)
 {
   if (*__first == *__next)
     {
       __to_destroy.splice(__to_destroy.begin(), *this, __next);



     }
   else
     __first = __next;
   __next = __first;
 }




      return __to_destroy.size();

    }

  template<typename _Tp, typename _Alloc>
    void
    list<_Tp, _Alloc>::

    merge(list&& __x)



    {


      if (this != std::__addressof(__x))
 {
   _M_check_equal_allocators(__x);

   iterator __first1 = begin();
   iterator __last1 = end();
   iterator __first2 = __x.begin();
   iterator __last2 = __x.end();

   const _Finalize_merge __fin(*this, __x, __first2);

   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);
       __first2 = __last2;
     }
 }
    }

  template<typename _Tp, typename _Alloc>
    template <typename _StrictWeakOrdering>
      void
      list<_Tp, _Alloc>::

      merge(list&& __x, _StrictWeakOrdering __comp)



      {


 if (this != std::__addressof(__x))
   {
     _M_check_equal_allocators(__x);

     iterator __first1 = begin();
     iterator __last1 = end();
     iterator __first2 = __x.begin();
     iterator __last2 = __x.end();

     const _Finalize_merge __fin(*this, __x, __first2);

     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);
  __first2 = __last2;
       }
   }
      }

  template<typename _Tp, typename _Alloc>
    void
    list<_Tp, _Alloc>::
    sort()
    {

      if (this->_M_impl._M_node._M_next != &this->_M_impl._M_node
   && this->_M_impl._M_node._M_next->_M_next != &this->_M_impl._M_node)
      {
 using __detail::_Scratch_list;
# 497 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/list.tcc" 3
 _Scratch_list __carry;
 _Scratch_list __tmp[64];
 _Scratch_list* __fill = __tmp;
 _Scratch_list* __counter;

 _Scratch_list::_Ptr_cmp<iterator, void> __ptr_comp;

 try
   {
     do
       {
  __carry._M_take_one(begin()._M_node);

  for(__counter = __tmp;
      __counter != __fill && !__counter->empty();
      ++__counter)
    {

      __counter->merge(__carry, __ptr_comp);
      __carry.swap(*__counter);
    }
  __carry.swap(*__counter);
  if (__counter == __fill)
    ++__fill;
       }
     while ( !empty() );

     for (__counter = __tmp + 1; __counter != __fill; ++__counter)
       __counter->merge(__counter[-1], __ptr_comp);
     __fill[-1].swap(this->_M_impl._M_node);
   }
 catch(...)
   {

     __carry._M_put_all(end()._M_node);
     for (int __i = 0; __i < sizeof(__tmp)/sizeof(__tmp[0]); ++__i)
       __tmp[__i]._M_put_all(end()._M_node);
     throw;
   }
      }
    }

  template<typename _Tp, typename _Alloc>
    template <typename _Predicate>
      typename list<_Tp, _Alloc>::__remove_return_type
      list<_Tp, _Alloc>::
      remove_if(_Predicate __pred)
      {



 list __to_destroy(get_allocator());
 iterator __first = begin();
 iterator __last = end();
 while (__first != __last)
   {
     iterator __next = __first;
     ++__next;
     if (__pred(*__first))
       {
  __to_destroy.splice(__to_destroy.begin(), *this, __first);



       }
     __first = __next;
   }




 return __to_destroy.size();

      }

  template<typename _Tp, typename _Alloc>
    template <typename _BinaryPredicate>
      typename list<_Tp, _Alloc>::__remove_return_type
      list<_Tp, _Alloc>::
      unique(_BinaryPredicate __binary_pred)
      {
        iterator __first = begin();
        iterator __last = end();
        if (__first == __last)
   return 0;



 list __to_destroy(get_allocator());
        iterator __next = __first;
        while (++__next != __last)
   {
     if (__binary_pred(*__first, *__next))
       {
  __to_destroy.splice(__to_destroy.begin(), *this, __next);



       }
     else
       __first = __next;
     __next = __first;
   }




 return __to_destroy.size();

      }



  template<typename _Tp, typename _Alloc>
    template <typename _StrictWeakOrdering>
      void
      list<_Tp, _Alloc>::
      sort(_StrictWeakOrdering __comp)
      {

 if (this->_M_impl._M_node._M_next != &this->_M_impl._M_node
     && this->_M_impl._M_node._M_next->_M_next != &this->_M_impl._M_node)
 {
   using __detail::_Scratch_list;
   _Scratch_list __carry;
   _Scratch_list __tmp[64];
   _Scratch_list* __fill = __tmp;
   _Scratch_list* __counter;

 _Scratch_list::_Ptr_cmp<iterator, _StrictWeakOrdering> __ptr_comp
   = { __comp };

   try
     {
       do
  {
    __carry._M_take_one(begin()._M_node);

    for(__counter = __tmp;
        __counter != __fill && !__counter->empty();
        ++__counter)
      {

        __counter->merge(__carry, __ptr_comp);
        __carry.swap(*__counter);
      }
    __carry.swap(*__counter);
    if (__counter == __fill)
      ++__fill;
  }
       while ( !empty() );

       for (__counter = __tmp + 1; __counter != __fill; ++__counter)
  __counter->merge(__counter[-1], __ptr_comp);
       __fill[-1].swap(this->_M_impl._M_node);
     }
   catch(...)
     {

       __carry._M_put_all(end()._M_node);
       for (size_t __i = 0; __i < sizeof(__tmp)/sizeof(__tmp[0]); ++__i)
  __tmp[__i]._M_put_all(end()._M_node);
       throw;
     }
 }
      }



}
# 67 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/list" 2 3
# 76 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/list" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 77 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/list" 2 3



namespace std __attribute__ ((__visibility__ ("default")))
{

  namespace pmr
  {
    template<typename _Tp>
      using list = std::list<_Tp, polymorphic_allocator<_Tp>>;
  }

}



namespace std __attribute__ ((__visibility__ ("default")))
{

  template<typename _Tp, typename _Alloc, typename _Predicate>
    inline typename list<_Tp, _Alloc>::size_type
    erase_if(list<_Tp, _Alloc>& __cont, _Predicate __pred)
    { return __cont.remove_if(__pred); }

  template<typename _Tp, typename _Alloc, typename _Up>
    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;
      });
    }

}
# 27 "/home/avi/scylla-maint/seastar/include/seastar/rpc/rpc.hh" 2
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/variant" 1 3
# 33 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/variant" 3



# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 37 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/variant" 2 3








# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/parse_numbers.h" 1 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/parse_numbers.h" 3








namespace std __attribute__ ((__visibility__ ("default")))
{


namespace __parse_int
{
  template<unsigned _Base, char _Dig>
    struct _Digit;

  template<unsigned _Base>
    struct _Digit<_Base, '0'> : integral_constant<unsigned, 0>
    {
      using __valid = true_type;
    };

  template<unsigned _Base>
    struct _Digit<_Base, '1'> : integral_constant<unsigned, 1>
    {
      using __valid = true_type;
    };

  template<unsigned _Base, unsigned _Val>
    struct _Digit_impl : integral_constant<unsigned, _Val>
    {
      static_assert(_Base > _Val, "invalid digit");
      using __valid = true_type;
    };

  template<unsigned _Base>
    struct _Digit<_Base, '2'> : _Digit_impl<_Base, 2>
    { };

  template<unsigned _Base>
    struct _Digit<_Base, '3'> : _Digit_impl<_Base, 3>
    { };

  template<unsigned _Base>
    struct _Digit<_Base, '4'> : _Digit_impl<_Base, 4>
    { };

  template<unsigned _Base>
    struct _Digit<_Base, '5'> : _Digit_impl<_Base, 5>
    { };

  template<unsigned _Base>
    struct _Digit<_Base, '6'> : _Digit_impl<_Base, 6>
    { };

  template<unsigned _Base>
    struct _Digit<_Base, '7'> : _Digit_impl<_Base, 7>
    { };

  template<unsigned _Base>
    struct _Digit<_Base, '8'> : _Digit_impl<_Base, 8>
    { };

  template<unsigned _Base>
    struct _Digit<_Base, '9'> : _Digit_impl<_Base, 9>
    { };

  template<unsigned _Base>
    struct _Digit<_Base, 'a'> : _Digit_impl<_Base, 0xa>
    { };

  template<unsigned _Base>
    struct _Digit<_Base, 'A'> : _Digit_impl<_Base, 0xa>
    { };

  template<unsigned _Base>
    struct _Digit<_Base, 'b'> : _Digit_impl<_Base, 0xb>
    { };

  template<unsigned _Base>
    struct _Digit<_Base, 'B'> : _Digit_impl<_Base, 0xb>
    { };

  template<unsigned _Base>
    struct _Digit<_Base, 'c'> : _Digit_impl<_Base, 0xc>
    { };

  template<unsigned _Base>
    struct _Digit<_Base, 'C'> : _Digit_impl<_Base, 0xc>
    { };

  template<unsigned _Base>
    struct _Digit<_Base, 'd'> : _Digit_impl<_Base, 0xd>
    { };

  template<unsigned _Base>
    struct _Digit<_Base, 'D'> : _Digit_impl<_Base, 0xd>
    { };

  template<unsigned _Base>
    struct _Digit<_Base, 'e'> : _Digit_impl<_Base, 0xe>
    { };

  template<unsigned _Base>
    struct _Digit<_Base, 'E'> : _Digit_impl<_Base, 0xe>
    { };

  template<unsigned _Base>
    struct _Digit<_Base, 'f'> : _Digit_impl<_Base, 0xf>
    { };

  template<unsigned _Base>
    struct _Digit<_Base, 'F'> : _Digit_impl<_Base, 0xf>
    { };


  template<unsigned _Base>
    struct _Digit<_Base, '\''> : integral_constant<unsigned, 0>
    {
      using __valid = false_type;
    };



  template<unsigned long long _Val>
    using __ull_constant = integral_constant<unsigned long long, _Val>;

  template<unsigned _Base, char _Dig, char... _Digs>
    struct _Power_help
    {
      using __next = typename _Power_help<_Base, _Digs...>::type;
      using __valid_digit = typename _Digit<_Base, _Dig>::__valid;
      using type
 = __ull_constant<__next::value * (__valid_digit{} ? _Base : 1ULL)>;
    };

  template<unsigned _Base, char _Dig>
    struct _Power_help<_Base, _Dig>
    {
      using __valid_digit = typename _Digit<_Base, _Dig>::__valid;
      using type = __ull_constant<__valid_digit::value>;
    };

  template<unsigned _Base, char... _Digs>
    struct _Power : _Power_help<_Base, _Digs...>::type
    { };

  template<unsigned _Base>
    struct _Power<_Base> : __ull_constant<0>
    { };



  template<unsigned _Base, unsigned long long _Pow, char _Dig, char... _Digs>
    struct _Number_help
    {
      using __digit = _Digit<_Base, _Dig>;
      using __valid_digit = typename __digit::__valid;
      using __next = _Number_help<_Base,
      __valid_digit::value ? _Pow / _Base : _Pow,
      _Digs...>;
      using type = __ull_constant<_Pow * __digit::value + __next::type::value>;
      static_assert((type::value / _Pow) == __digit::value,
      "integer literal does not fit in unsigned long long");
    };


  template<unsigned _Base, unsigned long long _Pow, char _Dig, char..._Digs>
    struct _Number_help<_Base, _Pow, '\'', _Dig, _Digs...>
    : _Number_help<_Base, _Pow, _Dig, _Digs...>
    { };


  template<unsigned _Base, char _Dig>
    struct _Number_help<_Base, 1ULL, _Dig>
    {
      using type = __ull_constant<_Digit<_Base, _Dig>::value>;
    };

  template<unsigned _Base, char... _Digs>
    struct _Number
    : _Number_help<_Base, _Power<_Base, _Digs...>::value, _Digs...>::type
    { };

  template<unsigned _Base>
    struct _Number<_Base>
    : __ull_constant<0>
    { };



  template<char... _Digs>
    struct _Parse_int;

  template<char... _Digs>
    struct _Parse_int<'0', 'b', _Digs...>
    : _Number<2U, _Digs...>::type
    { };

  template<char... _Digs>
    struct _Parse_int<'0', 'B', _Digs...>
    : _Number<2U, _Digs...>::type
    { };

  template<char... _Digs>
    struct _Parse_int<'0', 'x', _Digs...>
    : _Number<16U, _Digs...>::type
    { };

  template<char... _Digs>
    struct _Parse_int<'0', 'X', _Digs...>
    : _Number<16U, _Digs...>::type
    { };

  template<char... _Digs>
    struct _Parse_int<'0', _Digs...>
    : _Number<8U, _Digs...>::type
    { };

  template<char... _Digs>
    struct _Parse_int
    : _Number<10U, _Digs...>::type
    { };

}


namespace __select_int
{
  template<unsigned long long _Val, typename... _Ints>
    struct _Select_int_base;

  template<unsigned long long _Val, typename _IntType, typename... _Ints>
    struct _Select_int_base<_Val, _IntType, _Ints...>
    : __conditional_t<(_Val <= __gnu_cxx::__int_traits<_IntType>::__max),
        integral_constant<_IntType, (_IntType)_Val>,
        _Select_int_base<_Val, _Ints...>>
    { };

  template<unsigned long long _Val>
    struct _Select_int_base<_Val>
    { };

  template<char... _Digs>
    using _Select_int = typename _Select_int_base<
 __parse_int::_Parse_int<_Digs...>::value,
 unsigned char,
 unsigned short,
 unsigned int,
 unsigned long,
 unsigned long long
      >::type;

}


}
# 46 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/variant" 2 3
# 59 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/variant" 3
namespace std __attribute__ ((__visibility__ ("default")))
{


  template<typename... _Types> class tuple;
  template<typename... _Types> class variant;
  template <typename> struct hash;

  template<typename _Variant>
    struct variant_size;

  template<typename _Variant>
    struct variant_size<const _Variant> : variant_size<_Variant> {};

  template<typename _Variant>
    struct variant_size<volatile _Variant> : variant_size<_Variant> {};

  template<typename _Variant>
    struct variant_size<const volatile _Variant> : variant_size<_Variant> {};

  template<typename... _Types>
    struct variant_size<variant<_Types...>>
    : std::integral_constant<size_t, sizeof...(_Types)> {};

  template<typename _Variant>
    inline constexpr size_t variant_size_v = variant_size<_Variant>::value;

  template<typename... _Types>
    inline constexpr size_t
    variant_size_v<variant<_Types...>> = sizeof...(_Types);

  template<typename... _Types>
    inline constexpr size_t
    variant_size_v<const variant<_Types...>> = sizeof...(_Types);

  template<size_t _Np, typename _Variant>
    struct variant_alternative;

  template<size_t _Np, typename... _Types>
    struct variant_alternative<_Np, variant<_Types...>>
    {
      static_assert(_Np < sizeof...(_Types));

      using type = typename _Nth_type<_Np, _Types...>::type;
    };

  template<size_t _Np, typename _Variant>
    using variant_alternative_t =
      typename variant_alternative<_Np, _Variant>::type;

  template<size_t _Np, typename _Variant>
    struct variant_alternative<_Np, const _Variant>
    { using type = const variant_alternative_t<_Np, _Variant>; };

  template<size_t _Np, typename _Variant>
    struct variant_alternative<_Np, volatile _Variant>
    { using type = volatile variant_alternative_t<_Np, _Variant>; };

  template<size_t _Np, typename _Variant>
    struct variant_alternative<_Np, const volatile _Variant>
    { using type = const volatile variant_alternative_t<_Np, _Variant>; };

  inline constexpr size_t variant_npos = -1;

  template<size_t _Np, typename... _Types>
    constexpr variant_alternative_t<_Np, variant<_Types...>>&
    get(variant<_Types...>&);

  template<size_t _Np, typename... _Types>
    constexpr variant_alternative_t<_Np, variant<_Types...>>&&
    get(variant<_Types...>&&);

  template<size_t _Np, typename... _Types>
    constexpr variant_alternative_t<_Np, variant<_Types...>> const&
    get(const variant<_Types...>&);

  template<size_t _Np, typename... _Types>
    constexpr variant_alternative_t<_Np, variant<_Types...>> const&&
    get(const variant<_Types...>&&);

  template<typename _Result_type, typename _Visitor, typename... _Variants>
    constexpr decltype(auto)
    __do_visit(_Visitor&& __visitor, _Variants&&... __variants);

  template <typename... _Types, typename _Tp>
    constexpr
    decltype(auto)
    __variant_cast(_Tp&& __rhs)
    {
      if constexpr (is_lvalue_reference_v<_Tp>)
 {
   if constexpr (is_const_v<remove_reference_t<_Tp>>)
     return static_cast<const variant<_Types...>&>(__rhs);
   else
     return static_cast<variant<_Types...>&>(__rhs);
 }
      else
        return static_cast<variant<_Types...>&&>(__rhs);
    }

namespace __detail
{
namespace __variant
{

  struct __variant_cookie {};

  struct __variant_idx_cookie { using type = __variant_idx_cookie; };

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


  template<typename _Visitor, typename... _Variants>
    constexpr void
    __raw_visit(_Visitor&& __visitor, _Variants&&... __variants)
    {
      std::__do_visit<__variant_cookie>(std::forward<_Visitor>(__visitor),
            std::forward<_Variants>(__variants)...);
    }


  template<typename _Visitor, typename... _Variants>
    constexpr void
    __raw_idx_visit(_Visitor&& __visitor, _Variants&&... __variants)
    {
      std::__do_visit<__variant_idx_cookie>(std::forward<_Visitor>(__visitor),
   std::forward<_Variants>(__variants)...);
    }



  template<typename... _Types>
    constexpr std::variant<_Types...>&
    __as(std::variant<_Types...>& __v) noexcept
    { return __v; }

  template<typename... _Types>
    constexpr const std::variant<_Types...>&
    __as(const std::variant<_Types...>& __v) noexcept
    { return __v; }

  template<typename... _Types>
    constexpr std::variant<_Types...>&&
    __as(std::variant<_Types...>&& __v) noexcept
    { return std::move(__v); }

  template<typename... _Types>
    constexpr const std::variant<_Types...>&&
    __as(const std::variant<_Types...>&& __v) noexcept
    { return std::move(__v); }







  template<typename _Type, bool = std::is_trivially_destructible_v<_Type>>
    struct _Uninitialized;

  template<typename _Type>
    struct _Uninitialized<_Type, true>
    {
      template<typename... _Args>
 constexpr
 _Uninitialized(in_place_index_t<0>, _Args&&... __args)
 : _M_storage(std::forward<_Args>(__args)...)
 { }

      constexpr const _Type& _M_get() const & noexcept
      { return _M_storage; }

      constexpr _Type& _M_get() & noexcept
      { return _M_storage; }

      constexpr const _Type&& _M_get() const && noexcept
      { return std::move(_M_storage); }

      constexpr _Type&& _M_get() && noexcept
      { return std::move(_M_storage); }

      _Type _M_storage;
    };

  template<typename _Type>
    struct _Uninitialized<_Type, false>
    {
# 279 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/variant" 3
      template<typename... _Args>
 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<size_t _Np, typename _Union>
    constexpr decltype(auto)
    __get_n(_Union&& __u) noexcept
    {
      if constexpr (_Np == 0)
 return std::forward<_Union>(__u)._M_first._M_get();
      else if constexpr (_Np == 1)
 return std::forward<_Union>(__u)._M_rest._M_first._M_get();
      else if constexpr (_Np == 2)
 return std::forward<_Union>(__u)._M_rest._M_rest._M_first._M_get();
      else
 return __variant::__get_n<_Np - 3>(
   std::forward<_Union>(__u)._M_rest._M_rest._M_rest);
    }


  template<size_t _Np, typename _Variant>
    constexpr decltype(auto)
    __get(_Variant&& __v) noexcept
    { return __variant::__get_n<_Np>(std::forward<_Variant>(__v)._M_u); }


  template<size_t _Np, typename _Union>
    constexpr decltype(auto)
    __construct_n(_Union& __u) noexcept
    {
      if constexpr (_Np == 0)
 return &__u._M_first;
      else if constexpr (_Np == 1)
 {
   std::_Construct(&__u._M_rest);
   return &__u._M_rest._M_first;
 }
      else if constexpr (_Np == 2)
 {
   std::_Construct(&__u._M_rest);
   std::_Construct(&__u._M_rest._M_rest);
   return &__u._M_rest._M_rest._M_first;
 }
      else
 {
   std::_Construct(&__u._M_rest);
   std::_Construct(&__u._M_rest._M_rest);
   std::_Construct(&__u._M_rest._M_rest._M_rest);
   return __variant::__construct_n<_Np - 3>(__u._M_rest._M_rest._M_rest);
 }
    }

  template<typename... _Types>
    struct _Traits
    {
      static constexpr bool _S_default_ctor =
   is_default_constructible_v<typename _Nth_type<0, _Types...>::type>;
      static constexpr bool _S_copy_ctor =
   (is_copy_constructible_v<_Types> && ...);
      static constexpr bool _S_move_ctor =
   (is_move_constructible_v<_Types> && ...);
      static constexpr bool _S_copy_assign =
   _S_copy_ctor
   && (is_copy_assignable_v<_Types> && ...);
      static constexpr bool _S_move_assign =
   _S_move_ctor
   && (is_move_assignable_v<_Types> && ...);

      static constexpr bool _S_trivial_dtor =
   (is_trivially_destructible_v<_Types> && ...);
      static constexpr bool _S_trivial_copy_ctor =
   (is_trivially_copy_constructible_v<_Types> && ...);
      static constexpr bool _S_trivial_move_ctor =
   (is_trivially_move_constructible_v<_Types> && ...);
      static constexpr bool _S_trivial_copy_assign =
   _S_trivial_dtor && _S_trivial_copy_ctor
   && (is_trivially_copy_assignable_v<_Types> && ...);
      static constexpr bool _S_trivial_move_assign =
   _S_trivial_dtor && _S_trivial_move_ctor
   && (is_trivially_move_assignable_v<_Types> && ...);



      static constexpr bool _S_nothrow_default_ctor =
   is_nothrow_default_constructible_v<
       typename _Nth_type<0, _Types...>::type>;
      static constexpr bool _S_nothrow_copy_ctor = false;
      static constexpr bool _S_nothrow_move_ctor =
   (is_nothrow_move_constructible_v<_Types> && ...);
      static constexpr bool _S_nothrow_copy_assign = false;
      static constexpr bool _S_nothrow_move_assign =
   _S_nothrow_move_ctor
   && (is_nothrow_move_assignable_v<_Types> && ...);
    };


  template<bool __trivially_destructible, typename... _Types>
    union _Variadic_union
    {
      _Variadic_union() = default;

      template<size_t _Np, typename... _Args>
 _Variadic_union(in_place_index_t<_Np>, _Args&&...) = delete;
    };

  template<bool __trivially_destructible, typename _First, typename... _Rest>
    union _Variadic_union<__trivially_destructible, _First, _Rest...>
    {
      constexpr _Variadic_union() : _M_rest() { }

      template<typename... _Args>
 constexpr
 _Variadic_union(in_place_index_t<0>, _Args&&... __args)
 : _M_first(in_place_index<0>, std::forward<_Args>(__args)...)
 { }

      template<size_t _Np, typename... _Args>
 constexpr
 _Variadic_union(in_place_index_t<_Np>, _Args&&... __args)
 : _M_rest(in_place_index<_Np-1>, std::forward<_Args>(__args)...)
 { }
# 434 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/variant" 3
      _Uninitialized<_First> _M_first;
      _Variadic_union<__trivially_destructible, _Rest...> _M_rest;
    };






  template<typename _Tp>
    struct _Never_valueless_alt
    : __and_<bool_constant<sizeof(_Tp) <= 256>, is_trivially_copyable<_Tp>>
    { };
# 458 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/variant" 3
  template <typename... _Types>
    constexpr bool __never_valueless()
    {
      return _Traits<_Types...>::_S_move_assign
 && (_Never_valueless_alt<_Types>::value && ...);
    }


  template<bool __trivially_destructible, typename... _Types>
    struct _Variant_storage;

  template <typename... _Types>
    using __select_index =
      typename __select_int::_Select_int_base<sizeof...(_Types),
           unsigned char,
           unsigned short>::type::value_type;

  template<typename... _Types>
    struct _Variant_storage<false, _Types...>
    {
      constexpr
      _Variant_storage()
      : _M_index(static_cast<__index_type>(variant_npos))
      { }

      template<size_t _Np, typename... _Args>
 constexpr
 _Variant_storage(in_place_index_t<_Np>, _Args&&... __args)
 : _M_u(in_place_index<_Np>, std::forward<_Args>(__args)...),
 _M_index{_Np}
 { }

      constexpr void
      _M_reset()
      {
 if (!_M_valid()) [[unlikely]]
   return;

 std::__do_visit<void>([](auto&& __this_mem) mutable
   {
     std::_Destroy(std::__addressof(__this_mem));
   }, __variant_cast<_Types...>(*this));

 _M_index = static_cast<__index_type>(variant_npos);
      }

      constexpr
      ~_Variant_storage()
      { _M_reset(); }

      constexpr bool
      _M_valid() const noexcept
      {
 if constexpr (__variant::__never_valueless<_Types...>())
   return true;
 return this->_M_index != __index_type(variant_npos);
      }

      _Variadic_union<false, _Types...> _M_u;
      using __index_type = __select_index<_Types...>;
      __index_type _M_index;
    };

  template<typename... _Types>
    struct _Variant_storage<true, _Types...>
    {
      constexpr
      _Variant_storage()
      : _M_index(static_cast<__index_type>(variant_npos))
      { }

      template<size_t _Np, typename... _Args>
 constexpr
 _Variant_storage(in_place_index_t<_Np>, _Args&&... __args)
 : _M_u(in_place_index<_Np>, std::forward<_Args>(__args)...),
 _M_index{_Np}
 { }

      constexpr void
      _M_reset() noexcept
      { _M_index = static_cast<__index_type>(variant_npos); }

      constexpr bool
      _M_valid() const noexcept
      {
 if constexpr (__variant::__never_valueless<_Types...>())
   return true;






 return this->_M_index != static_cast<__index_type>(variant_npos);
      }

      _Variadic_union<true, _Types...> _M_u;
      using __index_type = __select_index<_Types...>;
      __index_type _M_index;
    };


  template<size_t _Np, bool _Triv, typename... _Types, typename... _Args>
    constexpr
    inline void
    __emplace(_Variant_storage<_Triv, _Types...>& __v, _Args&&... __args)
    {
      __v._M_reset();
      auto* __addr = __variant::__construct_n<_Np>(__v._M_u);
      std::_Construct(__addr, in_place_index<0>,
        std::forward<_Args>(__args)...);

      __v._M_index = _Np;
    }

  template<typename... _Types>
    using _Variant_storage_alias =
 _Variant_storage<_Traits<_Types...>::_S_trivial_dtor, _Types...>;




  template<bool, typename... _Types>
    struct _Copy_ctor_base : _Variant_storage_alias<_Types...>
    {
      using _Base = _Variant_storage_alias<_Types...>;
      using _Base::_Base;

      constexpr
      _Copy_ctor_base(const _Copy_ctor_base& __rhs)
   noexcept(_Traits<_Types...>::_S_nothrow_copy_ctor)
      {
 __variant::__raw_idx_visit(
   [this](auto&& __rhs_mem, auto __rhs_index) mutable
   {
     constexpr size_t __j = __rhs_index;
     if constexpr (__j != variant_npos)
       std::_Construct(std::__addressof(this->_M_u),
         in_place_index<__j>, __rhs_mem);
   }, __variant_cast<_Types...>(__rhs));
 this->_M_index = __rhs._M_index;
      }

      _Copy_ctor_base(_Copy_ctor_base&&) = default;
      _Copy_ctor_base& operator=(const _Copy_ctor_base&) = default;
      _Copy_ctor_base& operator=(_Copy_ctor_base&&) = default;
    };

  template<typename... _Types>
    struct _Copy_ctor_base<true, _Types...> : _Variant_storage_alias<_Types...>
    {
      using _Base = _Variant_storage_alias<_Types...>;
      using _Base::_Base;
    };

  template<typename... _Types>
    using _Copy_ctor_alias =
 _Copy_ctor_base<_Traits<_Types...>::_S_trivial_copy_ctor, _Types...>;

  template<bool, typename... _Types>
    struct _Move_ctor_base : _Copy_ctor_alias<_Types...>
    {
      using _Base = _Copy_ctor_alias<_Types...>;
      using _Base::_Base;

      constexpr
      _Move_ctor_base(_Move_ctor_base&& __rhs)
   noexcept(_Traits<_Types...>::_S_nothrow_move_ctor)
      {
 __variant::__raw_idx_visit(
   [this](auto&& __rhs_mem, auto __rhs_index) mutable
   {
     constexpr size_t __j = __rhs_index;
     if constexpr (__j != variant_npos)
       std::_Construct(std::__addressof(this->_M_u),
         in_place_index<__j>,
         std::forward<decltype(__rhs_mem)>(__rhs_mem));
   }, __variant_cast<_Types...>(std::move(__rhs)));
 this->_M_index = __rhs._M_index;
      }

      _Move_ctor_base(const _Move_ctor_base&) = default;
      _Move_ctor_base& operator=(const _Move_ctor_base&) = default;
      _Move_ctor_base& operator=(_Move_ctor_base&&) = default;
    };

  template<typename... _Types>
    struct _Move_ctor_base<true, _Types...> : _Copy_ctor_alias<_Types...>
    {
      using _Base = _Copy_ctor_alias<_Types...>;
      using _Base::_Base;
    };

  template<typename... _Types>
    using _Move_ctor_alias =
 _Move_ctor_base<_Traits<_Types...>::_S_trivial_move_ctor, _Types...>;

  template<bool, typename... _Types>
    struct _Copy_assign_base : _Move_ctor_alias<_Types...>
    {
      using _Base = _Move_ctor_alias<_Types...>;
      using _Base::_Base;

      constexpr
      _Copy_assign_base&
      operator=(const _Copy_assign_base& __rhs)
   noexcept(_Traits<_Types...>::_S_nothrow_copy_assign)
      {
 __variant::__raw_idx_visit(
   [this](auto&& __rhs_mem, auto __rhs_index) mutable
   {
     constexpr size_t __j = __rhs_index;
     if constexpr (__j == variant_npos)
       this->_M_reset();
     else if (this->_M_index == __j)
       __variant::__get<__j>(*this) = __rhs_mem;
     else
       {
  using _Tj = typename _Nth_type<__j, _Types...>::type;
  if constexpr (is_nothrow_copy_constructible_v<_Tj>
         || !is_nothrow_move_constructible_v<_Tj>)
    __variant::__emplace<__j>(*this, __rhs_mem);
  else
    {
      using _Variant = variant<_Types...>;
      _Variant& __self = __variant_cast<_Types...>(*this);
      __self = _Variant(in_place_index<__j>, __rhs_mem);
    }
       }
   }, __variant_cast<_Types...>(__rhs));
 return *this;
      }

      _Copy_assign_base(const _Copy_assign_base&) = default;
      _Copy_assign_base(_Copy_assign_base&&) = default;
      _Copy_assign_base& operator=(_Copy_assign_base&&) = default;
    };

  template<typename... _Types>
    struct _Copy_assign_base<true, _Types...> : _Move_ctor_alias<_Types...>
    {
      using _Base = _Move_ctor_alias<_Types...>;
      using _Base::_Base;
    };

  template<typename... _Types>
    using _Copy_assign_alias =
      _Copy_assign_base<_Traits<_Types...>::_S_trivial_copy_assign, _Types...>;

  template<bool, typename... _Types>
    struct _Move_assign_base : _Copy_assign_alias<_Types...>
    {
      using _Base = _Copy_assign_alias<_Types...>;
      using _Base::_Base;

      constexpr
      _Move_assign_base&
      operator=(_Move_assign_base&& __rhs)
   noexcept(_Traits<_Types...>::_S_nothrow_move_assign)
      {
 __variant::__raw_idx_visit(
   [this](auto&& __rhs_mem, auto __rhs_index) mutable
   {
     constexpr size_t __j = __rhs_index;
     if constexpr (__j != variant_npos)
       {
  if (this->_M_index == __j)
    __variant::__get<__j>(*this) = std::move(__rhs_mem);
  else
    {
      using _Tj = typename _Nth_type<__j, _Types...>::type;
      if constexpr (is_nothrow_move_constructible_v<_Tj>)
        __variant::__emplace<__j>(*this, std::move(__rhs_mem));
      else
        {
   using _Variant = variant<_Types...>;
   _Variant& __self = __variant_cast<_Types...>(*this);
   __self.template emplace<__j>(std::move(__rhs_mem));
        }
    }
       }
     else
       this->_M_reset();
   }, __variant_cast<_Types...>(__rhs));
 return *this;
      }

      _Move_assign_base(const _Move_assign_base&) = default;
      _Move_assign_base(_Move_assign_base&&) = default;
      _Move_assign_base& operator=(const _Move_assign_base&) = default;
    };

  template<typename... _Types>
    struct _Move_assign_base<true, _Types...> : _Copy_assign_alias<_Types...>
    {
      using _Base = _Copy_assign_alias<_Types...>;
      using _Base::_Base;
    };

  template<typename... _Types>
    using _Move_assign_alias =
      _Move_assign_base<_Traits<_Types...>::_S_trivial_move_assign, _Types...>;

  template<typename... _Types>
    struct _Variant_base : _Move_assign_alias<_Types...>
    {
      using _Base = _Move_assign_alias<_Types...>;

      constexpr
      _Variant_base() noexcept(_Traits<_Types...>::_S_nothrow_default_ctor)
      : _Variant_base(in_place_index<0>) { }

      template<size_t _Np, typename... _Args>
 constexpr explicit
 _Variant_base(in_place_index_t<_Np> __i, _Args&&... __args)
 : _Base(__i, std::forward<_Args>(__args)...)
 { }

      _Variant_base(const _Variant_base&) = default;
      _Variant_base(_Variant_base&&) = default;
      _Variant_base& operator=(const _Variant_base&) = default;
      _Variant_base& operator=(_Variant_base&&) = default;
    };

  template<typename _Tp, typename... _Types>
    inline constexpr bool __exactly_once
      = std::__find_uniq_type_in_pack<_Tp, _Types...>() < sizeof...(_Types);


  template<typename _Ti> struct _Arr { _Ti _M_x[1]; };


  template<size_t _Ind, typename _Tp, typename _Ti, typename = void>
    struct _Build_FUN
    {


      void _S_fun() = delete;
    };


  template<size_t _Ind, typename _Tp, typename _Ti>
    struct _Build_FUN<_Ind, _Tp, _Ti,
        void_t<decltype(_Arr<_Ti>{{std::declval<_Tp>()}})>>
    {

      static integral_constant<size_t, _Ind> _S_fun(_Ti);
    };

  template<typename _Tp, typename _Variant,
    typename = make_index_sequence<variant_size_v<_Variant>>>
    struct _Build_FUNs;

  template<typename _Tp, typename... _Ti, size_t... _Ind>
    struct _Build_FUNs<_Tp, variant<_Ti...>, index_sequence<_Ind...>>
    : _Build_FUN<_Ind, _Tp, _Ti>...
    {
      using _Build_FUN<_Ind, _Tp, _Ti>::_S_fun...;
    };



  template<typename _Tp, typename _Variant>
    using _FUN_type
      = decltype(_Build_FUNs<_Tp, _Variant>::_S_fun(std::declval<_Tp>()));


  template<typename _Tp, typename _Variant, typename = void>
    inline constexpr size_t
    __accepted_index = variant_npos;

  template<typename _Tp, typename _Variant>
    inline constexpr size_t
    __accepted_index<_Tp, _Variant, void_t<_FUN_type<_Tp, _Variant>>>
      = _FUN_type<_Tp, _Variant>::value;

  template<typename _Maybe_variant_cookie, typename _Variant,
    typename = __remove_cvref_t<_Variant>>
    inline constexpr bool
    __extra_visit_slot_needed = false;

  template<typename _Var, typename... _Types>
    inline constexpr bool
    __extra_visit_slot_needed<__variant_cookie, _Var, variant<_Types...>>
      = !__variant::__never_valueless<_Types...>();

  template<typename _Var, typename... _Types>
    inline constexpr bool
    __extra_visit_slot_needed<__variant_idx_cookie, _Var, variant<_Types...>>
      = !__variant::__never_valueless<_Types...>();


  template<typename _Tp, size_t... _Dimensions>
    struct _Multi_array;


  template<typename _Tp>
    struct _Multi_array<_Tp>
    {
      template<typename>
 struct __untag_result
 : false_type
 { using element_type = _Tp; };

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wignored-qualifiers"
      template <typename... _Args>
 struct __untag_result<const void(*)(_Args...)>
 : false_type
 { using element_type = void(*)(_Args...); };
#pragma GCC diagnostic pop

      template <typename... _Args>
 struct __untag_result<__variant_cookie(*)(_Args...)>
 : false_type
 { using element_type = void(*)(_Args...); };

      template <typename... _Args>
 struct __untag_result<__variant_idx_cookie(*)(_Args...)>
 : false_type
 { using element_type = void(*)(_Args...); };

      template <typename _Res, typename... _Args>
 struct __untag_result<__deduce_visit_result<_Res>(*)(_Args...)>
 : true_type
 { using element_type = _Res(*)(_Args...); };

      using __result_is_deduced = __untag_result<_Tp>;

      constexpr const typename __untag_result<_Tp>::element_type&
      _M_access() const
      { return _M_data; }

      typename __untag_result<_Tp>::element_type _M_data;
    };


  template<typename _Ret,
    typename _Visitor,
    typename... _Variants,
    size_t __first, size_t... __rest>
    struct _Multi_array<_Ret(*)(_Visitor, _Variants...), __first, __rest...>
    {
      static constexpr size_t __index =
 sizeof...(_Variants) - sizeof...(__rest) - 1;

      using _Variant = typename _Nth_type<__index, _Variants...>::type;

      static constexpr int __do_cookie =
 __extra_visit_slot_needed<_Ret, _Variant> ? 1 : 0;

      using _Tp = _Ret(*)(_Visitor, _Variants...);

      template<typename... _Args>
 constexpr decltype(auto)
 _M_access(size_t __first_index, _Args... __rest_indices) const
        {
   return _M_arr[__first_index + __do_cookie]
     ._M_access(__rest_indices...);
 }

      _Multi_array<_Tp, __rest...> _M_arr[__first + __do_cookie];
    };
# 949 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/variant" 3
  template<typename _Array_type, typename _Index_seq>
    struct __gen_vtable_impl;
# 959 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/variant" 3
  template<typename _Result_type, typename _Visitor, size_t... __dimensions,
    typename... _Variants, size_t... __indices>
    struct __gen_vtable_impl<
 _Multi_array<_Result_type (*)(_Visitor, _Variants...), __dimensions...>,
 std::index_sequence<__indices...>>
    {
      using _Next =
   remove_reference_t<typename _Nth_type<sizeof...(__indices),
        _Variants...>::type>;
      using _Array_type =
   _Multi_array<_Result_type (*)(_Visitor, _Variants...),
         __dimensions...>;

      static constexpr _Array_type
      _S_apply()
      {
 _Array_type __vtable{};
 _S_apply_all_alts(
   __vtable, make_index_sequence<variant_size_v<_Next>>());
 return __vtable;
      }

      template<size_t... __var_indices>
 static constexpr void
 _S_apply_all_alts(_Array_type& __vtable,
     std::index_sequence<__var_indices...>)
 {
   if constexpr (__extra_visit_slot_needed<_Result_type, _Next>)
     (_S_apply_single_alt<true, __var_indices>(
       __vtable._M_arr[__var_indices + 1],
       &(__vtable._M_arr[0])), ...);
   else
     (_S_apply_single_alt<false, __var_indices>(
       __vtable._M_arr[__var_indices]), ...);
 }

      template<bool __do_cookie, size_t __index, typename _Tp>
 static constexpr void
 _S_apply_single_alt(_Tp& __element, _Tp* __cookie_element = nullptr)
 {
   if constexpr (__do_cookie)
     {
       __element = __gen_vtable_impl<
  _Tp,
  std::index_sequence<__indices..., __index>>::_S_apply();
       *__cookie_element = __gen_vtable_impl<
  _Tp,
  std::index_sequence<__indices..., variant_npos>>::_S_apply();
     }
   else
     {
       auto __tmp_element = __gen_vtable_impl<
  remove_reference_t<decltype(__element)>,
  std::index_sequence<__indices..., __index>>::_S_apply();
       static_assert(is_same_v<_Tp, decltype(__tmp_element)>,
       "std::visit requires the visitor to have the same "
       "return type for all alternatives of a variant");
       __element = __tmp_element;
     }
 }
    };




  template<typename _Result_type, typename _Visitor, typename... _Variants,
    size_t... __indices>
    struct __gen_vtable_impl<
      _Multi_array<_Result_type (*)(_Visitor, _Variants...)>,
     std::index_sequence<__indices...>>
    {
      using _Array_type =
   _Multi_array<_Result_type (*)(_Visitor, _Variants...)>;

      template<size_t __index, typename _Variant>
 static constexpr decltype(auto)
 __element_by_index_or_cookie(_Variant&& __var) noexcept
        {
   if constexpr (__index != variant_npos)
     return __variant::__get<__index>(std::forward<_Variant>(__var));
   else
     return __variant_cookie{};
 }

      static constexpr decltype(auto)
      __visit_invoke(_Visitor&& __visitor, _Variants... __vars)
      {
 if constexpr (is_same_v<_Result_type, __variant_idx_cookie>)


   std::__invoke(std::forward<_Visitor>(__visitor),
       __element_by_index_or_cookie<__indices>(
  std::forward<_Variants>(__vars))...,
       integral_constant<size_t, __indices>()...);
 else if constexpr (is_same_v<_Result_type, __variant_cookie>)

   std::__invoke(std::forward<_Visitor>(__visitor),
       __element_by_index_or_cookie<__indices>(
  std::forward<_Variants>(__vars))...);
 else if constexpr (_Array_type::__result_is_deduced::value)

   return std::__invoke(std::forward<_Visitor>(__visitor),
       __element_by_index_or_cookie<__indices>(
  std::forward<_Variants>(__vars))...);
 else
   return std::__invoke_r<_Result_type>(
       std::forward<_Visitor>(__visitor),
       __variant::__get<__indices>(std::forward<_Variants>(__vars))...);
      }

      static constexpr auto
      _S_apply()
      {
 if constexpr (_Array_type::__result_is_deduced::value)
   {
     constexpr bool __visit_ret_type_mismatch =
       !is_same_v<typename _Result_type::type,
    decltype(__visit_invoke(std::declval<_Visitor>(),
        std::declval<_Variants>()...))>;
     if constexpr (__visit_ret_type_mismatch)
       {
  struct __cannot_match {};
  return __cannot_match{};
       }
     else
       return _Array_type{&__visit_invoke};
   }
 else
   return _Array_type{&__visit_invoke};
      }
    };

  template<typename _Result_type, typename _Visitor, typename... _Variants>
    struct __gen_vtable
    {
      using _Array_type =
   _Multi_array<_Result_type (*)(_Visitor, _Variants...),
         variant_size_v<remove_reference_t<_Variants>>...>;

      static constexpr _Array_type _S_vtable
 = __gen_vtable_impl<_Array_type, std::index_sequence<>>::_S_apply();
    };

  template<size_t _Np, typename _Tp>
    struct _Base_dedup : public _Tp { };

  template<typename _Variant, typename __indices>
    struct _Variant_hash_base;

  template<typename... _Types, size_t... __indices>
    struct _Variant_hash_base<variant<_Types...>,
         std::index_sequence<__indices...>>
    : _Base_dedup<__indices, __poison_hash<remove_const_t<_Types>>>... { };


  template<size_t _Np, typename _Variant,
      typename _AsV = decltype(__variant::__as(std::declval<_Variant>())),
      typename _Tp = variant_alternative_t<_Np, remove_reference_t<_AsV>>>
    using __get_t
      = __conditional_t<is_lvalue_reference_v<_Variant>, _Tp&, _Tp&&>;


  template<typename _Visitor, typename... _Variants>
    using __visit_result_t
      = invoke_result_t<_Visitor, __get_t<0, _Variants>...>;

  template<typename _Tp, typename... _Types>
    constexpr inline bool __same_types = (is_same_v<_Tp, _Types> && ...);

  template <typename _Visitor, typename _Variant, size_t... _Idxs>
    constexpr bool __check_visitor_results(std::index_sequence<_Idxs...>)
    {
      return __same_types<
 invoke_result_t<_Visitor, __get_t<_Idxs, _Variant>>...
 >;
    }

}
}

  template<typename _Tp, typename... _Types>
    constexpr bool
    holds_alternative(const variant<_Types...>& __v) noexcept
    {
      static_assert(__detail::__variant::__exactly_once<_Tp, _Types...>,
      "T must occur exactly once in alternatives");
      return __v.index() == std::__find_uniq_type_in_pack<_Tp, _Types...>();
    }

  template<typename _Tp, typename... _Types>
    constexpr _Tp&
    get(variant<_Types...>& __v)
    {
      static_assert(__detail::__variant::__exactly_once<_Tp, _Types...>,
      "T must occur exactly once in alternatives");
      constexpr size_t __n = std::__find_uniq_type_in_pack<_Tp, _Types...>();
      return std::get<__n>(__v);
    }

  template<typename _Tp, typename... _Types>
    constexpr _Tp&&
    get(variant<_Types...>&& __v)
    {
      static_assert(__detail::__variant::__exactly_once<_Tp, _Types...>,
      "T must occur exactly once in alternatives");
      constexpr size_t __n = std::__find_uniq_type_in_pack<_Tp, _Types...>();
      return std::get<__n>(std::move(__v));
    }

  template<typename _Tp, typename... _Types>
    constexpr const _Tp&
    get(const variant<_Types...>& __v)
    {
      static_assert(__detail::__variant::__exactly_once<_Tp, _Types...>,
      "T must occur exactly once in alternatives");
      constexpr size_t __n = std::__find_uniq_type_in_pack<_Tp, _Types...>();
      return std::get<__n>(__v);
    }

  template<typename _Tp, typename... _Types>
    constexpr const _Tp&&
    get(const variant<_Types...>&& __v)
    {
      static_assert(__detail::__variant::__exactly_once<_Tp, _Types...>,
      "T must occur exactly once in alternatives");
      constexpr size_t __n = std::__find_uniq_type_in_pack<_Tp, _Types...>();
      return std::get<__n>(std::move(__v));
    }

  template<size_t _Np, typename... _Types>
    constexpr add_pointer_t<variant_alternative_t<_Np, variant<_Types...>>>
    get_if(variant<_Types...>* __ptr) noexcept
    {
      using _Alternative_type = variant_alternative_t<_Np, variant<_Types...>>;
      static_assert(_Np < sizeof...(_Types),
      "The index must be in [0, number of alternatives)");
      static_assert(!is_void_v<_Alternative_type>, "_Tp must not be void");
      if (__ptr && __ptr->index() == _Np)
 return std::addressof(__detail::__variant::__get<_Np>(*__ptr));
      return nullptr;
    }

  template<size_t _Np, typename... _Types>
    constexpr
    add_pointer_t<const variant_alternative_t<_Np, variant<_Types...>>>
    get_if(const variant<_Types...>* __ptr) noexcept
    {
      using _Alternative_type = variant_alternative_t<_Np, variant<_Types...>>;
      static_assert(_Np < sizeof...(_Types),
      "The index must be in [0, number of alternatives)");
      static_assert(!is_void_v<_Alternative_type>, "_Tp must not be void");
      if (__ptr && __ptr->index() == _Np)
 return std::addressof(__detail::__variant::__get<_Np>(*__ptr));
      return nullptr;
    }

  template<typename _Tp, typename... _Types>
    constexpr add_pointer_t<_Tp>
    get_if(variant<_Types...>* __ptr) noexcept
    {
      static_assert(__detail::__variant::__exactly_once<_Tp, _Types...>,
      "T must occur exactly once in alternatives");
      static_assert(!is_void_v<_Tp>, "_Tp must not be void");
      constexpr size_t __n = std::__find_uniq_type_in_pack<_Tp, _Types...>();
      return std::get_if<__n>(__ptr);
    }

  template<typename _Tp, typename... _Types>
    constexpr add_pointer_t<const _Tp>
    get_if(const variant<_Types...>* __ptr) noexcept
    {
      static_assert(__detail::__variant::__exactly_once<_Tp, _Types...>,
      "T must occur exactly once in alternatives");
      static_assert(!is_void_v<_Tp>, "_Tp must not be void");
      constexpr size_t __n = std::__find_uniq_type_in_pack<_Tp, _Types...>();
      return std::get_if<__n>(__ptr);
    }

  struct monostate { };
# 1264 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/variant" 3
  template<typename... _Types> constexpr bool operator <(const variant<_Types...>& __lhs, const variant<_Types...>& __rhs) { bool __ret = true; __detail::__variant::__raw_idx_visit( [&__ret, &__lhs] (auto&& __rhs_mem, auto __rhs_index) mutable { if constexpr (__rhs_index != variant_npos) { if (__lhs.index() == __rhs_index) { auto& __this_mem = std::get<__rhs_index>(__lhs); __ret = __this_mem < __rhs_mem; } else __ret = (__lhs.index() + 1) < (__rhs_index + 1); } else __ret = (__lhs.index() + 1) < (__rhs_index + 1); }, __rhs); return __ret; }
  template<typename... _Types> constexpr bool operator <=(const variant<_Types...>& __lhs, const variant<_Types...>& __rhs) { bool __ret = true; __detail::__variant::__raw_idx_visit( [&__ret, &__lhs] (auto&& __rhs_mem, auto __rhs_index) mutable { if constexpr (__rhs_index != variant_npos) { if (__lhs.index() == __rhs_index) { auto& __this_mem = std::get<__rhs_index>(__lhs); __ret = __this_mem <= __rhs_mem; } else __ret = (__lhs.index() + 1) <= (__rhs_index + 1); } else __ret = (__lhs.index() + 1) <= (__rhs_index + 1); }, __rhs); return __ret; }
  template<typename... _Types> constexpr bool operator ==(const variant<_Types...>& __lhs, const variant<_Types...>& __rhs) { bool __ret = true; __detail::__variant::__raw_idx_visit( [&__ret, &__lhs] (auto&& __rhs_mem, auto __rhs_index) mutable { if constexpr (__rhs_index != variant_npos) { if (__lhs.index() == __rhs_index) { auto& __this_mem = std::get<__rhs_index>(__lhs); __ret = __this_mem == __rhs_mem; } else __ret = (__lhs.index() + 1) == (__rhs_index + 1); } else __ret = (__lhs.index() + 1) == (__rhs_index + 1); }, __rhs); return __ret; }
  template<typename... _Types> constexpr bool operator !=(const variant<_Types...>& __lhs, const variant<_Types...>& __rhs) { bool __ret = true; __detail::__variant::__raw_idx_visit( [&__ret, &__lhs] (auto&& __rhs_mem, auto __rhs_index) mutable { if constexpr (__rhs_index != variant_npos) { if (__lhs.index() == __rhs_index) { auto& __this_mem = std::get<__rhs_index>(__lhs); __ret = __this_mem != __rhs_mem; } else __ret = (__lhs.index() + 1) != (__rhs_index + 1); } else __ret = (__lhs.index() + 1) != (__rhs_index + 1); }, __rhs); return __ret; }
  template<typename... _Types> constexpr bool operator >=(const variant<_Types...>& __lhs, const variant<_Types...>& __rhs) { bool __ret = true; __detail::__variant::__raw_idx_visit( [&__ret, &__lhs] (auto&& __rhs_mem, auto __rhs_index) mutable { if constexpr (__rhs_index != variant_npos) { if (__lhs.index() == __rhs_index) { auto& __this_mem = std::get<__rhs_index>(__lhs); __ret = __this_mem >= __rhs_mem; } else __ret = (__lhs.index() + 1) >= (__rhs_index + 1); } else __ret = (__lhs.index() + 1) >= (__rhs_index + 1); }, __rhs); return __ret; }
  template<typename... _Types> constexpr bool operator >(const variant<_Types...>& __lhs, const variant<_Types...>& __rhs) { bool __ret = true; __detail::__variant::__raw_idx_visit( [&__ret, &__lhs] (auto&& __rhs_mem, auto __rhs_index) mutable { if constexpr (__rhs_index != variant_npos) { if (__lhs.index() == __rhs_index) { auto& __this_mem = std::get<__rhs_index>(__lhs); __ret = __this_mem > __rhs_mem; } else __ret = (__lhs.index() + 1) > (__rhs_index + 1); } else __ret = (__lhs.index() + 1) > (__rhs_index + 1); }, __rhs); return __ret; }



  constexpr bool operator==(monostate, monostate) noexcept { return true; }


  template<typename... _Types>
    requires (three_way_comparable<_Types> && ...)
    constexpr
    common_comparison_category_t<compare_three_way_result_t<_Types>...>
    operator<=>(const variant<_Types...>& __v, const variant<_Types...>& __w)
    {
      common_comparison_category_t<compare_three_way_result_t<_Types>...> __ret
 = strong_ordering::equal;

      __detail::__variant::__raw_idx_visit(
 [&__ret, &__v] (auto&& __w_mem, auto __w_index) mutable
 {
   if constexpr (__w_index != variant_npos)
     {
       if (__v.index() == __w_index)
  {
    auto& __this_mem = std::get<__w_index>(__v);
    __ret = __this_mem <=> __w_mem;
    return;
  }
     }
   __ret = (__v.index() + 1) <=> (__w_index + 1);
 }, __w);
      return __ret;
    }

  constexpr strong_ordering
  operator<=>(monostate, monostate) noexcept { return strong_ordering::equal; }
# 1312 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/variant" 3
  template<typename _Visitor, typename... _Variants>
    constexpr __detail::__variant::__visit_result_t<_Visitor, _Variants...>
    visit(_Visitor&&, _Variants&&...);

  template<typename... _Types>
    constexpr
    inline enable_if_t<(is_move_constructible_v<_Types> && ...)
   && (is_swappable_v<_Types> && ...)>
    swap(variant<_Types...>& __lhs, variant<_Types...>& __rhs)
    noexcept(noexcept(__lhs.swap(__rhs)))
    { __lhs.swap(__rhs); }

  template<typename... _Types>
    enable_if_t<!((is_move_constructible_v<_Types> && ...)
     && (is_swappable_v<_Types> && ...))>
    swap(variant<_Types...>&, variant<_Types...>&) = delete;

  class bad_variant_access : public exception
  {
  public:
    bad_variant_access() noexcept { }

    const char* what() const noexcept override
    { return _M_reason; }

  private:
    bad_variant_access(const char* __reason) noexcept : _M_reason(__reason) { }


    const char* _M_reason = "bad variant access";

    friend void __throw_bad_variant_access(const char* __what);
  };


  inline void
  __throw_bad_variant_access(const char* __what)
  { (throw (bad_variant_access(__what))); }

  inline void
  __throw_bad_variant_access(bool __valueless)
  {
    if (__valueless) [[__unlikely__]]
      __throw_bad_variant_access("std::get: variant is valueless");
    else
      __throw_bad_variant_access("std::get: wrong index for variant");
  }

  template<typename... _Types>
    class variant
    : private __detail::__variant::_Variant_base<_Types...>,
      private _Enable_copy_move<
 __detail::__variant::_Traits<_Types...>::_S_copy_ctor,
 __detail::__variant::_Traits<_Types...>::_S_copy_assign,
 __detail::__variant::_Traits<_Types...>::_S_move_ctor,
 __detail::__variant::_Traits<_Types...>::_S_move_assign,
 variant<_Types...>>
    {
    private:
      template <typename... _UTypes, typename _Tp>
 friend constexpr decltype(auto)
 __variant_cast(_Tp&&);

      static_assert(sizeof...(_Types) > 0,
      "variant must have at least one alternative");
      static_assert(!(std::is_reference_v<_Types> || ...),
      "variant must have no reference alternative");
      static_assert(!(std::is_void_v<_Types> || ...),
      "variant must have no void alternative");

      using _Base = __detail::__variant::_Variant_base<_Types...>;

      template<typename _Tp>
 static constexpr bool __not_self
   = !is_same_v<__remove_cvref_t<_Tp>, variant>;

      template<typename _Tp>
 static constexpr bool
 __exactly_once = __detail::__variant::__exactly_once<_Tp, _Types...>;

      template<typename _Tp>
 static constexpr size_t __accepted_index
   = __detail::__variant::__accepted_index<_Tp, variant>;

      template<size_t _Np, typename = enable_if_t<(_Np < sizeof...(_Types))>>
 using __to_type = typename _Nth_type<_Np, _Types...>::type;

      template<typename _Tp, typename = enable_if_t<__not_self<_Tp>>>
 using __accepted_type = __to_type<__accepted_index<_Tp>>;

      template<typename _Tp>
 static constexpr size_t __index_of
   = std::__find_uniq_type_in_pack<_Tp, _Types...>();

      using _Traits = __detail::__variant::_Traits<_Types...>;

      template<typename _Tp>
 struct __is_in_place_tag : false_type { };
      template<typename _Tp>
 struct __is_in_place_tag<in_place_type_t<_Tp>> : true_type { };
      template<size_t _Np>
 struct __is_in_place_tag<in_place_index_t<_Np>> : true_type { };

      template<typename _Tp>
 static constexpr bool __not_in_place_tag
   = !__is_in_place_type_v<__remove_cvref_t<_Tp>>
       && !__is_in_place_index_v<__remove_cvref_t<_Tp>>;

    public:

      variant() requires is_default_constructible_v<__to_type<0>> = default;
# 1431 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/variant" 3
      variant(const variant& __rhs) = default;
      variant(variant&&) = default;
      variant& operator=(const variant&) = default;
      variant& operator=(variant&&) = default;
      constexpr ~variant() = default;

      template<typename _Tp,
        typename = enable_if_t<sizeof...(_Types) != 0>,
        typename = enable_if_t<__not_in_place_tag<_Tp>>,
        typename _Tj = __accepted_type<_Tp&&>,
        typename = enable_if_t<__exactly_once<_Tj>
          && is_constructible_v<_Tj, _Tp>>>
 constexpr
 variant(_Tp&& __t)
 noexcept(is_nothrow_constructible_v<_Tj, _Tp>)
 : variant(in_place_index<__accepted_index<_Tp>>,
    std::forward<_Tp>(__t))
 { }

      template<typename _Tp, typename... _Args,
        typename = enable_if_t<__exactly_once<_Tp>
          && is_constructible_v<_Tp, _Args...>>>
 constexpr explicit
 variant(in_place_type_t<_Tp>, _Args&&... __args)
 : variant(in_place_index<__index_of<_Tp>>,
    std::forward<_Args>(__args)...)
 { }

      template<typename _Tp, typename _Up, typename... _Args,
        typename = enable_if_t<__exactly_once<_Tp>
          && is_constructible_v<_Tp,
        initializer_list<_Up>&, _Args...>>>
 constexpr explicit
 variant(in_place_type_t<_Tp>, initializer_list<_Up> __il,
  _Args&&... __args)
 : variant(in_place_index<__index_of<_Tp>>, __il,
    std::forward<_Args>(__args)...)
 { }

      template<size_t _Np, typename... _Args,
        typename _Tp = __to_type<_Np>,
        typename = enable_if_t<is_constructible_v<_Tp, _Args...>>>
 constexpr explicit
 variant(in_place_index_t<_Np>, _Args&&... __args)
 : _Base(in_place_index<_Np>, std::forward<_Args>(__args)...)
 { }

      template<size_t _Np, typename _Up, typename... _Args,
        typename _Tp = __to_type<_Np>,
        typename = enable_if_t<is_constructible_v<_Tp,
        initializer_list<_Up>&,
        _Args...>>>
 constexpr explicit
 variant(in_place_index_t<_Np>, initializer_list<_Up> __il,
  _Args&&... __args)
 : _Base(in_place_index<_Np>, __il, std::forward<_Args>(__args)...)
 { }

      template<typename _Tp>
 constexpr
 enable_if_t<__exactly_once<__accepted_type<_Tp&&>>
      && is_constructible_v<__accepted_type<_Tp&&>, _Tp>
      && is_assignable_v<__accepted_type<_Tp&&>&, _Tp>,
      variant&>
 operator=(_Tp&& __rhs)
 noexcept(is_nothrow_assignable_v<__accepted_type<_Tp&&>&, _Tp>
   && is_nothrow_constructible_v<__accepted_type<_Tp&&>, _Tp>)
 {
   constexpr auto __index = __accepted_index<_Tp>;
   if (index() == __index)
     std::get<__index>(*this) = std::forward<_Tp>(__rhs);
   else
     {
       using _Tj = __accepted_type<_Tp&&>;
       if constexpr (is_nothrow_constructible_v<_Tj, _Tp>
       || !is_nothrow_move_constructible_v<_Tj>)
  this->emplace<__index>(std::forward<_Tp>(__rhs));
       else


  this->emplace<__index>(_Tj(std::forward<_Tp>(__rhs)));
     }
   return *this;
 }

      template<typename _Tp, typename... _Args>
 constexpr
 enable_if_t<is_constructible_v<_Tp, _Args...> && __exactly_once<_Tp>,
      _Tp&>
 emplace(_Args&&... __args)
 {
   constexpr size_t __index = __index_of<_Tp>;
   return this->emplace<__index>(std::forward<_Args>(__args)...);
 }

      template<typename _Tp, typename _Up, typename... _Args>
 constexpr
 enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>
      && __exactly_once<_Tp>,
      _Tp&>
 emplace(initializer_list<_Up> __il, _Args&&... __args)
 {
   constexpr size_t __index = __index_of<_Tp>;
   return this->emplace<__index>(__il, std::forward<_Args>(__args)...);
 }

      template<size_t _Np, typename... _Args>
 constexpr
 enable_if_t<is_constructible_v<__to_type<_Np>, _Args...>,
      __to_type<_Np>&>
 emplace(_Args&&... __args)
 {
   namespace __variant = std::__detail::__variant;
   using type = typename _Nth_type<_Np, _Types...>::type;


   if constexpr (is_nothrow_constructible_v<type, _Args...>)
     {
       __variant::__emplace<_Np>(*this, std::forward<_Args>(__args)...);
     }
   else if constexpr (is_scalar_v<type>)
     {

       const type __tmp(std::forward<_Args>(__args)...);

       __variant::__emplace<_Np>(*this, __tmp);
     }
   else if constexpr (__variant::_Never_valueless_alt<type>()
       && _Traits::_S_move_assign)
     {

       variant __tmp(in_place_index<_Np>,
       std::forward<_Args>(__args)...);

       *this = std::move(__tmp);
     }
   else
     {


       __variant::__emplace<_Np>(*this, std::forward<_Args>(__args)...);
     }
   return std::get<_Np>(*this);
 }

      template<size_t _Np, typename _Up, typename... _Args>
 constexpr
 enable_if_t<is_constructible_v<__to_type<_Np>,
           initializer_list<_Up>&, _Args...>,
      __to_type<_Np>&>
 emplace(initializer_list<_Up> __il, _Args&&... __args)
 {
   namespace __variant = std::__detail::__variant;
   using type = typename _Nth_type<_Np, _Types...>::type;


   if constexpr (is_nothrow_constructible_v<type,
         initializer_list<_Up>&,
         _Args...>)
     {
       __variant::__emplace<_Np>(*this, __il,
     std::forward<_Args>(__args)...);
     }
   else if constexpr (__variant::_Never_valueless_alt<type>()
       && _Traits::_S_move_assign)
     {

       variant __tmp(in_place_index<_Np>, __il,
       std::forward<_Args>(__args)...);

       *this = std::move(__tmp);
     }
   else
     {


       __variant::__emplace<_Np>(*this, __il,
     std::forward<_Args>(__args)...);
     }
   return std::get<_Np>(*this);
 }

      template<size_t _Np, typename... _Args>
 enable_if_t<!(_Np < sizeof...(_Types))> emplace(_Args&&...) = delete;

      template<typename _Tp, typename... _Args>
 enable_if_t<!__exactly_once<_Tp>> emplace(_Args&&...) = delete;

      constexpr bool valueless_by_exception() const noexcept
      { return !this->_M_valid(); }

      constexpr size_t index() const noexcept
      {
 using __index_type = typename _Base::__index_type;
 if constexpr (__detail::__variant::__never_valueless<_Types...>())
   return this->_M_index;
 else if constexpr (sizeof...(_Types) <= __index_type(-1) / 2)
   return make_signed_t<__index_type>(this->_M_index);
 else
   return size_t(__index_type(this->_M_index + 1)) - 1;
      }

      constexpr
      void
      swap(variant& __rhs)
      noexcept((__is_nothrow_swappable<_Types>::value && ...)
        && is_nothrow_move_constructible_v<variant>)
      {
 static_assert((is_move_constructible_v<_Types> && ...));


 if (__rhs.valueless_by_exception()) [[__unlikely__]]
   {
     if (!this->valueless_by_exception()) [[__likely__]]
       __rhs.swap(*this);
     return;
   }

 namespace __variant = __detail::__variant;

 __variant::__raw_idx_visit(
   [this, &__rhs](auto&& __rhs_mem, auto __rhs_index) mutable
   {
     constexpr size_t __j = __rhs_index;
     if constexpr (__j != variant_npos)
       {
  if (this->index() == __j)
    {
      using std::swap;
      swap(std::get<__j>(*this), __rhs_mem);
    }
  else
    {
      auto __tmp(std::move(__rhs_mem));

      if constexpr (_Traits::_S_trivial_move_assign)
        __rhs = std::move(*this);
      else
        __variant::__raw_idx_visit(
   [&__rhs](auto&& __this_mem, auto __this_index) mutable
   {
     constexpr size_t __k = __this_index;
     if constexpr (__k != variant_npos)
       __variant::__emplace<__k>(__rhs,
            std::move(__this_mem));
   }, *this);

      __variant::__emplace<__j>(*this, std::move(__tmp));
    }
       }
   }, __rhs);
      }






    private:
      template<size_t _Np, typename _Vp>
 friend constexpr decltype(auto)
 __detail::__variant::__get(_Vp&& __v) noexcept;







      template<typename... _Tp> friend constexpr bool operator <(const variant<_Tp...>& __lhs, const variant<_Tp...>& __rhs);
      template<typename... _Tp> friend constexpr bool operator <=(const variant<_Tp...>& __lhs, const variant<_Tp...>& __rhs);
      template<typename... _Tp> friend constexpr bool operator ==(const variant<_Tp...>& __lhs, const variant<_Tp...>& __rhs);
      template<typename... _Tp> friend constexpr bool operator !=(const variant<_Tp...>& __lhs, const variant<_Tp...>& __rhs);
      template<typename... _Tp> friend constexpr bool operator >=(const variant<_Tp...>& __lhs, const variant<_Tp...>& __rhs);
      template<typename... _Tp> friend constexpr bool operator >(const variant<_Tp...>& __lhs, const variant<_Tp...>& __rhs);


    };

  template<size_t _Np, typename... _Types>
    constexpr variant_alternative_t<_Np, variant<_Types...>>&
    get(variant<_Types...>& __v)
    {
      static_assert(_Np < sizeof...(_Types),
      "The index must be in [0, number of alternatives)");
      if (__v.index() != _Np)
 __throw_bad_variant_access(__v.valueless_by_exception());
      return __detail::__variant::__get<_Np>(__v);
    }

  template<size_t _Np, typename... _Types>
    constexpr variant_alternative_t<_Np, variant<_Types...>>&&
    get(variant<_Types...>&& __v)
    {
      static_assert(_Np < sizeof...(_Types),
      "The index must be in [0, number of alternatives)");
      if (__v.index() != _Np)
 __throw_bad_variant_access(__v.valueless_by_exception());
      return __detail::__variant::__get<_Np>(std::move(__v));
    }

  template<size_t _Np, typename... _Types>
    constexpr const variant_alternative_t<_Np, variant<_Types...>>&
    get(const variant<_Types...>& __v)
    {
      static_assert(_Np < sizeof...(_Types),
      "The index must be in [0, number of alternatives)");
      if (__v.index() != _Np)
 __throw_bad_variant_access(__v.valueless_by_exception());
      return __detail::__variant::__get<_Np>(__v);
    }

  template<size_t _Np, typename... _Types>
    constexpr const variant_alternative_t<_Np, variant<_Types...>>&&
    get(const variant<_Types...>&& __v)
    {
      static_assert(_Np < sizeof...(_Types),
      "The index must be in [0, number of alternatives)");
      if (__v.index() != _Np)
 __throw_bad_variant_access(__v.valueless_by_exception());
      return __detail::__variant::__get<_Np>(std::move(__v));
    }


  template<typename _Result_type, typename _Visitor, typename... _Variants>
    constexpr decltype(auto)
    __do_visit(_Visitor&& __visitor, _Variants&&... __variants)
    {

      if constexpr (sizeof...(_Variants) == 0)
 {
   if constexpr (is_void_v<_Result_type>)
     return (void) std::forward<_Visitor>(__visitor)();
   else
     return std::forward<_Visitor>(__visitor)();
 }
      else
 {
   constexpr size_t __max = 11;


   using _V0 = typename _Nth_type<0, _Variants...>::type;

   constexpr auto __n = variant_size_v<remove_reference_t<_V0>>;

   if constexpr (sizeof...(_Variants) > 1 || __n > __max)
     {

       constexpr auto& __vtable = __detail::__variant::__gen_vtable<
  _Result_type, _Visitor&&, _Variants&&...>::_S_vtable;

       auto __func_ptr = __vtable._M_access(__variants.index()...);
       return (*__func_ptr)(std::forward<_Visitor>(__visitor),
       std::forward<_Variants>(__variants)...);
     }
   else
     {

       _V0& __v0
  = [](_V0& __v, ...) -> _V0& { return __v; }(__variants...);

       using __detail::__variant::_Multi_array;
       using __detail::__variant::__gen_vtable_impl;
       using _Ma = _Multi_array<_Result_type (*)(_Visitor&&, _V0&&)>;
# 1814 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/variant" 3
       switch (__v0.index())
  {
    case 0: { if constexpr (0 < __n) { return __gen_vtable_impl<_Ma, index_sequence<0>>:: __visit_invoke(std::forward<_Visitor>(__visitor), std::forward<_V0>(__v0)); } else __builtin_unreachable(); }
    case 1: { if constexpr (1 < __n) { return __gen_vtable_impl<_Ma, index_sequence<1>>:: __visit_invoke(std::forward<_Visitor>(__visitor), std::forward<_V0>(__v0)); } else __builtin_unreachable(); }
    case 2: { if constexpr (2 < __n) { return __gen_vtable_impl<_Ma, index_sequence<2>>:: __visit_invoke(std::forward<_Visitor>(__visitor), std::forward<_V0>(__v0)); } else __builtin_unreachable(); }
    case 3: { if constexpr (3 < __n) { return __gen_vtable_impl<_Ma, index_sequence<3>>:: __visit_invoke(std::forward<_Visitor>(__visitor), std::forward<_V0>(__v0)); } else __builtin_unreachable(); }
    case 4: { if constexpr (4 < __n) { return __gen_vtable_impl<_Ma, index_sequence<4>>:: __visit_invoke(std::forward<_Visitor>(__visitor), std::forward<_V0>(__v0)); } else __builtin_unreachable(); }
    case 5: { if constexpr (5 < __n) { return __gen_vtable_impl<_Ma, index_sequence<5>>:: __visit_invoke(std::forward<_Visitor>(__visitor), std::forward<_V0>(__v0)); } else __builtin_unreachable(); }
    case 6: { if constexpr (6 < __n) { return __gen_vtable_impl<_Ma, index_sequence<6>>:: __visit_invoke(std::forward<_Visitor>(__visitor), std::forward<_V0>(__v0)); } else __builtin_unreachable(); }
    case 7: { if constexpr (7 < __n) { return __gen_vtable_impl<_Ma, index_sequence<7>>:: __visit_invoke(std::forward<_Visitor>(__visitor), std::forward<_V0>(__v0)); } else __builtin_unreachable(); }
    case 8: { if constexpr (8 < __n) { return __gen_vtable_impl<_Ma, index_sequence<8>>:: __visit_invoke(std::forward<_Visitor>(__visitor), std::forward<_V0>(__v0)); } else __builtin_unreachable(); }
    case 9: { if constexpr (9 < __n) { return __gen_vtable_impl<_Ma, index_sequence<9>>:: __visit_invoke(std::forward<_Visitor>(__visitor), std::forward<_V0>(__v0)); } else __builtin_unreachable(); }
    case 10: { if constexpr (10 < __n) { return __gen_vtable_impl<_Ma, index_sequence<10>>:: __visit_invoke(std::forward<_Visitor>(__visitor), std::forward<_V0>(__v0)); } else __builtin_unreachable(); }
  case variant_npos:
    using __detail::__variant::__variant_idx_cookie;
    using __detail::__variant::__variant_cookie;
    if constexpr (is_same_v<_Result_type, __variant_idx_cookie>
    || is_same_v<_Result_type, __variant_cookie>)
      {
        using _Npos = index_sequence<variant_npos>;
        return __gen_vtable_impl<_Ma, _Npos>::
   __visit_invoke(std::forward<_Visitor>(__visitor),
           std::forward<_V0>(__v0));
      }
    else
      __builtin_unreachable();
  default:
    __builtin_unreachable();
  }


     }
 }
    }


  template<typename _Visitor, typename... _Variants>
    constexpr __detail::__variant::__visit_result_t<_Visitor, _Variants...>
    visit(_Visitor&& __visitor, _Variants&&... __variants)
    {
      namespace __variant = std::__detail::__variant;

      if ((__variant::__as(__variants).valueless_by_exception() || ...))
 __throw_bad_variant_access("std::visit: variant is valueless");

      using _Result_type
 = __detail::__variant::__visit_result_t<_Visitor, _Variants...>;

      using _Tag = __detail::__variant::__deduce_visit_result<_Result_type>;

      if constexpr (sizeof...(_Variants) == 1)
 {
   using _Vp = decltype(__variant::__as(std::declval<_Variants>()...));

   constexpr bool __visit_rettypes_match = __detail::__variant::
     __check_visitor_results<_Visitor, _Vp>(
       make_index_sequence<variant_size_v<remove_reference_t<_Vp>>>());
   if constexpr (!__visit_rettypes_match)
     {
       static_assert(__visit_rettypes_match,
     "std::visit requires the visitor to have the same "
     "return type for all alternatives of a variant");
       return;
     }
   else
     return std::__do_visit<_Tag>(
       std::forward<_Visitor>(__visitor),
       static_cast<_Vp>(__variants)...);
 }
      else
 return std::__do_visit<_Tag>(
   std::forward<_Visitor>(__visitor),
   __variant::__as(std::forward<_Variants>(__variants))...);
    }


  template<typename _Res, typename _Visitor, typename... _Variants>
    constexpr _Res
    visit(_Visitor&& __visitor, _Variants&&... __variants)
    {
      namespace __variant = std::__detail::__variant;

      if ((__variant::__as(__variants).valueless_by_exception() || ...))
 __throw_bad_variant_access("std::visit<R>: variant is valueless");

      return std::__do_visit<_Res>(std::forward<_Visitor>(__visitor),
   __variant::__as(std::forward<_Variants>(__variants))...);
    }



  template<bool, typename... _Types>
    struct __variant_hash_call_base_impl
    {
      size_t
      operator()(const variant<_Types...>& __t) const
      noexcept((is_nothrow_invocable_v<hash<decay_t<_Types>>, _Types> && ...))
      {
 size_t __ret;
 __detail::__variant::__raw_visit(
   [&__t, &__ret](auto&& __t_mem) mutable
   {
     using _Type = __remove_cvref_t<decltype(__t_mem)>;
     if constexpr (!is_same_v<_Type,
                __detail::__variant::__variant_cookie>)
       __ret = std::hash<size_t>{}(__t.index())
        + std::hash<_Type>{}(__t_mem);
     else
       __ret = std::hash<size_t>{}(__t.index());
   }, __t);
 return __ret;
      }
    };

  template<typename... _Types>
    struct __variant_hash_call_base_impl<false, _Types...> {};

  template<typename... _Types>
    using __variant_hash_call_base =
    __variant_hash_call_base_impl<(__poison_hash<remove_const_t<_Types>>::
       __enable_hash_call &&...), _Types...>;


  template<typename... _Types>
    struct hash<variant<_Types...>>
    : private __detail::__variant::_Variant_hash_base<
 variant<_Types...>, std::index_sequence_for<_Types...>>,
      public __variant_hash_call_base<_Types...>
    {
      using result_type [[__deprecated__]] = size_t;
      using argument_type [[__deprecated__]] = variant<_Types...>;
    };

  template<>
    struct hash<monostate>
    {
      using result_type [[__deprecated__]] = size_t;
      using argument_type [[__deprecated__]] = monostate;

      size_t
      operator()(const monostate&) const noexcept
      {
 constexpr size_t __magic_monostate_hash = -7777;
 return __magic_monostate_hash;
      }
    };

  template<typename... _Types>
    struct __is_fast_hash<hash<variant<_Types...>>>
    : bool_constant<(__is_fast_hash<_Types>::value && ...)>
    { };


}
# 28 "/home/avi/scylla-maint/seastar/include/seastar/rpc/rpc.hh" 2
# 1 "/usr/include/boost/intrusive/list.hpp" 1 3 4
# 17 "/usr/include/boost/intrusive/list.hpp" 3 4
# 1 "/usr/include/boost/intrusive/detail/config_begin.hpp" 1 3 4
# 14 "/usr/include/boost/intrusive/detail/config_begin.hpp" 3 4
# 1 "/usr/include/boost/config.hpp" 1 3 4
# 30 "/usr/include/boost/config.hpp" 3 4
# 1 "/usr/include/boost/config/user.hpp" 1 3 4
# 31 "/usr/include/boost/config.hpp" 2 3 4




# 1 "/usr/include/boost/config/detail/select_compiler_config.hpp" 1 3 4
# 36 "/usr/include/boost/config.hpp" 2 3 4



# 1 "/usr/include/boost/config/compiler/clang.hpp" 1 3 4
# 366 "/usr/include/boost/config/compiler/clang.hpp" 3 4
# 1 "/usr/include/boost/config/compiler/clang_version.hpp" 1 3 4
# 367 "/usr/include/boost/config/compiler/clang.hpp" 2 3 4
# 40 "/usr/include/boost/config.hpp" 2 3 4




# 1 "/usr/include/boost/config/detail/select_stdlib_config.hpp" 1 3 4
# 24 "/usr/include/boost/config/detail/select_stdlib_config.hpp" 3 4
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/version" 1 3 4
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/version" 3


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 37 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/version" 2 3
# 25 "/usr/include/boost/config/detail/select_stdlib_config.hpp" 2 3 4
# 45 "/usr/include/boost/config.hpp" 2 3 4



# 1 "/usr/include/boost/config/stdlib/libstdcpp3.hpp" 1 3 4
# 78 "/usr/include/boost/config/stdlib/libstdcpp3.hpp" 3 4
# 1 "/usr/include/unistd.h" 1 3 4
# 27 "/usr/include/unistd.h" 3 4
extern "C" {
# 202 "/usr/include/unistd.h" 3 4
# 1 "/usr/include/bits/posix_opt.h" 1 3 4
# 203 "/usr/include/unistd.h" 2 3 4



# 1 "/usr/include/bits/environments.h" 1 3 4
# 22 "/usr/include/bits/environments.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 23 "/usr/include/bits/environments.h" 2 3 4
# 207 "/usr/include/unistd.h" 2 3 4
# 217 "/usr/include/unistd.h" 3 4
# 1 "/usr/include/bits/types.h" 1 3 4
# 27 "/usr/include/bits/types.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 28 "/usr/include/bits/types.h" 2 3 4
# 1 "/usr/include/bits/timesize.h" 1 3 4
# 19 "/usr/include/bits/timesize.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 20 "/usr/include/bits/timesize.h" 2 3 4
# 29 "/usr/include/bits/types.h" 2 3 4


typedef unsigned char __u_char;
typedef unsigned short int __u_short;
typedef unsigned int __u_int;
typedef unsigned long int __u_long;


typedef signed char __int8_t;
typedef unsigned char __uint8_t;
typedef signed short int __int16_t;
typedef unsigned short int __uint16_t;
typedef signed int __int32_t;
typedef unsigned int __uint32_t;

typedef signed long int __int64_t;
typedef unsigned long int __uint64_t;






typedef __int8_t __int_least8_t;
typedef __uint8_t __uint_least8_t;
typedef __int16_t __int_least16_t;
typedef __uint16_t __uint_least16_t;
typedef __int32_t __int_least32_t;
typedef __uint32_t __uint_least32_t;
typedef __int64_t __int_least64_t;
typedef __uint64_t __uint_least64_t;



typedef long int __quad_t;
typedef unsigned long int __u_quad_t;







typedef long int __intmax_t;
typedef unsigned long int __uintmax_t;
# 141 "/usr/include/bits/types.h" 3 4
# 1 "/usr/include/bits/typesizes.h" 1 3 4
# 142 "/usr/include/bits/types.h" 2 3 4
# 1 "/usr/include/bits/time64.h" 1 3 4
# 143 "/usr/include/bits/types.h" 2 3 4


typedef unsigned long int __dev_t;
typedef unsigned int __uid_t;
typedef unsigned int __gid_t;
typedef unsigned long int __ino_t;
typedef unsigned long int __ino64_t;
typedef unsigned int __mode_t;
typedef unsigned long int __nlink_t;
typedef long int __off_t;
typedef long int __off64_t;
typedef int __pid_t;
typedef struct { int __val[2]; } __fsid_t;
typedef long int __clock_t;
typedef unsigned long int __rlim_t;
typedef unsigned long int __rlim64_t;
typedef unsigned int __id_t;
typedef long int __time_t;
typedef unsigned int __useconds_t;
typedef long int __suseconds_t;
typedef long int __suseconds64_t;

typedef int __daddr_t;
typedef int __key_t;


typedef int __clockid_t;


typedef void * __timer_t;


typedef long int __blksize_t;




typedef long int __blkcnt_t;
typedef long int __blkcnt64_t;


typedef unsigned long int __fsblkcnt_t;
typedef unsigned long int __fsblkcnt64_t;


typedef unsigned long int __fsfilcnt_t;
typedef unsigned long int __fsfilcnt64_t;


typedef long int __fsword_t;

typedef long int __ssize_t;


typedef long int __syscall_slong_t;

typedef unsigned long int __syscall_ulong_t;



typedef __off64_t __loff_t;
typedef char *__caddr_t;


typedef long int __intptr_t;


typedef unsigned int __socklen_t;




typedef int __sig_atomic_t;
# 218 "/usr/include/unistd.h" 2 3 4


typedef __ssize_t ssize_t;





# 1 "/usr/bin/../lib/clang/18/include/stddef.h" 1 3 4
# 77 "/usr/bin/../lib/clang/18/include/stddef.h" 3 4
# 1 "/usr/bin/../lib/clang/18/include/__stddef_size_t.h" 1 3 4
# 18 "/usr/bin/../lib/clang/18/include/__stddef_size_t.h" 3 4
typedef long unsigned int size_t;
# 78 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3 4
# 92 "/usr/bin/../lib/clang/18/include/stddef.h" 3 4
# 1 "/usr/bin/../lib/clang/18/include/__stddef_null.h" 1 3 4
# 93 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3 4
# 227 "/usr/include/unistd.h" 2 3 4





typedef __gid_t gid_t;




typedef __uid_t uid_t;





typedef __off_t off_t;






typedef __off64_t off64_t;




typedef __useconds_t useconds_t;




typedef __pid_t pid_t;






typedef __intptr_t intptr_t;






typedef __socklen_t socklen_t;
# 287 "/usr/include/unistd.h" 3 4
extern int access (const char *__name, int __type) noexcept (true) __attribute__ ((__nonnull__ (1)));




extern int euidaccess (const char *__name, int __type)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int eaccess (const char *__name, int __type)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int execveat (int __fd, const char *__path, char *const __argv[],
                     char *const __envp[], int __flags)
    noexcept (true) __attribute__ ((__nonnull__ (2, 3)));






extern int faccessat (int __fd, const char *__file, int __type, int __flag)
     noexcept (true) __attribute__ ((__nonnull__ (2))) ;
# 339 "/usr/include/unistd.h" 3 4
extern __off_t lseek (int __fd, __off_t __offset, int __whence) noexcept (true);
# 350 "/usr/include/unistd.h" 3 4
extern __off64_t lseek64 (int __fd, __off64_t __offset, int __whence)
     noexcept (true);






extern int close (int __fd);




extern void closefrom (int __lowfd) noexcept (true);







extern ssize_t read (int __fd, void *__buf, size_t __nbytes)
                                                  ;





extern ssize_t write (int __fd, const void *__buf, size_t __n)
                                         ;
# 389 "/usr/include/unistd.h" 3 4
extern ssize_t pread (int __fd, void *__buf, size_t __nbytes,
        __off_t __offset)
                                                  ;






extern ssize_t pwrite (int __fd, const void *__buf, size_t __n,
         __off_t __offset)
                                         ;
# 422 "/usr/include/unistd.h" 3 4
extern ssize_t pread64 (int __fd, void *__buf, size_t __nbytes,
   __off64_t __offset)
                                                  ;


extern ssize_t pwrite64 (int __fd, const void *__buf, size_t __n,
    __off64_t __offset)
                                         ;







extern int pipe (int __pipedes[2]) noexcept (true) ;




extern int pipe2 (int __pipedes[2], int __flags) noexcept (true) ;
# 452 "/usr/include/unistd.h" 3 4
extern unsigned int alarm (unsigned int __seconds) noexcept (true);
# 464 "/usr/include/unistd.h" 3 4
extern unsigned int sleep (unsigned int __seconds);







extern __useconds_t ualarm (__useconds_t __value, __useconds_t __interval)
     noexcept (true);






extern int usleep (__useconds_t __useconds);
# 489 "/usr/include/unistd.h" 3 4
extern int pause (void);



extern int chown (const char *__file, __uid_t __owner, __gid_t __group)
     noexcept (true) __attribute__ ((__nonnull__ (1))) ;



extern int fchown (int __fd, __uid_t __owner, __gid_t __group) noexcept (true) ;




extern int lchown (const char *__file, __uid_t __owner, __gid_t __group)
     noexcept (true) __attribute__ ((__nonnull__ (1))) ;






extern int fchownat (int __fd, const char *__file, __uid_t __owner,
       __gid_t __group, int __flag)
     noexcept (true) __attribute__ ((__nonnull__ (2))) ;



extern int chdir (const char *__path) noexcept (true) __attribute__ ((__nonnull__ (1))) ;



extern int fchdir (int __fd) noexcept (true) ;
# 531 "/usr/include/unistd.h" 3 4
extern char *getcwd (char *__buf, size_t __size) noexcept (true) ;





extern char *get_current_dir_name (void) noexcept (true);







extern char *getwd (char *__buf)
     noexcept (true) __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__))
                                       ;




extern int dup (int __fd) noexcept (true) ;


extern int dup2 (int __fd, int __fd2) noexcept (true);




extern int dup3 (int __fd, int __fd2, int __flags) noexcept (true);



extern char **__environ;

extern char **environ;





extern int execve (const char *__path, char *const __argv[],
     char *const __envp[]) noexcept (true) __attribute__ ((__nonnull__ (1, 2)));




extern int fexecve (int __fd, char *const __argv[], char *const __envp[])
     noexcept (true) __attribute__ ((__nonnull__ (2)));




extern int execv (const char *__path, char *const __argv[])
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));



extern int execle (const char *__path, const char *__arg, ...)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));



extern int execl (const char *__path, const char *__arg, ...)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));



extern int execvp (const char *__file, char *const __argv[])
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));




extern int execlp (const char *__file, const char *__arg, ...)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));




extern int execvpe (const char *__file, char *const __argv[],
      char *const __envp[])
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));





extern int nice (int __inc) noexcept (true) ;




extern void _exit (int __status) __attribute__ ((__noreturn__));





# 1 "/usr/include/bits/confname.h" 1 3 4
# 24 "/usr/include/bits/confname.h" 3 4
enum
  {
    _PC_LINK_MAX,

    _PC_MAX_CANON,

    _PC_MAX_INPUT,

    _PC_NAME_MAX,

    _PC_PATH_MAX,

    _PC_PIPE_BUF,

    _PC_CHOWN_RESTRICTED,

    _PC_NO_TRUNC,

    _PC_VDISABLE,

    _PC_SYNC_IO,

    _PC_ASYNC_IO,

    _PC_PRIO_IO,

    _PC_SOCK_MAXBUF,

    _PC_FILESIZEBITS,

    _PC_REC_INCR_XFER_SIZE,

    _PC_REC_MAX_XFER_SIZE,

    _PC_REC_MIN_XFER_SIZE,

    _PC_REC_XFER_ALIGN,

    _PC_ALLOC_SIZE_MIN,

    _PC_SYMLINK_MAX,

    _PC_2_SYMLINKS

  };


enum
  {
    _SC_ARG_MAX,

    _SC_CHILD_MAX,

    _SC_CLK_TCK,

    _SC_NGROUPS_MAX,

    _SC_OPEN_MAX,

    _SC_STREAM_MAX,

    _SC_TZNAME_MAX,

    _SC_JOB_CONTROL,

    _SC_SAVED_IDS,

    _SC_REALTIME_SIGNALS,

    _SC_PRIORITY_SCHEDULING,

    _SC_TIMERS,

    _SC_ASYNCHRONOUS_IO,

    _SC_PRIORITIZED_IO,

    _SC_SYNCHRONIZED_IO,

    _SC_FSYNC,

    _SC_MAPPED_FILES,

    _SC_MEMLOCK,

    _SC_MEMLOCK_RANGE,

    _SC_MEMORY_PROTECTION,

    _SC_MESSAGE_PASSING,

    _SC_SEMAPHORES,

    _SC_SHARED_MEMORY_OBJECTS,

    _SC_AIO_LISTIO_MAX,

    _SC_AIO_MAX,

    _SC_AIO_PRIO_DELTA_MAX,

    _SC_DELAYTIMER_MAX,

    _SC_MQ_OPEN_MAX,

    _SC_MQ_PRIO_MAX,

    _SC_VERSION,

    _SC_PAGESIZE,


    _SC_RTSIG_MAX,

    _SC_SEM_NSEMS_MAX,

    _SC_SEM_VALUE_MAX,

    _SC_SIGQUEUE_MAX,

    _SC_TIMER_MAX,




    _SC_BC_BASE_MAX,

    _SC_BC_DIM_MAX,

    _SC_BC_SCALE_MAX,

    _SC_BC_STRING_MAX,

    _SC_COLL_WEIGHTS_MAX,

    _SC_EQUIV_CLASS_MAX,

    _SC_EXPR_NEST_MAX,

    _SC_LINE_MAX,

    _SC_RE_DUP_MAX,

    _SC_CHARCLASS_NAME_MAX,


    _SC_2_VERSION,

    _SC_2_C_BIND,

    _SC_2_C_DEV,

    _SC_2_FORT_DEV,

    _SC_2_FORT_RUN,

    _SC_2_SW_DEV,

    _SC_2_LOCALEDEF,


    _SC_PII,

    _SC_PII_XTI,

    _SC_PII_SOCKET,

    _SC_PII_INTERNET,

    _SC_PII_OSI,

    _SC_POLL,

    _SC_SELECT,

    _SC_UIO_MAXIOV,

    _SC_IOV_MAX = _SC_UIO_MAXIOV,

    _SC_PII_INTERNET_STREAM,

    _SC_PII_INTERNET_DGRAM,

    _SC_PII_OSI_COTS,

    _SC_PII_OSI_CLTS,

    _SC_PII_OSI_M,

    _SC_T_IOV_MAX,



    _SC_THREADS,

    _SC_THREAD_SAFE_FUNCTIONS,

    _SC_GETGR_R_SIZE_MAX,

    _SC_GETPW_R_SIZE_MAX,

    _SC_LOGIN_NAME_MAX,

    _SC_TTY_NAME_MAX,

    _SC_THREAD_DESTRUCTOR_ITERATIONS,

    _SC_THREAD_KEYS_MAX,

    _SC_THREAD_STACK_MIN,

    _SC_THREAD_THREADS_MAX,

    _SC_THREAD_ATTR_STACKADDR,

    _SC_THREAD_ATTR_STACKSIZE,

    _SC_THREAD_PRIORITY_SCHEDULING,

    _SC_THREAD_PRIO_INHERIT,

    _SC_THREAD_PRIO_PROTECT,

    _SC_THREAD_PROCESS_SHARED,


    _SC_NPROCESSORS_CONF,

    _SC_NPROCESSORS_ONLN,

    _SC_PHYS_PAGES,

    _SC_AVPHYS_PAGES,

    _SC_ATEXIT_MAX,

    _SC_PASS_MAX,


    _SC_XOPEN_VERSION,

    _SC_XOPEN_XCU_VERSION,

    _SC_XOPEN_UNIX,

    _SC_XOPEN_CRYPT,

    _SC_XOPEN_ENH_I18N,

    _SC_XOPEN_SHM,


    _SC_2_CHAR_TERM,

    _SC_2_C_VERSION,

    _SC_2_UPE,


    _SC_XOPEN_XPG2,

    _SC_XOPEN_XPG3,

    _SC_XOPEN_XPG4,


    _SC_CHAR_BIT,

    _SC_CHAR_MAX,

    _SC_CHAR_MIN,

    _SC_INT_MAX,

    _SC_INT_MIN,

    _SC_LONG_BIT,

    _SC_WORD_BIT,

    _SC_MB_LEN_MAX,

    _SC_NZERO,

    _SC_SSIZE_MAX,

    _SC_SCHAR_MAX,

    _SC_SCHAR_MIN,

    _SC_SHRT_MAX,

    _SC_SHRT_MIN,

    _SC_UCHAR_MAX,

    _SC_UINT_MAX,

    _SC_ULONG_MAX,

    _SC_USHRT_MAX,


    _SC_NL_ARGMAX,

    _SC_NL_LANGMAX,

    _SC_NL_MSGMAX,

    _SC_NL_NMAX,

    _SC_NL_SETMAX,

    _SC_NL_TEXTMAX,


    _SC_XBS5_ILP32_OFF32,

    _SC_XBS5_ILP32_OFFBIG,

    _SC_XBS5_LP64_OFF64,

    _SC_XBS5_LPBIG_OFFBIG,


    _SC_XOPEN_LEGACY,

    _SC_XOPEN_REALTIME,

    _SC_XOPEN_REALTIME_THREADS,


    _SC_ADVISORY_INFO,

    _SC_BARRIERS,

    _SC_BASE,

    _SC_C_LANG_SUPPORT,

    _SC_C_LANG_SUPPORT_R,

    _SC_CLOCK_SELECTION,

    _SC_CPUTIME,

    _SC_THREAD_CPUTIME,

    _SC_DEVICE_IO,

    _SC_DEVICE_SPECIFIC,

    _SC_DEVICE_SPECIFIC_R,

    _SC_FD_MGMT,

    _SC_FIFO,

    _SC_PIPE,

    _SC_FILE_ATTRIBUTES,

    _SC_FILE_LOCKING,

    _SC_FILE_SYSTEM,

    _SC_MONOTONIC_CLOCK,

    _SC_MULTI_PROCESS,

    _SC_SINGLE_PROCESS,

    _SC_NETWORKING,

    _SC_READER_WRITER_LOCKS,

    _SC_SPIN_LOCKS,

    _SC_REGEXP,

    _SC_REGEX_VERSION,

    _SC_SHELL,

    _SC_SIGNALS,

    _SC_SPAWN,

    _SC_SPORADIC_SERVER,

    _SC_THREAD_SPORADIC_SERVER,

    _SC_SYSTEM_DATABASE,

    _SC_SYSTEM_DATABASE_R,

    _SC_TIMEOUTS,

    _SC_TYPED_MEMORY_OBJECTS,

    _SC_USER_GROUPS,

    _SC_USER_GROUPS_R,

    _SC_2_PBS,

    _SC_2_PBS_ACCOUNTING,

    _SC_2_PBS_LOCATE,

    _SC_2_PBS_MESSAGE,

    _SC_2_PBS_TRACK,

    _SC_SYMLOOP_MAX,

    _SC_STREAMS,

    _SC_2_PBS_CHECKPOINT,


    _SC_V6_ILP32_OFF32,

    _SC_V6_ILP32_OFFBIG,

    _SC_V6_LP64_OFF64,

    _SC_V6_LPBIG_OFFBIG,


    _SC_HOST_NAME_MAX,

    _SC_TRACE,

    _SC_TRACE_EVENT_FILTER,

    _SC_TRACE_INHERIT,

    _SC_TRACE_LOG,


    _SC_LEVEL1_ICACHE_SIZE,

    _SC_LEVEL1_ICACHE_ASSOC,

    _SC_LEVEL1_ICACHE_LINESIZE,

    _SC_LEVEL1_DCACHE_SIZE,

    _SC_LEVEL1_DCACHE_ASSOC,

    _SC_LEVEL1_DCACHE_LINESIZE,

    _SC_LEVEL2_CACHE_SIZE,

    _SC_LEVEL2_CACHE_ASSOC,

    _SC_LEVEL2_CACHE_LINESIZE,

    _SC_LEVEL3_CACHE_SIZE,

    _SC_LEVEL3_CACHE_ASSOC,

    _SC_LEVEL3_CACHE_LINESIZE,

    _SC_LEVEL4_CACHE_SIZE,

    _SC_LEVEL4_CACHE_ASSOC,

    _SC_LEVEL4_CACHE_LINESIZE,



    _SC_IPV6 = _SC_LEVEL1_ICACHE_SIZE + 50,

    _SC_RAW_SOCKETS,


    _SC_V7_ILP32_OFF32,

    _SC_V7_ILP32_OFFBIG,

    _SC_V7_LP64_OFF64,

    _SC_V7_LPBIG_OFFBIG,


    _SC_SS_REPL_MAX,


    _SC_TRACE_EVENT_NAME_MAX,

    _SC_TRACE_NAME_MAX,

    _SC_TRACE_SYS_MAX,

    _SC_TRACE_USER_EVENT_MAX,


    _SC_XOPEN_STREAMS,


    _SC_THREAD_ROBUST_PRIO_INHERIT,

    _SC_THREAD_ROBUST_PRIO_PROTECT,


    _SC_MINSIGSTKSZ,


    _SC_SIGSTKSZ

  };


enum
  {
    _CS_PATH,


    _CS_V6_WIDTH_RESTRICTED_ENVS,



    _CS_GNU_LIBC_VERSION,

    _CS_GNU_LIBPTHREAD_VERSION,


    _CS_V5_WIDTH_RESTRICTED_ENVS,



    _CS_V7_WIDTH_RESTRICTED_ENVS,



    _CS_LFS_CFLAGS = 1000,

    _CS_LFS_LDFLAGS,

    _CS_LFS_LIBS,

    _CS_LFS_LINTFLAGS,

    _CS_LFS64_CFLAGS,

    _CS_LFS64_LDFLAGS,

    _CS_LFS64_LIBS,

    _CS_LFS64_LINTFLAGS,


    _CS_XBS5_ILP32_OFF32_CFLAGS = 1100,

    _CS_XBS5_ILP32_OFF32_LDFLAGS,

    _CS_XBS5_ILP32_OFF32_LIBS,

    _CS_XBS5_ILP32_OFF32_LINTFLAGS,

    _CS_XBS5_ILP32_OFFBIG_CFLAGS,

    _CS_XBS5_ILP32_OFFBIG_LDFLAGS,

    _CS_XBS5_ILP32_OFFBIG_LIBS,

    _CS_XBS5_ILP32_OFFBIG_LINTFLAGS,

    _CS_XBS5_LP64_OFF64_CFLAGS,

    _CS_XBS5_LP64_OFF64_LDFLAGS,

    _CS_XBS5_LP64_OFF64_LIBS,

    _CS_XBS5_LP64_OFF64_LINTFLAGS,

    _CS_XBS5_LPBIG_OFFBIG_CFLAGS,

    _CS_XBS5_LPBIG_OFFBIG_LDFLAGS,

    _CS_XBS5_LPBIG_OFFBIG_LIBS,

    _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS,


    _CS_POSIX_V6_ILP32_OFF32_CFLAGS,

    _CS_POSIX_V6_ILP32_OFF32_LDFLAGS,

    _CS_POSIX_V6_ILP32_OFF32_LIBS,

    _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS,

    _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS,

    _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS,

    _CS_POSIX_V6_ILP32_OFFBIG_LIBS,

    _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS,

    _CS_POSIX_V6_LP64_OFF64_CFLAGS,

    _CS_POSIX_V6_LP64_OFF64_LDFLAGS,

    _CS_POSIX_V6_LP64_OFF64_LIBS,

    _CS_POSIX_V6_LP64_OFF64_LINTFLAGS,

    _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS,

    _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS,

    _CS_POSIX_V6_LPBIG_OFFBIG_LIBS,

    _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS,


    _CS_POSIX_V7_ILP32_OFF32_CFLAGS,

    _CS_POSIX_V7_ILP32_OFF32_LDFLAGS,

    _CS_POSIX_V7_ILP32_OFF32_LIBS,

    _CS_POSIX_V7_ILP32_OFF32_LINTFLAGS,

    _CS_POSIX_V7_ILP32_OFFBIG_CFLAGS,

    _CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS,

    _CS_POSIX_V7_ILP32_OFFBIG_LIBS,

    _CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS,

    _CS_POSIX_V7_LP64_OFF64_CFLAGS,

    _CS_POSIX_V7_LP64_OFF64_LDFLAGS,

    _CS_POSIX_V7_LP64_OFF64_LIBS,

    _CS_POSIX_V7_LP64_OFF64_LINTFLAGS,

    _CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS,

    _CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS,

    _CS_POSIX_V7_LPBIG_OFFBIG_LIBS,

    _CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS,


    _CS_V6_ENV,

    _CS_V7_ENV

  };
# 631 "/usr/include/unistd.h" 2 3 4


extern long int pathconf (const char *__path, int __name)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern long int fpathconf (int __fd, int __name) noexcept (true);


extern long int sysconf (int __name) noexcept (true);



extern size_t confstr (int __name, char *__buf, size_t __len) noexcept (true)
                                                  ;




extern __pid_t getpid (void) noexcept (true);


extern __pid_t getppid (void) noexcept (true);


extern __pid_t getpgrp (void) noexcept (true);


extern __pid_t __getpgid (__pid_t __pid) noexcept (true);

extern __pid_t getpgid (__pid_t __pid) noexcept (true);






extern int setpgid (__pid_t __pid, __pid_t __pgid) noexcept (true);
# 682 "/usr/include/unistd.h" 3 4
extern int setpgrp (void) noexcept (true);






extern __pid_t setsid (void) noexcept (true);



extern __pid_t getsid (__pid_t __pid) noexcept (true);



extern __uid_t getuid (void) noexcept (true);


extern __uid_t geteuid (void) noexcept (true);


extern __gid_t getgid (void) noexcept (true);


extern __gid_t getegid (void) noexcept (true);




extern int getgroups (int __size, __gid_t __list[]) noexcept (true)
                                                  ;


extern int group_member (__gid_t __gid) noexcept (true);






extern int setuid (__uid_t __uid) noexcept (true) ;




extern int setreuid (__uid_t __ruid, __uid_t __euid) noexcept (true) ;




extern int seteuid (__uid_t __uid) noexcept (true) ;






extern int setgid (__gid_t __gid) noexcept (true) ;




extern int setregid (__gid_t __rgid, __gid_t __egid) noexcept (true) ;




extern int setegid (__gid_t __gid) noexcept (true) ;





extern int getresuid (__uid_t *__ruid, __uid_t *__euid, __uid_t *__suid)
     noexcept (true);



extern int getresgid (__gid_t *__rgid, __gid_t *__egid, __gid_t *__sgid)
     noexcept (true);



extern int setresuid (__uid_t __ruid, __uid_t __euid, __uid_t __suid)
     noexcept (true) ;



extern int setresgid (__gid_t __rgid, __gid_t __egid, __gid_t __sgid)
     noexcept (true) ;






extern __pid_t fork (void) noexcept (true);







extern __pid_t vfork (void) noexcept (true);






extern __pid_t _Fork (void) noexcept (true);





extern char *ttyname (int __fd) noexcept (true);



extern int ttyname_r (int __fd, char *__buf, size_t __buflen)
     noexcept (true) __attribute__ ((__nonnull__ (2)))
                                                   ;



extern int isatty (int __fd) noexcept (true);




extern int ttyslot (void) noexcept (true);




extern int link (const char *__from, const char *__to)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2))) ;




extern int linkat (int __fromfd, const char *__from, int __tofd,
     const char *__to, int __flags)
     noexcept (true) __attribute__ ((__nonnull__ (2, 4))) ;




extern int symlink (const char *__from, const char *__to)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2))) ;




extern ssize_t readlink (const char *__restrict __path,
    char *__restrict __buf, size_t __len)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)))
                                                   ;





extern int symlinkat (const char *__from, int __tofd,
        const char *__to) noexcept (true) __attribute__ ((__nonnull__ (1, 3))) ;


extern ssize_t readlinkat (int __fd, const char *__restrict __path,
      char *__restrict __buf, size_t __len)
     noexcept (true) __attribute__ ((__nonnull__ (2, 3)))
                                                   ;



extern int unlink (const char *__name) noexcept (true) __attribute__ ((__nonnull__ (1)));



extern int unlinkat (int __fd, const char *__name, int __flag)
     noexcept (true) __attribute__ ((__nonnull__ (2)));



extern int rmdir (const char *__path) noexcept (true) __attribute__ ((__nonnull__ (1)));



extern __pid_t tcgetpgrp (int __fd) noexcept (true);


extern int tcsetpgrp (int __fd, __pid_t __pgrp_id) noexcept (true);






extern char *getlogin (void);







extern int getlogin_r (char *__name, size_t __name_len) __attribute__ ((__nonnull__ (1)))
                                                  ;




extern int setlogin (const char *__name) noexcept (true) __attribute__ ((__nonnull__ (1)));







# 1 "/usr/include/bits/getopt_posix.h" 1 3 4
# 27 "/usr/include/bits/getopt_posix.h" 3 4
# 1 "/usr/include/bits/getopt_core.h" 1 3 4
# 28 "/usr/include/bits/getopt_core.h" 3 4
extern "C" {







extern char *optarg;
# 50 "/usr/include/bits/getopt_core.h" 3 4
extern int optind;




extern int opterr;



extern int optopt;
# 91 "/usr/include/bits/getopt_core.h" 3 4
extern int getopt (int ___argc, char *const *___argv, const char *__shortopts)
       noexcept (true) __attribute__ ((__nonnull__ (2, 3)));

}
# 28 "/usr/include/bits/getopt_posix.h" 2 3 4

extern "C" {
# 49 "/usr/include/bits/getopt_posix.h" 3 4
}
# 904 "/usr/include/unistd.h" 2 3 4







extern int gethostname (char *__name, size_t __len) noexcept (true) __attribute__ ((__nonnull__ (1)))
                                                  ;






extern int sethostname (const char *__name, size_t __len)
     noexcept (true) __attribute__ ((__nonnull__ (1))) ;



extern int sethostid (long int __id) noexcept (true) ;





extern int getdomainname (char *__name, size_t __len)
     noexcept (true) __attribute__ ((__nonnull__ (1)))
                                                   ;
extern int setdomainname (const char *__name, size_t __len)
     noexcept (true) __attribute__ ((__nonnull__ (1))) ;




extern int vhangup (void) noexcept (true);


extern int revoke (const char *__file) noexcept (true) __attribute__ ((__nonnull__ (1))) ;







extern int profil (unsigned short int *__sample_buffer, size_t __size,
     size_t __offset, unsigned int __scale)
     noexcept (true) __attribute__ ((__nonnull__ (1)));





extern int acct (const char *__name) noexcept (true);



extern char *getusershell (void) noexcept (true);
extern void endusershell (void) noexcept (true);
extern void setusershell (void) noexcept (true);





extern int daemon (int __nochdir, int __noclose) noexcept (true) ;






extern int chroot (const char *__path) noexcept (true) __attribute__ ((__nonnull__ (1))) ;



extern char *getpass (const char *__prompt) __attribute__ ((__nonnull__ (1)));







extern int fsync (int __fd);





extern int syncfs (int __fd) noexcept (true);






extern long int gethostid (void);


extern void sync (void) noexcept (true);





extern int getpagesize (void) noexcept (true) __attribute__ ((__const__));




extern int getdtablesize (void) noexcept (true);
# 1026 "/usr/include/unistd.h" 3 4
extern int truncate (const char *__file, __off_t __length)
     noexcept (true) __attribute__ ((__nonnull__ (1))) ;
# 1038 "/usr/include/unistd.h" 3 4
extern int truncate64 (const char *__file, __off64_t __length)
     noexcept (true) __attribute__ ((__nonnull__ (1))) ;
# 1049 "/usr/include/unistd.h" 3 4
extern int ftruncate (int __fd, __off_t __length) noexcept (true) ;
# 1059 "/usr/include/unistd.h" 3 4
extern int ftruncate64 (int __fd, __off64_t __length) noexcept (true) ;
# 1070 "/usr/include/unistd.h" 3 4
extern int brk (void *__addr) noexcept (true) ;





extern void *sbrk (intptr_t __delta) noexcept (true);
# 1091 "/usr/include/unistd.h" 3 4
extern long int syscall (long int __sysno, ...) noexcept (true);
# 1114 "/usr/include/unistd.h" 3 4
extern int lockf (int __fd, int __cmd, __off_t __len) ;
# 1124 "/usr/include/unistd.h" 3 4
extern int lockf64 (int __fd, int __cmd, __off64_t __len) ;
# 1142 "/usr/include/unistd.h" 3 4
ssize_t copy_file_range (int __infd, __off64_t *__pinoff,
    int __outfd, __off64_t *__poutoff,
    size_t __length, unsigned int __flags);





extern int fdatasync (int __fildes);
# 1162 "/usr/include/unistd.h" 3 4
extern char *crypt (const char *__key, const char *__salt)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));







extern void swab (const void *__restrict __from, void *__restrict __to,
    ssize_t __n) noexcept (true) __attribute__ ((__nonnull__ (1, 2)))

                                          ;
# 1201 "/usr/include/unistd.h" 3 4
int getentropy (void *__buffer, size_t __length)
                                          ;
# 1211 "/usr/include/unistd.h" 3 4
extern int close_range (unsigned int __fd, unsigned int __max_fd,
   int __flags) noexcept (true);
# 1221 "/usr/include/unistd.h" 3 4
# 1 "/usr/include/bits/unistd_ext.h" 1 3 4
# 34 "/usr/include/bits/unistd_ext.h" 3 4
extern __pid_t gettid (void) noexcept (true);



# 1 "/usr/include/linux/close_range.h" 1 3 4
# 39 "/usr/include/bits/unistd_ext.h" 2 3 4
# 1222 "/usr/include/unistd.h" 2 3 4

}
# 79 "/usr/include/boost/config/stdlib/libstdcpp3.hpp" 2 3 4
# 49 "/usr/include/boost/config.hpp" 2 3 4




# 1 "/usr/include/boost/config/detail/select_platform_config.hpp" 1 3 4
# 54 "/usr/include/boost/config.hpp" 2 3 4



# 1 "/usr/include/boost/config/platform/linux.hpp" 1 3 4
# 15 "/usr/include/boost/config/platform/linux.hpp" 3 4
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdlib" 1 3 4
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdlib" 3
# 79 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdlib" 3
# 1 "/usr/include/stdlib.h" 1 3 4
# 26 "/usr/include/stdlib.h" 3 4
# 1 "/usr/include/bits/libc-header-start.h" 1 3 4
# 27 "/usr/include/stdlib.h" 2 3 4





# 1 "/usr/bin/../lib/clang/18/include/stddef.h" 1 3 4
# 77 "/usr/bin/../lib/clang/18/include/stddef.h" 3 4
# 1 "/usr/bin/../lib/clang/18/include/__stddef_size_t.h" 1 3 4
# 18 "/usr/bin/../lib/clang/18/include/__stddef_size_t.h" 3 4
typedef long unsigned int size_t;
# 78 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3 4
# 87 "/usr/bin/../lib/clang/18/include/stddef.h" 3 4
# 1 "/usr/bin/../lib/clang/18/include/__stddef_wchar_t.h" 1 3 4
# 88 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3 4




# 1 "/usr/bin/../lib/clang/18/include/__stddef_null.h" 1 3 4
# 93 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3 4
# 33 "/usr/include/stdlib.h" 2 3 4

extern "C" {





# 1 "/usr/include/bits/waitflags.h" 1 3 4
# 41 "/usr/include/stdlib.h" 2 3 4
# 1 "/usr/include/bits/waitstatus.h" 1 3 4
# 42 "/usr/include/stdlib.h" 2 3 4
# 56 "/usr/include/stdlib.h" 3 4
# 1 "/usr/include/bits/floatn.h" 1 3 4
# 119 "/usr/include/bits/floatn.h" 3 4
# 1 "/usr/include/bits/floatn-common.h" 1 3 4
# 24 "/usr/include/bits/floatn-common.h" 3 4
# 1 "/usr/include/bits/long-double.h" 1 3 4
# 25 "/usr/include/bits/floatn-common.h" 2 3 4
# 214 "/usr/include/bits/floatn-common.h" 3 4
typedef float _Float32;
# 251 "/usr/include/bits/floatn-common.h" 3 4
typedef double _Float64;
# 268 "/usr/include/bits/floatn-common.h" 3 4
typedef double _Float32x;
# 285 "/usr/include/bits/floatn-common.h" 3 4
typedef long double _Float64x;
# 120 "/usr/include/bits/floatn.h" 2 3 4
# 57 "/usr/include/stdlib.h" 2 3 4


typedef struct
  {
    int quot;
    int rem;
  } div_t;



typedef struct
  {
    long int quot;
    long int rem;
  } ldiv_t;





__extension__ typedef struct
  {
    long long int quot;
    long long int rem;
  } lldiv_t;
# 98 "/usr/include/stdlib.h" 3 4
extern size_t __ctype_get_mb_cur_max (void) noexcept (true) ;



extern double atof (const char *__nptr)
     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;

extern int atoi (const char *__nptr)
     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;

extern long int atol (const char *__nptr)
     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;



__extension__ extern long long int atoll (const char *__nptr)
     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;



extern double strtod (const char *__restrict __nptr,
        char **__restrict __endptr)
     noexcept (true) __attribute__ ((__nonnull__ (1)));



extern float strtof (const char *__restrict __nptr,
       char **__restrict __endptr) noexcept (true) __attribute__ ((__nonnull__ (1)));

extern long double strtold (const char *__restrict __nptr,
       char **__restrict __endptr)
     noexcept (true) __attribute__ ((__nonnull__ (1)));
# 141 "/usr/include/stdlib.h" 3 4
extern _Float32 strtof32 (const char *__restrict __nptr,
     char **__restrict __endptr)
     noexcept (true) __attribute__ ((__nonnull__ (1)));



extern _Float64 strtof64 (const char *__restrict __nptr,
     char **__restrict __endptr)
     noexcept (true) __attribute__ ((__nonnull__ (1)));
# 159 "/usr/include/stdlib.h" 3 4
extern _Float32x strtof32x (const char *__restrict __nptr,
       char **__restrict __endptr)
     noexcept (true) __attribute__ ((__nonnull__ (1)));



extern _Float64x strtof64x (const char *__restrict __nptr,
       char **__restrict __endptr)
     noexcept (true) __attribute__ ((__nonnull__ (1)));
# 177 "/usr/include/stdlib.h" 3 4
extern long int strtol (const char *__restrict __nptr,
   char **__restrict __endptr, int __base)
     noexcept (true) __attribute__ ((__nonnull__ (1)));

extern unsigned long int strtoul (const char *__restrict __nptr,
      char **__restrict __endptr, int __base)
     noexcept (true) __attribute__ ((__nonnull__ (1)));



__extension__
extern long long int strtoq (const char *__restrict __nptr,
        char **__restrict __endptr, int __base)
     noexcept (true) __attribute__ ((__nonnull__ (1)));

__extension__
extern unsigned long long int strtouq (const char *__restrict __nptr,
           char **__restrict __endptr, int __base)
     noexcept (true) __attribute__ ((__nonnull__ (1)));




__extension__
extern long long int strtoll (const char *__restrict __nptr,
         char **__restrict __endptr, int __base)
     noexcept (true) __attribute__ ((__nonnull__ (1)));

__extension__
extern unsigned long long int strtoull (const char *__restrict __nptr,
     char **__restrict __endptr, int __base)
     noexcept (true) __attribute__ ((__nonnull__ (1)));






extern long int strtol (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtol")


     __attribute__ ((__nonnull__ (1)));
extern unsigned long int strtoul (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoul")



     __attribute__ ((__nonnull__ (1)));

__extension__
extern long long int strtoq (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoll")


     __attribute__ ((__nonnull__ (1)));
__extension__
extern unsigned long long int strtouq (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoull")



     __attribute__ ((__nonnull__ (1)));

__extension__
extern long long int strtoll (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoll")


     __attribute__ ((__nonnull__ (1)));
__extension__
extern unsigned long long int strtoull (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoull")



     __attribute__ ((__nonnull__ (1)));
# 278 "/usr/include/stdlib.h" 3 4
extern int strfromd (char *__dest, size_t __size, const char *__format,
       double __f)
     noexcept (true) __attribute__ ((__nonnull__ (3)));

extern int strfromf (char *__dest, size_t __size, const char *__format,
       float __f)
     noexcept (true) __attribute__ ((__nonnull__ (3)));

extern int strfroml (char *__dest, size_t __size, const char *__format,
       long double __f)
     noexcept (true) __attribute__ ((__nonnull__ (3)));
# 298 "/usr/include/stdlib.h" 3 4
extern int strfromf32 (char *__dest, size_t __size, const char * __format,
         _Float32 __f)
     noexcept (true) __attribute__ ((__nonnull__ (3)));



extern int strfromf64 (char *__dest, size_t __size, const char * __format,
         _Float64 __f)
     noexcept (true) __attribute__ ((__nonnull__ (3)));
# 316 "/usr/include/stdlib.h" 3 4
extern int strfromf32x (char *__dest, size_t __size, const char * __format,
   _Float32x __f)
     noexcept (true) __attribute__ ((__nonnull__ (3)));



extern int strfromf64x (char *__dest, size_t __size, const char * __format,
   _Float64x __f)
     noexcept (true) __attribute__ ((__nonnull__ (3)));
# 338 "/usr/include/stdlib.h" 3 4
# 1 "/usr/include/bits/types/locale_t.h" 1 3 4
# 22 "/usr/include/bits/types/locale_t.h" 3 4
# 1 "/usr/include/bits/types/__locale_t.h" 1 3 4
# 27 "/usr/include/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/bits/types/locale_t.h" 2 3 4

typedef __locale_t locale_t;
# 339 "/usr/include/stdlib.h" 2 3 4

extern long int strtol_l (const char *__restrict __nptr,
     char **__restrict __endptr, int __base,
     locale_t __loc) noexcept (true) __attribute__ ((__nonnull__ (1, 4)));

extern unsigned long int strtoul_l (const char *__restrict __nptr,
        char **__restrict __endptr,
        int __base, locale_t __loc)
     noexcept (true) __attribute__ ((__nonnull__ (1, 4)));

__extension__
extern long long int strtoll_l (const char *__restrict __nptr,
    char **__restrict __endptr, int __base,
    locale_t __loc)
     noexcept (true) __attribute__ ((__nonnull__ (1, 4)));

__extension__
extern unsigned long long int strtoull_l (const char *__restrict __nptr,
       char **__restrict __endptr,
       int __base, locale_t __loc)
     noexcept (true) __attribute__ ((__nonnull__ (1, 4)));





extern long int strtol_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtol_l")



     __attribute__ ((__nonnull__ (1, 4)));
extern unsigned long int strtoul_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtoul_l")




     __attribute__ ((__nonnull__ (1, 4)));
__extension__
extern long long int strtoll_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtoll_l")




     __attribute__ ((__nonnull__ (1, 4)));
__extension__
extern unsigned long long int strtoull_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtoull_l")




     __attribute__ ((__nonnull__ (1, 4)));
# 415 "/usr/include/stdlib.h" 3 4
extern double strtod_l (const char *__restrict __nptr,
   char **__restrict __endptr, locale_t __loc)
     noexcept (true) __attribute__ ((__nonnull__ (1, 3)));

extern float strtof_l (const char *__restrict __nptr,
         char **__restrict __endptr, locale_t __loc)
     noexcept (true) __attribute__ ((__nonnull__ (1, 3)));

extern long double strtold_l (const char *__restrict __nptr,
         char **__restrict __endptr,
         locale_t __loc)
     noexcept (true) __attribute__ ((__nonnull__ (1, 3)));
# 436 "/usr/include/stdlib.h" 3 4
extern _Float32 strtof32_l (const char *__restrict __nptr,
       char **__restrict __endptr,
       locale_t __loc)
     noexcept (true) __attribute__ ((__nonnull__ (1, 3)));



extern _Float64 strtof64_l (const char *__restrict __nptr,
       char **__restrict __endptr,
       locale_t __loc)
     noexcept (true) __attribute__ ((__nonnull__ (1, 3)));
# 457 "/usr/include/stdlib.h" 3 4
extern _Float32x strtof32x_l (const char *__restrict __nptr,
         char **__restrict __endptr,
         locale_t __loc)
     noexcept (true) __attribute__ ((__nonnull__ (1, 3)));



extern _Float64x strtof64x_l (const char *__restrict __nptr,
         char **__restrict __endptr,
         locale_t __loc)
     noexcept (true) __attribute__ ((__nonnull__ (1, 3)));
# 480 "/usr/include/stdlib.h" 3 4
extern __inline __attribute__ ((__gnu_inline__)) int
 atoi (const char *__nptr) noexcept (true)
{
  return (int) strtol (__nptr, (char **) __null, 10);
}
extern __inline __attribute__ ((__gnu_inline__)) long int
 atol (const char *__nptr) noexcept (true)
{
  return strtol (__nptr, (char **) __null, 10);
}


__extension__ extern __inline __attribute__ ((__gnu_inline__)) long long int
 atoll (const char *__nptr) noexcept (true)
{
  return strtoll (__nptr, (char **) __null, 10);
}
# 505 "/usr/include/stdlib.h" 3 4
extern char *l64a (long int __n) noexcept (true) ;


extern long int a64l (const char *__s)
     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;




# 1 "/usr/include/sys/types.h" 1 3 4
# 27 "/usr/include/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;
# 69 "/usr/include/sys/types.h" 3 4
typedef __mode_t mode_t;




typedef __nlink_t nlink_t;
# 103 "/usr/include/sys/types.h" 3 4
typedef __id_t id_t;
# 114 "/usr/include/sys/types.h" 3 4
typedef __daddr_t daddr_t;
typedef __caddr_t caddr_t;





typedef __key_t key_t;




# 1 "/usr/include/bits/types/clock_t.h" 1 3 4






typedef __clock_t clock_t;
# 127 "/usr/include/sys/types.h" 2 3 4

# 1 "/usr/include/bits/types/clockid_t.h" 1 3 4






typedef __clockid_t clockid_t;
# 129 "/usr/include/sys/types.h" 2 3 4
# 1 "/usr/include/bits/types/time_t.h" 1 3 4
# 10 "/usr/include/bits/types/time_t.h" 3 4
typedef __time_t time_t;
# 130 "/usr/include/sys/types.h" 2 3 4
# 1 "/usr/include/bits/types/timer_t.h" 1 3 4






typedef __timer_t timer_t;
# 131 "/usr/include/sys/types.h" 2 3 4







typedef __suseconds_t suseconds_t;





# 1 "/usr/bin/../lib/clang/18/include/stddef.h" 1 3 4
# 77 "/usr/bin/../lib/clang/18/include/stddef.h" 3 4
# 1 "/usr/bin/../lib/clang/18/include/__stddef_size_t.h" 1 3 4
# 18 "/usr/bin/../lib/clang/18/include/__stddef_size_t.h" 3 4
typedef long unsigned int size_t;
# 78 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3 4
# 145 "/usr/include/sys/types.h" 2 3 4



typedef unsigned long int ulong;
typedef unsigned short int ushort;
typedef unsigned int uint;




# 1 "/usr/include/bits/stdint-intn.h" 1 3 4
# 24 "/usr/include/bits/stdint-intn.h" 3 4
typedef __int8_t int8_t;
typedef __int16_t int16_t;
typedef __int32_t int32_t;
typedef __int64_t int64_t;
# 156 "/usr/include/sys/types.h" 2 3 4


typedef __uint8_t u_int8_t;
typedef __uint16_t u_int16_t;
typedef __uint32_t u_int32_t;
typedef __uint64_t u_int64_t;


typedef int register_t __attribute__ ((__mode__ (__word__)));
# 176 "/usr/include/sys/types.h" 3 4
# 1 "/usr/include/endian.h" 1 3 4
# 24 "/usr/include/endian.h" 3 4
# 1 "/usr/include/bits/endian.h" 1 3 4
# 35 "/usr/include/bits/endian.h" 3 4
# 1 "/usr/include/bits/endianness.h" 1 3 4
# 36 "/usr/include/bits/endian.h" 2 3 4
# 25 "/usr/include/endian.h" 2 3 4
# 35 "/usr/include/endian.h" 3 4
# 1 "/usr/include/bits/byteswap.h" 1 3 4
# 33 "/usr/include/bits/byteswap.h" 3 4
static __inline __uint16_t
__bswap_16 (__uint16_t __bsx)
{



  return ((__uint16_t) ((((__bsx) >> 8) & 0xff) | (((__bsx) & 0xff) << 8)));

}






static __inline __uint32_t
__bswap_32 (__uint32_t __bsx)
{



  return ((((__bsx) & 0xff000000u) >> 24) | (((__bsx) & 0x00ff0000u) >> 8) | (((__bsx) & 0x0000ff00u) << 8) | (((__bsx) & 0x000000ffu) << 24));

}
# 69 "/usr/include/bits/byteswap.h" 3 4
__extension__ static __inline __uint64_t
__bswap_64 (__uint64_t __bsx)
{



  return ((((__bsx) & 0xff00000000000000ull) >> 56) | (((__bsx) & 0x00ff000000000000ull) >> 40) | (((__bsx) & 0x0000ff0000000000ull) >> 24) | (((__bsx) & 0x000000ff00000000ull) >> 8) | (((__bsx) & 0x00000000ff000000ull) << 8) | (((__bsx) & 0x0000000000ff0000ull) << 24) | (((__bsx) & 0x000000000000ff00ull) << 40) | (((__bsx) & 0x00000000000000ffull) << 56));

}
# 36 "/usr/include/endian.h" 2 3 4
# 1 "/usr/include/bits/uintn-identity.h" 1 3 4
# 32 "/usr/include/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/sys/types.h" 2 3 4


# 1 "/usr/include/sys/select.h" 1 3 4
# 30 "/usr/include/sys/select.h" 3 4
# 1 "/usr/include/bits/select.h" 1 3 4
# 31 "/usr/include/sys/select.h" 2 3 4


# 1 "/usr/include/bits/types/sigset_t.h" 1 3 4



# 1 "/usr/include/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/bits/types/sigset_t.h" 2 3 4


typedef __sigset_t sigset_t;
# 34 "/usr/include/sys/select.h" 2 3 4



# 1 "/usr/include/bits/types/struct_timeval.h" 1 3 4







struct timeval
{




  __time_t tv_sec;
  __suseconds_t tv_usec;

};
# 38 "/usr/include/sys/select.h" 2 3 4

# 1 "/usr/include/bits/types/struct_timespec.h" 1 3 4
# 11 "/usr/include/bits/types/struct_timespec.h" 3 4
struct timespec
{



  __time_t tv_sec;




  __syscall_slong_t tv_nsec;
# 31 "/usr/include/bits/types/struct_timespec.h" 3 4
};
# 40 "/usr/include/sys/select.h" 2 3 4
# 49 "/usr/include/sys/select.h" 3 4
typedef long int __fd_mask;
# 59 "/usr/include/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/sys/select.h" 3 4
extern "C" {
# 102 "/usr/include/sys/select.h" 3 4
extern int select (int __nfds, fd_set *__restrict __readfds,
     fd_set *__restrict __writefds,
     fd_set *__restrict __exceptfds,
     struct timeval *__restrict __timeout);
# 127 "/usr/include/sys/select.h" 3 4
extern int pselect (int __nfds, fd_set *__restrict __readfds,
      fd_set *__restrict __writefds,
      fd_set *__restrict __exceptfds,
      const struct timespec *__restrict __timeout,
      const __sigset_t *__restrict __sigmask);
# 153 "/usr/include/sys/select.h" 3 4
}
# 180 "/usr/include/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/sys/types.h" 3 4
typedef __blkcnt64_t blkcnt64_t;
typedef __fsblkcnt64_t fsblkcnt64_t;
typedef __fsfilcnt64_t fsfilcnt64_t;





# 1 "/usr/include/bits/pthreadtypes.h" 1 3 4
# 23 "/usr/include/bits/pthreadtypes.h" 3 4
# 1 "/usr/include/bits/thread-shared-types.h" 1 3 4
# 44 "/usr/include/bits/thread-shared-types.h" 3 4
# 1 "/usr/include/bits/pthreadtypes-arch.h" 1 3 4
# 21 "/usr/include/bits/pthreadtypes-arch.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 22 "/usr/include/bits/pthreadtypes-arch.h" 2 3 4
# 45 "/usr/include/bits/thread-shared-types.h" 2 3 4

# 1 "/usr/include/bits/atomic_wide_counter.h" 1 3 4
# 25 "/usr/include/bits/atomic_wide_counter.h" 3 4
typedef union
{
  __extension__ unsigned long long int __value64;
  struct
  {
    unsigned int __low;
    unsigned int __high;
  } __value32;
} __atomic_wide_counter;
# 47 "/usr/include/bits/thread-shared-types.h" 2 3 4




typedef struct __pthread_internal_list
{
  struct __pthread_internal_list *__prev;
  struct __pthread_internal_list *__next;
} __pthread_list_t;

typedef struct __pthread_internal_slist
{
  struct __pthread_internal_slist *__next;
} __pthread_slist_t;
# 76 "/usr/include/bits/thread-shared-types.h" 3 4
# 1 "/usr/include/bits/struct_mutex.h" 1 3 4
# 22 "/usr/include/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/bits/struct_mutex.h" 3 4
};
# 77 "/usr/include/bits/thread-shared-types.h" 2 3 4
# 89 "/usr/include/bits/thread-shared-types.h" 3 4
# 1 "/usr/include/bits/struct_rwlock.h" 1 3 4
# 23 "/usr/include/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/bits/struct_rwlock.h" 3 4
};
# 90 "/usr/include/bits/thread-shared-types.h" 2 3 4




struct __pthread_cond_s
{
  __atomic_wide_counter __wseq;
  __atomic_wide_counter __g1_start;
  unsigned int __g_refs[2] ;
  unsigned int __g_size[2];
  unsigned int __g1_orig_size;
  unsigned int __wrefs;
  unsigned int __g_signals[2];
};

typedef unsigned int __tss_t;
typedef unsigned long int __thrd_t;

typedef struct
{
  int __data ;
} __once_flag;
# 24 "/usr/include/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/sys/types.h" 2 3 4


}
# 515 "/usr/include/stdlib.h" 2 3 4






extern long int random (void) noexcept (true);


extern void srandom (unsigned int __seed) noexcept (true);





extern char *initstate (unsigned int __seed, char *__statebuf,
   size_t __statelen) noexcept (true) __attribute__ ((__nonnull__ (2)));



extern char *setstate (char *__statebuf) noexcept (true) __attribute__ ((__nonnull__ (1)));







struct random_data
  {
    int32_t *fptr;
    int32_t *rptr;
    int32_t *state;
    int rand_type;
    int rand_deg;
    int rand_sep;
    int32_t *end_ptr;
  };

extern int random_r (struct random_data *__restrict __buf,
       int32_t *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2)));

extern int srandom_r (unsigned int __seed, struct random_data *__buf)
     noexcept (true) __attribute__ ((__nonnull__ (2)));

extern int initstate_r (unsigned int __seed, char *__restrict __statebuf,
   size_t __statelen,
   struct random_data *__restrict __buf)
     noexcept (true) __attribute__ ((__nonnull__ (2, 4)));

extern int setstate_r (char *__restrict __statebuf,
         struct random_data *__restrict __buf)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));





extern int rand (void) noexcept (true);

extern void srand (unsigned int __seed) noexcept (true);



extern int rand_r (unsigned int *__seed) noexcept (true);







extern double drand48 (void) noexcept (true);
extern double erand48 (unsigned short int __xsubi[3]) noexcept (true) __attribute__ ((__nonnull__ (1)));


extern long int lrand48 (void) noexcept (true);
extern long int nrand48 (unsigned short int __xsubi[3])
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern long int mrand48 (void) noexcept (true);
extern long int jrand48 (unsigned short int __xsubi[3])
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern void srand48 (long int __seedval) noexcept (true);
extern unsigned short int *seed48 (unsigned short int __seed16v[3])
     noexcept (true) __attribute__ ((__nonnull__ (1)));
extern void lcong48 (unsigned short int __param[7]) noexcept (true) __attribute__ ((__nonnull__ (1)));





struct drand48_data
  {
    unsigned short int __x[3];
    unsigned short int __old_x[3];
    unsigned short int __c;
    unsigned short int __init;
    __extension__ unsigned long long int __a;

  };


extern int drand48_r (struct drand48_data *__restrict __buffer,
        double *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
extern int erand48_r (unsigned short int __xsubi[3],
        struct drand48_data *__restrict __buffer,
        double *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern int lrand48_r (struct drand48_data *__restrict __buffer,
        long int *__restrict __result)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
extern int nrand48_r (unsigned short int __xsubi[3],
        struct drand48_data *__restrict __buffer,
        long int *__restrict __result)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern int mrand48_r (struct drand48_data *__restrict __buffer,
        long int *__restrict __result)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
extern int jrand48_r (unsigned short int __xsubi[3],
        struct drand48_data *__restrict __buffer,
        long int *__restrict __result)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern int srand48_r (long int __seedval, struct drand48_data *__buffer)
     noexcept (true) __attribute__ ((__nonnull__ (2)));

extern int seed48_r (unsigned short int __seed16v[3],
       struct drand48_data *__buffer) noexcept (true) __attribute__ ((__nonnull__ (1, 2)));

extern int lcong48_r (unsigned short int __param[7],
        struct drand48_data *__buffer)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern __uint32_t arc4random (void)
     noexcept (true) ;


extern void arc4random_buf (void *__buf, size_t __size)
     noexcept (true) __attribute__ ((__nonnull__ (1)));



extern __uint32_t arc4random_uniform (__uint32_t __upper_bound)
     noexcept (true) ;




extern void *malloc (size_t __size) noexcept (true) __attribute__ ((__malloc__))
                                         ;

extern void *calloc (size_t __nmemb, size_t __size)
     noexcept (true) __attribute__ ((__malloc__)) ;






extern void *realloc (void *__ptr, size_t __size)
     noexcept (true) __attribute__ ((__warn_unused_result__)) ;


extern void free (void *__ptr) noexcept (true);







extern void *reallocarray (void *__ptr, size_t __nmemb, size_t __size)
     noexcept (true) __attribute__ ((__warn_unused_result__))

                       ;


extern void *reallocarray (void *__ptr, size_t __nmemb, size_t __size)
     noexcept (true) ;



# 1 "/usr/include/alloca.h" 1 3 4
# 24 "/usr/include/alloca.h" 3 4
# 1 "/usr/bin/../lib/clang/18/include/stddef.h" 1 3 4
# 77 "/usr/bin/../lib/clang/18/include/stddef.h" 3 4
# 1 "/usr/bin/../lib/clang/18/include/__stddef_size_t.h" 1 3 4
# 18 "/usr/bin/../lib/clang/18/include/__stddef_size_t.h" 3 4
typedef long unsigned int size_t;
# 78 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3 4
# 25 "/usr/include/alloca.h" 2 3 4

extern "C" {





extern void *alloca (size_t __size) noexcept (true);





}
# 707 "/usr/include/stdlib.h" 2 3 4





extern void *valloc (size_t __size) noexcept (true) __attribute__ ((__malloc__))
                                         ;




extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size)
     noexcept (true) __attribute__ ((__nonnull__ (1))) ;




extern void *aligned_alloc (size_t __alignment, size_t __size)
     noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__alloc_align__ (1)))
                                         ;



extern void abort (void) noexcept (true) __attribute__ ((__noreturn__));



extern int atexit (void (*__func) (void)) noexcept (true) __attribute__ ((__nonnull__ (1)));




extern "C++" int at_quick_exit (void (*__func) (void))
     noexcept (true) __asm ("at_quick_exit") __attribute__ ((__nonnull__ (1)));
# 749 "/usr/include/stdlib.h" 3 4
extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg)
     noexcept (true) __attribute__ ((__nonnull__ (1)));





extern void exit (int __status) noexcept (true) __attribute__ ((__noreturn__));





extern void quick_exit (int __status) noexcept (true) __attribute__ ((__noreturn__));





extern void _Exit (int __status) noexcept (true) __attribute__ ((__noreturn__));




extern char *getenv (const char *__name) noexcept (true) __attribute__ ((__nonnull__ (1))) ;




extern char *secure_getenv (const char *__name)
     noexcept (true) __attribute__ ((__nonnull__ (1))) ;






extern int putenv (char *__string) noexcept (true) __attribute__ ((__nonnull__ (1)));





extern int setenv (const char *__name, const char *__value, int __replace)
     noexcept (true) __attribute__ ((__nonnull__ (2)));


extern int unsetenv (const char *__name) noexcept (true) __attribute__ ((__nonnull__ (1)));






extern int clearenv (void) noexcept (true);
# 814 "/usr/include/stdlib.h" 3 4
extern char *mktemp (char *__template) noexcept (true) __attribute__ ((__nonnull__ (1)));
# 827 "/usr/include/stdlib.h" 3 4
extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) ;
# 837 "/usr/include/stdlib.h" 3 4
extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) ;
# 849 "/usr/include/stdlib.h" 3 4
extern int mkstemps (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) ;
# 859 "/usr/include/stdlib.h" 3 4
extern int mkstemps64 (char *__template, int __suffixlen)
     __attribute__ ((__nonnull__ (1))) ;
# 870 "/usr/include/stdlib.h" 3 4
extern char *mkdtemp (char *__template) noexcept (true) __attribute__ ((__nonnull__ (1))) ;
# 881 "/usr/include/stdlib.h" 3 4
extern int mkostemp (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ;
# 891 "/usr/include/stdlib.h" 3 4
extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ;
# 901 "/usr/include/stdlib.h" 3 4
extern int mkostemps (char *__template, int __suffixlen, int __flags)
     __attribute__ ((__nonnull__ (1))) ;
# 913 "/usr/include/stdlib.h" 3 4
extern int mkostemps64 (char *__template, int __suffixlen, int __flags)
     __attribute__ ((__nonnull__ (1))) ;
# 923 "/usr/include/stdlib.h" 3 4
extern int system (const char *__command) ;





extern char *canonicalize_file_name (const char *__name)
     noexcept (true) __attribute__ ((__nonnull__ (1))) __attribute__ ((__malloc__))
                              ;
# 940 "/usr/include/stdlib.h" 3 4
extern char *realpath (const char *__restrict __name,
         char *__restrict __resolved) noexcept (true) ;






typedef int (*__compar_fn_t) (const void *, const void *);


typedef __compar_fn_t comparison_fn_t;



typedef int (*__compar_d_fn_t) (const void *, const void *, void *);




extern void *bsearch (const void *__key, const void *__base,
        size_t __nmemb, size_t __size, __compar_fn_t __compar)
     __attribute__ ((__nonnull__ (1, 2, 5))) ;


# 1 "/usr/include/bits/stdlib-bsearch.h" 1 3 4
# 19 "/usr/include/bits/stdlib-bsearch.h" 3 4
extern __inline __attribute__ ((__gnu_inline__)) void *
bsearch (const void *__key, const void *__base, size_t __nmemb, size_t __size,
  __compar_fn_t __compar)
{
  size_t __l, __u, __idx;
  const void *__p;
  int __comparison;

  __l = 0;
  __u = __nmemb;
  while (__l < __u)
    {
      __idx = (__l + __u) / 2;
      __p = (const void *) (((const char *) __base) + (__idx * __size));
      __comparison = (*__compar) (__key, __p);
      if (__comparison < 0)
 __u = __idx;
      else if (__comparison > 0)
 __l = __idx + 1;
      else
 {




   return (void *) __p;



 }
    }

  return __null;
}
# 966 "/usr/include/stdlib.h" 2 3 4




extern void qsort (void *__base, size_t __nmemb, size_t __size,
     __compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4)));

extern void qsort_r (void *__base, size_t __nmemb, size_t __size,
       __compar_d_fn_t __compar, void *__arg)
  __attribute__ ((__nonnull__ (1, 4)));




extern int abs (int __x) noexcept (true) __attribute__ ((__const__)) ;
extern long int labs (long int __x) noexcept (true) __attribute__ ((__const__)) ;


__extension__ extern long long int llabs (long long int __x)
     noexcept (true) __attribute__ ((__const__)) ;






extern div_t div (int __numer, int __denom)
     noexcept (true) __attribute__ ((__const__)) ;
extern ldiv_t ldiv (long int __numer, long int __denom)
     noexcept (true) __attribute__ ((__const__)) ;


__extension__ extern lldiv_t lldiv (long long int __numer,
        long long int __denom)
     noexcept (true) __attribute__ ((__const__)) ;
# 1012 "/usr/include/stdlib.h" 3 4
extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt,
     int *__restrict __sign) noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ;




extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt,
     int *__restrict __sign) noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ;




extern char *gcvt (double __value, int __ndigit, char *__buf)
     noexcept (true) __attribute__ ((__nonnull__ (3))) ;




extern char *qecvt (long double __value, int __ndigit,
      int *__restrict __decpt, int *__restrict __sign)
     noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ;
extern char *qfcvt (long double __value, int __ndigit,
      int *__restrict __decpt, int *__restrict __sign)
     noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ;
extern char *qgcvt (long double __value, int __ndigit, char *__buf)
     noexcept (true) __attribute__ ((__nonnull__ (3))) ;




extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt,
     int *__restrict __sign, char *__restrict __buf,
     size_t __len) noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5)));
extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt,
     int *__restrict __sign, char *__restrict __buf,
     size_t __len) noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5)));

extern int qecvt_r (long double __value, int __ndigit,
      int *__restrict __decpt, int *__restrict __sign,
      char *__restrict __buf, size_t __len)
     noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5)));
extern int qfcvt_r (long double __value, int __ndigit,
      int *__restrict __decpt, int *__restrict __sign,
      char *__restrict __buf, size_t __len)
     noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5)));





extern int mblen (const char *__s, size_t __n) noexcept (true);


extern int mbtowc (wchar_t *__restrict __pwc,
     const char *__restrict __s, size_t __n) noexcept (true);


extern int wctomb (char *__s, wchar_t __wchar) noexcept (true);



extern size_t mbstowcs (wchar_t *__restrict __pwcs,
   const char *__restrict __s, size_t __n) noexcept (true)
                                      ;

extern size_t wcstombs (char *__restrict __s,
   const wchar_t *__restrict __pwcs, size_t __n)
     noexcept (true)

                                    ;






extern int rpmatch (const char *__response) noexcept (true) __attribute__ ((__nonnull__ (1))) ;
# 1099 "/usr/include/stdlib.h" 3 4
extern int getsubopt (char **__restrict __optionp,
        char *const *__restrict __tokens,
        char **__restrict __valuep)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2, 3))) ;







extern int posix_openpt (int __oflag) ;







extern int grantpt (int __fd) noexcept (true);



extern int unlockpt (int __fd) noexcept (true);




extern char *ptsname (int __fd) noexcept (true) ;






extern int ptsname_r (int __fd, char *__buf, size_t __buflen)
     noexcept (true) __attribute__ ((__nonnull__ (2))) ;


extern int getpt (void);






extern int getloadavg (double __loadavg[], int __nelem)
     noexcept (true) __attribute__ ((__nonnull__ (1)));
# 1155 "/usr/include/stdlib.h" 3 4
# 1 "/usr/include/bits/stdlib-float.h" 1 3 4
# 24 "/usr/include/bits/stdlib-float.h" 3 4
extern __inline __attribute__ ((__gnu_inline__)) double
 atof (const char *__nptr) noexcept (true)
{
  return strtod (__nptr, (char **) __null);
}
# 1156 "/usr/include/stdlib.h" 2 3 4
# 1167 "/usr/include/stdlib.h" 3 4
}
# 80 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdlib" 2 3

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/std_abs.h" 1 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/std_abs.h" 3
# 46 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/std_abs.h" 3
  inline constexpr double
  abs(double __x)
  { return __builtin_fabs(__x); }

  inline constexpr float
  abs(float __x)
  { return __builtin_fabsf(__x); }

  inline constexpr long double
  abs(long double __x)
  { return __builtin_fabsl(__x); }



  __extension__ inline constexpr __int128
  abs(__int128 __x) { return __x >= 0 ? __x : -__x; }
# 135 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/std_abs.h" 3
  __extension__ inline constexpr
  __float128
  abs(__float128 __x)
  {



    return __builtin_fabsf128(__x);




  }



}
}
# 82 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdlib" 2 3
# 125 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdlib" 3
extern "C++"
{
namespace std __attribute__ ((__visibility__ ("default")))
{


  using ::div_t;
  using ::ldiv_t;

  using ::abort;

  using ::aligned_alloc;

  using ::atexit;


  using ::at_quick_exit;


  using ::atof;
  using ::atoi;
  using ::atol;
  using ::bsearch;
  using ::calloc;
  using ::div;
  using ::exit;
  using ::free;
  using ::getenv;
  using ::labs;
  using ::ldiv;
  using ::malloc;

  using ::mblen;
  using ::mbstowcs;
  using ::mbtowc;

  using ::qsort;


  using ::quick_exit;


  using ::rand;
  using ::realloc;
  using ::srand;
  using ::strtod;
  using ::strtol;
  using ::strtoul;
  using ::system;

  using ::wcstombs;
  using ::wctomb;



  inline ldiv_t
  div(long __i, long __j) noexcept { return ldiv(__i, __j); }




}
# 199 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdlib" 3
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{



  using ::lldiv_t;





  using ::_Exit;



  using ::llabs;

  inline lldiv_t
  div(long long __n, long long __d)
  { lldiv_t __q; __q.quot = __n / __d; __q.rem = __n % __d; return __q; }

  using ::lldiv;
# 231 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdlib" 3
  using ::atoll;
  using ::strtoll;
  using ::strtoull;

  using ::strtof;
  using ::strtold;


}

namespace std
{

  using ::__gnu_cxx::lldiv_t;

  using ::__gnu_cxx::_Exit;

  using ::__gnu_cxx::llabs;
  using ::__gnu_cxx::div;
  using ::__gnu_cxx::lldiv;

  using ::__gnu_cxx::atoll;
  using ::__gnu_cxx::strtof;
  using ::__gnu_cxx::strtoll;
  using ::__gnu_cxx::strtoull;
  using ::__gnu_cxx::strtold;
}
# 275 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdlib" 3
}
# 16 "/usr/include/boost/config/platform/linux.hpp" 2 3 4
# 75 "/usr/include/boost/config/platform/linux.hpp" 3 4
# 1 "/usr/include/boost/config/detail/posix_features.hpp" 1 3 4
# 76 "/usr/include/boost/config/platform/linux.hpp" 2 3 4
# 58 "/usr/include/boost/config.hpp" 2 3 4



# 1 "/usr/include/boost/config/detail/suffix.hpp" 1 3 4
# 35 "/usr/include/boost/config/detail/suffix.hpp" 3
# 510 "/usr/include/boost/config/detail/suffix.hpp" 3
namespace boost{

   __extension__ typedef long long long_long_type;
   __extension__ typedef unsigned long long ulong_long_type;




}



namespace boost{

   __extension__ typedef __int128 int128_type;
   __extension__ typedef unsigned __int128 uint128_type;




}
# 572 "/usr/include/boost/config/detail/suffix.hpp" 3
# 1 "/usr/include/boost/config/helper_macros.hpp" 1 3 4
# 573 "/usr/include/boost/config/detail/suffix.hpp" 2 3
# 1282 "/usr/include/boost/config/detail/suffix.hpp" 3
# 1 "/usr/include/boost/config/detail/cxx_composite.hpp" 1 3 4
# 1283 "/usr/include/boost/config/detail/suffix.hpp" 2 3
# 62 "/usr/include/boost/config.hpp" 2 3 4
# 15 "/usr/include/boost/intrusive/detail/config_begin.hpp" 2 3 4
# 18 "/usr/include/boost/intrusive/list.hpp" 2 3 4
# 1 "/usr/include/boost/intrusive/intrusive_fwd.hpp" 1 3 4
# 21 "/usr/include/boost/intrusive/intrusive_fwd.hpp" 3 4
# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 47 "/usr/include/boost/cstdint.hpp" 3
# 71 "/usr/include/boost/cstdint.hpp" 3
# 1 "/usr/bin/../lib/clang/18/include/stdint.h" 1 3
# 52 "/usr/bin/../lib/clang/18/include/stdint.h" 3
# 1 "/usr/include/stdint.h" 1 3 4
# 26 "/usr/include/stdint.h" 3 4
# 1 "/usr/include/bits/libc-header-start.h" 1 3 4
# 27 "/usr/include/stdint.h" 2 3 4

# 1 "/usr/include/bits/wchar.h" 1 3 4
# 29 "/usr/include/stdint.h" 2 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 30 "/usr/include/stdint.h" 2 3 4







# 1 "/usr/include/bits/stdint-uintn.h" 1 3 4
# 24 "/usr/include/bits/stdint-uintn.h" 3 4
typedef __uint8_t uint8_t;
typedef __uint16_t uint16_t;
typedef __uint32_t uint32_t;
typedef __uint64_t uint64_t;
# 38 "/usr/include/stdint.h" 2 3 4



# 1 "/usr/include/bits/stdint-least.h" 1 3 4
# 25 "/usr/include/bits/stdint-least.h" 3 4
typedef __int_least8_t int_least8_t;
typedef __int_least16_t int_least16_t;
typedef __int_least32_t int_least32_t;
typedef __int_least64_t int_least64_t;


typedef __uint_least8_t uint_least8_t;
typedef __uint_least16_t uint_least16_t;
typedef __uint_least32_t uint_least32_t;
typedef __uint_least64_t uint_least64_t;
# 42 "/usr/include/stdint.h" 2 3 4





typedef signed char int_fast8_t;

typedef long int int_fast16_t;
typedef long int int_fast32_t;
typedef long int int_fast64_t;
# 60 "/usr/include/stdint.h" 3 4
typedef unsigned char uint_fast8_t;

typedef unsigned long int uint_fast16_t;
typedef unsigned long int uint_fast32_t;
typedef unsigned long int uint_fast64_t;
# 79 "/usr/include/stdint.h" 3 4
typedef unsigned long int uintptr_t;
# 90 "/usr/include/stdint.h" 3 4
typedef __intmax_t intmax_t;
typedef __uintmax_t uintmax_t;
# 53 "/usr/bin/../lib/clang/18/include/stdint.h" 2 3
# 72 "/usr/include/boost/cstdint.hpp" 2 3
# 114 "/usr/include/boost/cstdint.hpp" 3
namespace boost
{

  using ::int8_t;
  using ::int_least8_t;
  using ::int_fast8_t;
  using ::uint8_t;
  using ::uint_least8_t;
  using ::uint_fast8_t;

  using ::int16_t;
  using ::int_least16_t;
  using ::int_fast16_t;
  using ::uint16_t;
  using ::uint_least16_t;
  using ::uint_fast16_t;

  using ::int32_t;
  using ::int_least32_t;
  using ::int_fast32_t;
  using ::uint32_t;
  using ::uint_least32_t;
  using ::uint_fast32_t;



  using ::int64_t;
  using ::int_least64_t;
  using ::int_fast64_t;
  using ::uint64_t;
  using ::uint_least64_t;
  using ::uint_fast64_t;



  using ::intmax_t;
  using ::uintmax_t;

}
# 387 "/usr/include/boost/cstdint.hpp" 3
namespace boost {
    using ::intptr_t;
    using ::uintptr_t;
}
# 22 "/usr/include/boost/intrusive/intrusive_fwd.hpp" 2 3 4
# 66 "/usr/include/boost/intrusive/intrusive_fwd.hpp" 3 4
# 1 "/usr/include/boost/intrusive/link_mode.hpp" 1 3 4
# 20 "/usr/include/boost/intrusive/link_mode.hpp" 3 4
namespace boost {
namespace intrusive {



enum link_mode_type{





   normal_link,






   safe_link,






   auto_unlink
};



template <link_mode_type link_mode>
struct is_safe_autounlink
{
   static const bool value =
      (int)link_mode == (int)auto_unlink ||
      (int)link_mode == (int)safe_link;
};



}
}
# 67 "/usr/include/boost/intrusive/intrusive_fwd.hpp" 2 3 4
# 1 "/usr/include/boost/intrusive/detail/workaround.hpp" 1 3 4
# 68 "/usr/include/boost/intrusive/intrusive_fwd.hpp" 2 3 4

namespace boost {
namespace intrusive {



      using ::boost::uintptr_t;
# 85 "/usr/include/boost/intrusive/intrusive_fwd.hpp" 3 4
template<class NodeTraits>
class circular_list_algorithms;

template<class NodeTraits>
class circular_slist_algorithms;

template<class NodeTraits>
class linear_slist_algorithms;

template<class NodeTraits>
class bstree_algorithms;

template<class NodeTraits>
class rbtree_algorithms;

template<class NodeTraits>
class avltree_algorithms;

template<class NodeTraits>
class sgtree_algorithms;

template<class NodeTraits>
class splaytree_algorithms;

template<class NodeTraits>
class treap_algorithms;
# 128 "/usr/include/boost/intrusive/intrusive_fwd.hpp" 3 4
template<class T, class ...Options>

class slist;
# 139 "/usr/include/boost/intrusive/intrusive_fwd.hpp" 3 4
template<class ...Options>

class slist_base_hook;
# 150 "/usr/include/boost/intrusive/intrusive_fwd.hpp" 3 4
template<class ...Options>

class slist_member_hook;
# 164 "/usr/include/boost/intrusive/intrusive_fwd.hpp" 3 4
template<class T, class ...Options>

class list;
# 175 "/usr/include/boost/intrusive/intrusive_fwd.hpp" 3 4
template<class ...Options>

class list_base_hook;
# 186 "/usr/include/boost/intrusive/intrusive_fwd.hpp" 3 4
template<class ...Options>

class list_member_hook;
# 202 "/usr/include/boost/intrusive/intrusive_fwd.hpp" 3 4
template<class T, class ...Options>

class rbtree;
# 217 "/usr/include/boost/intrusive/intrusive_fwd.hpp" 3 4
template<class T, class ...Options>

class set;
# 232 "/usr/include/boost/intrusive/intrusive_fwd.hpp" 3 4
template<class T, class ...Options>

class multiset;
# 244 "/usr/include/boost/intrusive/intrusive_fwd.hpp" 3 4
template<class ...Options>

class set_base_hook;
# 256 "/usr/include/boost/intrusive/intrusive_fwd.hpp" 3 4
template<class ...Options>

class set_member_hook;
# 272 "/usr/include/boost/intrusive/intrusive_fwd.hpp" 3 4
template<class T, class ...Options>

class splaytree;
# 287 "/usr/include/boost/intrusive/intrusive_fwd.hpp" 3 4
template<class T, class ...Options>

class splay_set;
# 302 "/usr/include/boost/intrusive/intrusive_fwd.hpp" 3 4
template<class T, class ...Options>

class splay_multiset;
# 318 "/usr/include/boost/intrusive/intrusive_fwd.hpp" 3 4
template<class T, class ...Options>

class avltree;
# 333 "/usr/include/boost/intrusive/intrusive_fwd.hpp" 3 4
template<class T, class ...Options>

class avl_set;
# 348 "/usr/include/boost/intrusive/intrusive_fwd.hpp" 3 4
template<class T, class ...Options>

class avl_multiset;
# 360 "/usr/include/boost/intrusive/intrusive_fwd.hpp" 3 4
template<class ...Options>

class avl_set_base_hook;
# 372 "/usr/include/boost/intrusive/intrusive_fwd.hpp" 3 4
template<class ...Options>

class avl_set_member_hook;
# 390 "/usr/include/boost/intrusive/intrusive_fwd.hpp" 3 4
template<class T, class ...Options>

class treap;
# 406 "/usr/include/boost/intrusive/intrusive_fwd.hpp" 3 4
template<class T, class ...Options>

class treap_set;
# 422 "/usr/include/boost/intrusive/intrusive_fwd.hpp" 3 4
template<class T, class ...Options>

class treap_multiset;
# 438 "/usr/include/boost/intrusive/intrusive_fwd.hpp" 3 4
template<class T, class ...Options>

class sgtree;
# 453 "/usr/include/boost/intrusive/intrusive_fwd.hpp" 3 4
template<class T, class ...Options>

class sg_set;
# 468 "/usr/include/boost/intrusive/intrusive_fwd.hpp" 3 4
template<class T, class ...Options>

class sg_multiset;
# 483 "/usr/include/boost/intrusive/intrusive_fwd.hpp" 3 4
template<class T, class ...Options>

class bstree;
# 498 "/usr/include/boost/intrusive/intrusive_fwd.hpp" 3 4
template<class T, class ...Options>

class bs_set;
# 513 "/usr/include/boost/intrusive/intrusive_fwd.hpp" 3 4
template<class T, class ...Options>

class bs_multiset;
# 524 "/usr/include/boost/intrusive/intrusive_fwd.hpp" 3 4
template<class ...Options>

class bs_set_base_hook;
# 535 "/usr/include/boost/intrusive/intrusive_fwd.hpp" 3 4
template<class ...Options>

class bs_set_member_hook;
# 556 "/usr/include/boost/intrusive/intrusive_fwd.hpp" 3 4
template<class T, class ...Options>

class hashtable;
# 576 "/usr/include/boost/intrusive/intrusive_fwd.hpp" 3 4
template<class T, class ...Options>

class unordered_set;
# 596 "/usr/include/boost/intrusive/intrusive_fwd.hpp" 3 4
template<class T, class ...Options>

class unordered_multiset;
# 608 "/usr/include/boost/intrusive/intrusive_fwd.hpp" 3 4
template<class ...Options>

class unordered_set_base_hook;
# 620 "/usr/include/boost/intrusive/intrusive_fwd.hpp" 3 4
template<class ...Options>

class unordered_set_member_hook;
# 631 "/usr/include/boost/intrusive/intrusive_fwd.hpp" 3 4
template<class ...Options>

class any_base_hook;
# 642 "/usr/include/boost/intrusive/intrusive_fwd.hpp" 3 4
template<class ...Options>

class any_member_hook;



template<bool Enabled>
struct constant_time_size;

template<typename SizeType>
struct size_type;

template<typename Compare>
struct compare;

template<bool Enabled>
struct floating_point;

template<typename Equal>
struct equal;

template<typename Priority>
struct priority;

template<typename Hash>
struct hash;

template<typename ValueTraits> struct value_traits;

template< typename Parent
        , typename MemberHook
        , MemberHook Parent::* PtrToMember>
struct member_hook;

template<typename Functor>
struct function_hook;

template<typename BaseHook>
struct base_hook;

template<typename VoidPointer>
struct void_pointer;

template<typename Tag>
struct tag;

template<link_mode_type LinkType>
struct link_mode;

template<bool Enabled> struct
optimize_size;

template<bool Enabled>
struct linear;

template<bool Enabled>
struct cache_last;

template<typename BucketTraits>
struct bucket_traits;

template<bool Enabled>
struct store_hash;

template<bool Enabled>
struct optimize_multikey;

template<bool Enabled>
struct power_2_buckets;

template<bool Enabled>
struct cache_begin;

template<bool Enabled>
struct compare_hash;

template<bool Enabled>
struct incremental;



template<typename ValueTraits>
struct value_traits;

template< typename Parent
        , typename MemberHook
        , MemberHook Parent::* PtrToMember>
struct member_hook;

template< typename Functor>
struct function_hook;

template<typename BaseHook>
struct base_hook;

template<class T, class NodeTraits, link_mode_type LinkMode = safe_link>
struct derivation_value_traits;

template<class NodeTraits, link_mode_type LinkMode = normal_link>
struct trivial_value_traits;



template<typename VoidPointer, std::size_t Alignment>
struct max_pointer_plus_bits;

template<std::size_t Alignment>
struct max_pointer_plus_bits<void *, Alignment>;

template<typename Pointer, std::size_t NumBits>
struct pointer_plus_bits;

template<typename T, std::size_t NumBits>
struct pointer_plus_bits<T *, NumBits>;

template<typename Ptr>
struct pointer_traits;

template<typename T>
struct pointer_traits<T *>;

}
}
# 19 "/usr/include/boost/intrusive/list.hpp" 2 3 4
# 1 "/usr/include/boost/intrusive/detail/assert.hpp" 1 3 4
# 25 "/usr/include/boost/intrusive/detail/assert.hpp" 3 4
# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 58 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 59 "/usr/include/boost/assert.hpp" 2 3 4
# 26 "/usr/include/boost/intrusive/detail/assert.hpp" 2 3 4






# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 58 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 59 "/usr/include/boost/assert.hpp" 2 3 4
# 33 "/usr/include/boost/intrusive/detail/assert.hpp" 2 3 4






# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 58 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 59 "/usr/include/boost/assert.hpp" 2 3 4
# 40 "/usr/include/boost/intrusive/detail/assert.hpp" 2 3 4
# 20 "/usr/include/boost/intrusive/list.hpp" 2 3 4
# 1 "/usr/include/boost/intrusive/list_hook.hpp" 1 3 4
# 17 "/usr/include/boost/intrusive/list_hook.hpp" 3 4
# 1 "/usr/include/boost/intrusive/detail/config_begin.hpp" 1 3 4
# 18 "/usr/include/boost/intrusive/list_hook.hpp" 2 3 4


# 1 "/usr/include/boost/intrusive/detail/list_node.hpp" 1 3 4
# 26 "/usr/include/boost/intrusive/detail/list_node.hpp" 3 4
# 1 "/usr/include/boost/intrusive/pointer_rebind.hpp" 1 3 4
# 26 "/usr/include/boost/intrusive/pointer_rebind.hpp" 3 4
namespace boost {
namespace intrusive {




template <typename Ptr, typename U>
struct pointer_has_rebind
{
   template <typename V> struct any
   { any(const V&) { } };

   template <typename X>
   static char test(int, typename X::template rebind<U>*);

   template <typename X>
   static int test(any<int>, void*);

   static const bool value = (1 == sizeof(test<Ptr>(0, 0)));
};

template <typename Ptr, typename U>
struct pointer_has_rebind_other
{
   template <typename V> struct any
   { any(const V&) { } };

   template <typename X>
   static char test(int, typename X::template rebind<U>::other*);

   template <typename X>
   static int test(any<int>, void*);

   static const bool value = (1 == sizeof(test<Ptr>(0, 0)));
};

template <typename Ptr, typename U>
struct pointer_rebind_mode
{
   static const unsigned int rebind = (unsigned int)pointer_has_rebind<Ptr, U>::value;
   static const unsigned int rebind_other = (unsigned int)pointer_has_rebind_other<Ptr, U>::value;
   static const unsigned int mode = rebind + rebind*rebind_other;
};




template <typename Ptr, typename U, unsigned int RebindMode>
struct pointer_rebinder;



template <typename Ptr, typename U>
struct pointer_rebinder< Ptr, U, 2u >
{
   typedef typename Ptr::template rebind<U>::other type;
};



template <typename Ptr, typename U>
struct pointer_rebinder< Ptr, U, 1u >
{
   typedef typename Ptr::template rebind<U> type;
};
# 99 "/usr/include/boost/intrusive/pointer_rebind.hpp" 3 4
template <template <class, class...> class Ptr, typename A, class... An, class U>
struct pointer_rebinder<Ptr<A, An...>, U, 0u >
{
   typedef Ptr<U, An...> type;
};


template <template <class> class Ptr, typename A, class U>
struct pointer_rebinder<Ptr<A>, U, 0u >
{
   typedef Ptr<U> type;
};
# 176 "/usr/include/boost/intrusive/pointer_rebind.hpp" 3 4
template <typename Ptr, typename U>
struct pointer_rebind
   : public pointer_rebinder<Ptr, U, pointer_rebind_mode<Ptr, U>::mode>
{};

template <typename T, typename U>
struct pointer_rebind<T*, U>
{ typedef U* type; };

}
}
# 27 "/usr/include/boost/intrusive/detail/list_node.hpp" 2 3 4

namespace boost {
namespace intrusive {





template<class VoidPointer>
struct list_node
{
   typedef typename pointer_rebind<VoidPointer, list_node>::type node_ptr;
   node_ptr next_;
   node_ptr prev_;
};

template<class VoidPointer>
struct list_node_traits
{
   typedef list_node<VoidPointer> node;
   typedef typename node::node_ptr node_ptr;
   typedef typename pointer_rebind<VoidPointer, const node>::type const_node_ptr;

   inline __attribute__ ((__always_inline__)) static node_ptr get_previous(const_node_ptr n)
   { return n->prev_; }

   inline __attribute__ ((__always_inline__)) static node_ptr get_previous(node_ptr n)
   { return n->prev_; }

   inline __attribute__ ((__always_inline__)) static void set_previous(node_ptr n, node_ptr prev)
   { n->prev_ = prev; }

   inline __attribute__ ((__always_inline__)) static node_ptr get_next(const_node_ptr n)
   { return n->next_; }

   inline __attribute__ ((__always_inline__)) static node_ptr get_next(node_ptr n)
   { return n->next_; }

   inline __attribute__ ((__always_inline__)) static void set_next(node_ptr n, node_ptr next)
   { n->next_ = next; }
};

}
}
# 21 "/usr/include/boost/intrusive/list_hook.hpp" 2 3 4
# 1 "/usr/include/boost/intrusive/circular_list_algorithms.hpp" 1 3 4
# 17 "/usr/include/boost/intrusive/circular_list_algorithms.hpp" 3 4
# 1 "/usr/include/boost/intrusive/detail/config_begin.hpp" 1 3 4
# 18 "/usr/include/boost/intrusive/circular_list_algorithms.hpp" 2 3 4


# 1 "/usr/include/boost/intrusive/detail/algo_type.hpp" 1 3 4
# 24 "/usr/include/boost/intrusive/detail/algo_type.hpp" 3 4
namespace boost {
namespace intrusive {

enum algo_types
{
   CircularListAlgorithms,
   CircularSListAlgorithms,
   LinearSListAlgorithms,
   CommonSListAlgorithms,
   BsTreeAlgorithms,
   RbTreeAlgorithms,
   AvlTreeAlgorithms,
   SgTreeAlgorithms,
   SplayTreeAlgorithms,
   TreapAlgorithms,
   UnorderedAlgorithms,
   UnorderedCircularSlistAlgorithms,
   AnyAlgorithm
};

template<algo_types AlgoType, class NodeTraits>
struct get_algo;

template<algo_types AlgoType, class ValueTraits, class NodePtrCompare, class ExtraChecker>
struct get_node_checker;

}
}
# 21 "/usr/include/boost/intrusive/circular_list_algorithms.hpp" 2 3 4






namespace boost {
namespace intrusive {
# 55 "/usr/include/boost/intrusive/circular_list_algorithms.hpp" 3 4
template<class NodeTraits>
class circular_list_algorithms
{
   public:
   typedef typename NodeTraits::node node;
   typedef typename NodeTraits::node_ptr node_ptr;
   typedef typename NodeTraits::const_node_ptr const_node_ptr;
   typedef NodeTraits node_traits;







   static void init(node_ptr this_node) noexcept
   {
      const node_ptr null_node = node_ptr();
      NodeTraits::set_next(this_node, null_node);
      NodeTraits::set_previous(this_node, null_node);
   }







   inline __attribute__ ((__always_inline__)) static bool inited(const_node_ptr this_node) noexcept
   { return !NodeTraits::get_next(this_node); }
# 94 "/usr/include/boost/intrusive/circular_list_algorithms.hpp" 3 4
   static void init_header(node_ptr this_node) noexcept
   {
      NodeTraits::set_next(this_node, this_node);
      NodeTraits::set_previous(this_node, this_node);
   }






   inline __attribute__ ((__always_inline__)) static bool is_empty(const_node_ptr this_node) noexcept
   {
      return NodeTraits::get_next(this_node) == this_node;
   }
# 118 "/usr/include/boost/intrusive/circular_list_algorithms.hpp" 3 4
   static bool unique(const_node_ptr this_node) noexcept
   {
      node_ptr next = NodeTraits::get_next(this_node);
      return !next || next == this_node;
   }
# 132 "/usr/include/boost/intrusive/circular_list_algorithms.hpp" 3 4
   static std::size_t count(const_node_ptr this_node) noexcept
   {
      std::size_t result = 0;
      const_node_ptr p = this_node;
      do{
         p = NodeTraits::get_next(p);
         ++result;
      }while (p != this_node);
      return result;
   }
# 150 "/usr/include/boost/intrusive/circular_list_algorithms.hpp" 3 4
   static node_ptr unlink(node_ptr this_node) noexcept
   {
      node_ptr next(NodeTraits::get_next(this_node));
      node_ptr prev(NodeTraits::get_previous(this_node));
      NodeTraits::set_next(prev, next);
      NodeTraits::set_previous(next, prev);
      return next;
   }
# 166 "/usr/include/boost/intrusive/circular_list_algorithms.hpp" 3 4
   static void unlink(node_ptr b, node_ptr e) noexcept
   {
      if (b != e) {
         node_ptr prevb(NodeTraits::get_previous(b));
         NodeTraits::set_previous(e, prevb);
         NodeTraits::set_next(prevb, e);
      }
   }
# 182 "/usr/include/boost/intrusive/circular_list_algorithms.hpp" 3 4
   static void link_before(node_ptr nxt_node, node_ptr this_node) noexcept
   {
      node_ptr prev(NodeTraits::get_previous(nxt_node));
      NodeTraits::set_previous(this_node, prev);
      NodeTraits::set_next(this_node, nxt_node);



      NodeTraits::set_previous(nxt_node, this_node);
      NodeTraits::set_next(prev, this_node);
   }
# 201 "/usr/include/boost/intrusive/circular_list_algorithms.hpp" 3 4
   static void link_after(node_ptr prev_node, node_ptr this_node) noexcept
   {
      node_ptr next(NodeTraits::get_next(prev_node));
      NodeTraits::set_previous(this_node, prev_node);
      NodeTraits::set_next(this_node, next);



      NodeTraits::set_next(prev_node, this_node);
      NodeTraits::set_previous(next, this_node);
   }
# 223 "/usr/include/boost/intrusive/circular_list_algorithms.hpp" 3 4
   static void swap_nodes(node_ptr this_node, node_ptr other_node) noexcept
   {
      if (other_node == this_node)
         return;
      bool this_inited = inited(this_node);
      bool other_inited = inited(other_node);
      if(this_inited){
         init_header(this_node);
      }
      if(other_inited){
         init_header(other_node);
      }

      node_ptr next_this(NodeTraits::get_next(this_node));
      node_ptr prev_this(NodeTraits::get_previous(this_node));
      node_ptr next_other(NodeTraits::get_next(other_node));
      node_ptr prev_other(NodeTraits::get_previous(other_node));

      swap_prev(next_this, next_other);
      swap_next(prev_this, prev_other);
      swap_next(this_node, other_node);
      swap_prev(this_node, other_node);

      if(this_inited){
         init(other_node);
      }
      if(other_inited){
         init(this_node);
      }
   }
# 264 "/usr/include/boost/intrusive/circular_list_algorithms.hpp" 3 4
   static void transfer(node_ptr p, node_ptr b, node_ptr e) noexcept
   {
      if (b != e && p != b && p != e) {
         node_ptr prev_p(NodeTraits::get_previous(p));
         node_ptr prev_b(NodeTraits::get_previous(b));
         node_ptr prev_e(NodeTraits::get_previous(e));
         NodeTraits::set_next(prev_e, p);
         NodeTraits::set_previous(p, prev_e);
         NodeTraits::set_next(prev_b, e);
         NodeTraits::set_previous(e, prev_b);
         NodeTraits::set_next(prev_p, b);
         NodeTraits::set_previous(b, prev_p);
      }
   }
# 289 "/usr/include/boost/intrusive/circular_list_algorithms.hpp" 3 4
   static void transfer(node_ptr p, node_ptr i) noexcept
   {
      node_ptr n(NodeTraits::get_next(i));
      if(n != p && i != p){
         node_ptr prev_p(NodeTraits::get_previous(p));
         node_ptr prev_i(NodeTraits::get_previous(i));
         NodeTraits::set_next(prev_p, i);
         NodeTraits::set_previous(i, prev_p);
         NodeTraits::set_next(i, p);
         NodeTraits::set_previous(p, i);
         NodeTraits::set_previous(n, prev_i);
         NodeTraits::set_next(prev_i, n);

      }
   }






   static void reverse(node_ptr p) noexcept
   {
      node_ptr f(NodeTraits::get_next(p));
      node_ptr i(NodeTraits::get_next(f)), e(p);

      while(i != e) {
         node_ptr n = i;
         i = NodeTraits::get_next(i);
         transfer(f, n, i);
         f = n;
      }
   }






   static void move_backwards(node_ptr p, std::size_t n) noexcept
   {

      if(!n) return;
      node_ptr first = NodeTraits::get_next(p);

      if(first == NodeTraits::get_previous(p)) return;
      unlink(p);

      while(n--){
         first = NodeTraits::get_next(first);
      }
      link_before(first, p);
   }






   static void move_forward(node_ptr p, std::size_t n) noexcept
   {

      if(!n) return;
      node_ptr last = NodeTraits::get_previous(p);

      if(last == NodeTraits::get_next(p)) return;

      unlink(p);

      while(n--){
         last = NodeTraits::get_previous(last);
      }
      link_after(last, p);
   }
# 371 "/usr/include/boost/intrusive/circular_list_algorithms.hpp" 3 4
   static std::size_t distance(const_node_ptr f, const_node_ptr l) noexcept
   {
      std::size_t result = 0;
      while(f != l){
         f = NodeTraits::get_next(f);
         ++result;
      }
      return result;
   }

   struct stable_partition_info
   {
      std::size_t num_1st_partition;
      std::size_t num_2nd_partition;
      node_ptr beg_2st_partition;
   };

   template<class Pred>
   static void stable_partition(node_ptr beg, node_ptr end, Pred pred, stable_partition_info &info)
   {
      node_ptr bcur = node_traits::get_previous(beg);
      node_ptr cur = beg;
      node_ptr new_f = end;

      std::size_t num1 = 0, num2 = 0;
      while(cur != end){
         if(pred(cur)){
            ++num1;
            bcur = cur;
            cur = node_traits::get_next(cur);
         }
         else{
            ++num2;
            node_ptr last_to_remove = bcur;
            new_f = cur;
            bcur = cur;
            cur = node_traits::get_next(cur);
            { try{

               while(cur != end){
                  if(pred(cur)){
                     ++num1;

                     node_traits::set_next (last_to_remove, cur);
                     node_traits::set_previous(cur, last_to_remove);
                     last_to_remove = cur;
                     node_ptr nxt = node_traits::get_next(cur);
                     node_traits::set_next (bcur, nxt);
                     node_traits::set_previous(nxt, bcur);
                     cur = nxt;
                  }
                  else{
                     ++num2;
                     bcur = cur;
                     cur = node_traits::get_next(cur);
                  }
               }
            }
            catch(...){
               node_traits::set_next (last_to_remove, new_f);
               node_traits::set_previous(new_f, last_to_remove);
               throw;;
            }
            }
            node_traits::set_next(last_to_remove, new_f);
            node_traits::set_previous(new_f, last_to_remove);
            break;
         }
      }
      info.num_1st_partition = num1;
      info.num_2nd_partition = num2;
      info.beg_2st_partition = new_f;
   }

   private:
   static void swap_prev(node_ptr this_node, node_ptr other_node) noexcept
   {
      node_ptr temp(NodeTraits::get_previous(this_node));
      NodeTraits::set_previous(this_node, NodeTraits::get_previous(other_node));
      NodeTraits::set_previous(other_node, temp);
   }

   static void swap_next(node_ptr this_node, node_ptr other_node) noexcept
   {
      node_ptr temp(NodeTraits::get_next(this_node));
      NodeTraits::set_next(this_node, NodeTraits::get_next(other_node));
      NodeTraits::set_next(other_node, temp);
   }
};



template<class NodeTraits>
struct get_algo<CircularListAlgorithms, NodeTraits>
{
   typedef circular_list_algorithms<NodeTraits> type;
};



}
}

# 1 "/usr/include/boost/intrusive/detail/config_end.hpp" 1 3 4
# 475 "/usr/include/boost/intrusive/circular_list_algorithms.hpp" 2 3 4
# 22 "/usr/include/boost/intrusive/list_hook.hpp" 2 3 4
# 1 "/usr/include/boost/intrusive/options.hpp" 1 3 4
# 16 "/usr/include/boost/intrusive/options.hpp" 3 4
# 1 "/usr/include/boost/intrusive/detail/config_begin.hpp" 1 3 4
# 17 "/usr/include/boost/intrusive/options.hpp" 2 3 4


# 1 "/usr/include/boost/intrusive/pack_options.hpp" 1 3 4
# 16 "/usr/include/boost/intrusive/pack_options.hpp" 3 4
# 1 "/usr/include/boost/intrusive/detail/config_begin.hpp" 1 3 4
# 17 "/usr/include/boost/intrusive/pack_options.hpp" 2 3 4







namespace boost {
namespace intrusive {
# 102 "/usr/include/boost/intrusive/pack_options.hpp" 3 4
template<std::size_t... Indexes>
struct index_tuple{};


template<std::size_t Num, typename Tuple = index_tuple<> >
struct build_number_seq;

template<std::size_t Num, std::size_t... Indexes>
struct build_number_seq<Num, index_tuple<Indexes...> >
   : build_number_seq<Num - 1, index_tuple<Indexes..., sizeof...(Indexes)> >
{};

template<std::size_t... Indexes>
struct build_number_seq<0, index_tuple<Indexes...> >
{ typedef index_tuple<Indexes...> type; };

template<class ...Types>
struct typelist
{};


template<class T>
struct invert_typelist;

template<std::size_t I, typename Tuple>
struct typelist_element;

template<std::size_t I, typename Head, typename... Tail>
struct typelist_element<I, typelist<Head, Tail...> >
{
   typedef typename typelist_element<I-1, typelist<Tail...> >::type type;
};

template<typename Head, typename... Tail>
struct typelist_element<0, typelist<Head, Tail...> >
{
   typedef Head type;
};

template<std::size_t ...Ints, class ...Types>
typelist<typename typelist_element<(sizeof...(Types) - 1) - Ints, typelist<Types...> >::type...>
   inverted_typelist(index_tuple<Ints...>, typelist<Types...>)
{
   return typelist<typename typelist_element<(sizeof...(Types) - 1) - Ints, typelist<Types...> >::type...>();
}


template<class Typelist>
struct sizeof_typelist;

template<class ...Types>
struct sizeof_typelist< typelist<Types...> >
{
   static const std::size_t value = sizeof...(Types);
};


template<class Typelist, class Indexes>
struct invert_typelist_impl;


template<class Typelist, std::size_t ...Ints>
struct invert_typelist_impl< Typelist, index_tuple<Ints...> >
{
   static const std::size_t last_idx = sizeof_typelist<Typelist>::value - 1;
   typedef typelist
      <typename typelist_element<last_idx - Ints, Typelist>::type...> type;
};

template<class Typelist, std::size_t Int>
struct invert_typelist_impl< Typelist, index_tuple<Int> >
{
   typedef Typelist type;
};

template<class Typelist>
struct invert_typelist_impl< Typelist, index_tuple<> >
{
   typedef Typelist type;
};


template<class Typelist>
struct invert_typelist;

template<class ...Types>
struct invert_typelist< typelist<Types...> >
{
   typedef typelist<Types...> typelist_t;
   typedef typename build_number_seq<sizeof...(Types)>::type indexes_t;
   typedef typename invert_typelist_impl<typelist_t, indexes_t>::type type;
};


template<class Typelist>
struct do_pack;

template<>
struct do_pack<typelist<> >;

template<class Prev>
struct do_pack<typelist<Prev> >
{
   typedef Prev type;
};

template<class Prev, class Last>
struct do_pack<typelist<Prev, Last> >
{
   typedef typename Prev::template pack<Last> type;
};

template<class ...Others>
struct do_pack<typelist<void, Others...> >
{
   typedef typename do_pack<typelist<Others...> >::type type;
};

template<class Prev, class ...Others>
struct do_pack<typelist<Prev, Others...> >
{
   typedef typename Prev::template pack
      <typename do_pack<typelist<Others...> >::type> type;
};


template<class DefaultOptions, class ...Options>
struct pack_options
{
   typedef typelist<DefaultOptions, Options...> typelist_t;
   typedef typename invert_typelist<typelist_t>::type inverted_typelist;
   typedef typename do_pack<inverted_typelist>::type type;
};
# 379 "/usr/include/boost/intrusive/pack_options.hpp" 3 4
}
}

# 1 "/usr/include/boost/intrusive/detail/config_end.hpp" 1 3 4
# 383 "/usr/include/boost/intrusive/pack_options.hpp" 2 3 4
# 20 "/usr/include/boost/intrusive/options.hpp" 2 3 4





namespace boost {
namespace intrusive {



struct empty
{};

template<class Functor>
struct fhtraits;

template<class T, class Hook, Hook T::* P>
struct mhtraits;

struct dft_tag;
struct member_tag;

template<class SupposedValueTraits>
struct is_default_hook_tag;






template< bool Enabled> struct constant_time_size { static const bool value = Enabled; template<class Base> struct pack : Base { static const bool constant_time_size = Enabled; }; };


template< class HeaderHolder> struct header_holder_type { template<class Base> struct pack : Base { typedef HeaderHolder header_holder_type; }; };



template< class SizeType> struct size_type { template<class Base> struct pack : Base { typedef SizeType size_type; }; };



template< class Compare> struct compare { template<class Base> struct pack : Base { typedef Compare compare; }; };
# 70 "/usr/include/boost/intrusive/options.hpp" 3 4
template< class KeyOfValue> struct key_of_value { template<class Base> struct pack : Base { typedef KeyOfValue key_of_value; }; };
# 79 "/usr/include/boost/intrusive/options.hpp" 3 4
template< class PrioOfValue> struct priority_of_value { template<class Base> struct pack : Base { typedef PrioOfValue priority_of_value; }; };
# 93 "/usr/include/boost/intrusive/options.hpp" 3 4
template< bool Enabled> struct floating_point { static const bool value = Enabled; template<class Base> struct pack : Base { static const bool floating_point = Enabled; }; };



template< class Equal> struct equal { template<class Base> struct pack : Base { typedef Equal equal; }; };



template< class Priority> struct priority { template<class Base> struct pack : Base { typedef Priority priority; }; };



template< class Hash> struct hash { template<class Base> struct pack : Base { typedef Hash hash; }; };




template< class ValueTraits> struct value_traits { template<class Base> struct pack : Base { typedef ValueTraits proto_value_traits; }; };
# 129 "/usr/include/boost/intrusive/options.hpp" 3 4
template< typename Parent
        , typename MemberHook
        , MemberHook Parent::* PtrToMember>
struct member_hook
{
# 148 "/usr/include/boost/intrusive/options.hpp" 3 4
   typedef mhtraits <Parent, MemberHook, PtrToMember> member_value_traits;
   template<class Base>
   struct pack : Base
   {
      typedef member_value_traits proto_value_traits;
   };

};




template< class Functor> struct function_hook { template<class Base> struct pack : Base { typedef fhtraits<Functor> proto_value_traits; }; };



template< class BaseHook> struct base_hook { template<class Base> struct pack : Base { typedef BaseHook proto_value_traits; }; };





template< class VoidPointer> struct void_pointer { template<class Base> struct pack : Base { typedef VoidPointer void_pointer; }; };





template< class Tag> struct tag { template<class Base> struct pack : Base { typedef Tag tag; }; };



template< link_mode_type LinkType> struct link_mode { static const link_mode_type value = LinkType; template<class Base> struct pack : Base { static const link_mode_type link_mode = LinkType; }; };



template< bool Enabled> struct optimize_size { static const bool value = Enabled; template<class Base> struct pack : Base { static const bool optimize_size = Enabled; }; };



template< bool Enabled> struct linear { static const bool value = Enabled; template<class Base> struct pack : Base { static const bool linear = Enabled; }; };




template< bool Enabled> struct cache_last { static const bool value = Enabled; template<class Base> struct pack : Base { static const bool cache_last = Enabled; }; };




template< class BucketTraits> struct bucket_traits { template<class Base> struct pack : Base { typedef BucketTraits bucket_traits; }; };






template< bool Enabled> struct store_hash { static const bool value = Enabled; template<class Base> struct pack : Base { static const bool store_hash = Enabled; }; };







template< bool Enabled> struct optimize_multikey { static const bool value = Enabled; template<class Base> struct pack : Base { static const bool optimize_multikey = Enabled; }; };






template< bool Enabled> struct power_2_buckets { static const bool value = Enabled; template<class Base> struct pack : Base { static const bool power_2_buckets = Enabled; }; };
# 229 "/usr/include/boost/intrusive/options.hpp" 3 4
template< bool Enabled> struct fastmod_buckets { static const bool value = Enabled; template<class Base> struct pack : Base { static const bool fastmod_buckets = Enabled; }; };





template< bool Enabled> struct cache_begin { static const bool value = Enabled; template<class Base> struct pack : Base { static const bool cache_begin = Enabled; }; };







template< bool Enabled> struct compare_hash { static const bool value = Enabled; template<class Base> struct pack : Base { static const bool compare_hash = Enabled; }; };







template< bool Enabled> struct incremental { static const bool value = Enabled; template<class Base> struct pack : Base { static const bool incremental = Enabled; }; };




template< bool Enabled> struct linear_buckets { static const bool value = Enabled; template<class Base> struct pack : Base { static const bool linear_buckets = Enabled; }; };



struct hook_defaults
{
   typedef void* void_pointer;
   static const link_mode_type link_mode = safe_link;
   typedef dft_tag tag;
   static const bool optimize_size = false;
   static const bool store_hash = false;
   static const bool linear = false;
   static const bool optimize_multikey = false;
};



}
}

# 1 "/usr/include/boost/intrusive/detail/config_end.hpp" 1 3 4
# 277 "/usr/include/boost/intrusive/options.hpp" 2 3 4
# 23 "/usr/include/boost/intrusive/list_hook.hpp" 2 3 4
# 1 "/usr/include/boost/intrusive/detail/generic_hook.hpp" 1 3 4
# 24 "/usr/include/boost/intrusive/detail/generic_hook.hpp" 3 4
# 1 "/usr/include/boost/intrusive/pointer_traits.hpp" 1 3 4
# 20 "/usr/include/boost/intrusive/pointer_traits.hpp" 3 4
# 1 "/usr/include/boost/intrusive/detail/config_begin.hpp" 1 3 4
# 21 "/usr/include/boost/intrusive/pointer_traits.hpp" 2 3 4


# 1 "/usr/include/boost/move/detail/pointer_element.hpp" 1 3 4
# 23 "/usr/include/boost/move/detail/pointer_element.hpp" 3 4
# 1 "/usr/include/boost/move/detail/workaround.hpp" 1 3 4
# 71 "/usr/include/boost/move/detail/workaround.hpp" 3 4
namespace boost {
namespace movelib {

template <typename T1>
inline __attribute__ ((__always_inline__)) constexpr void ignore(T1 const&)
{}

}}
# 24 "/usr/include/boost/move/detail/pointer_element.hpp" 2 3 4


namespace boost {
namespace movelib {
namespace detail{





template <typename T> struct first_param
{ typedef void type; };



   template <template <typename, typename...> class TemplateClass, typename T, typename... Args>
   struct first_param< TemplateClass<T, Args...> >
   {
      typedef T type;
   };
# 129 "/usr/include/boost/move/detail/pointer_element.hpp" 3 4
template <typename T>
struct has_internal_pointer_element
{
   template <typename X>
   static char test(int, typename X::element_type*);

   template <typename X>
   static int test(...);

   static const bool value = (1 == sizeof(test<T>(0, 0)));
};

template<class Ptr, bool = has_internal_pointer_element<Ptr>::value>
struct pointer_element_impl
{
   typedef typename Ptr::element_type type;
};

template<class Ptr>
struct pointer_element_impl<Ptr, false>
{
   typedef typename boost::movelib::detail::first_param<Ptr>::type type;
};

}

template <typename Ptr>
struct pointer_element
{
   typedef typename ::boost::movelib::detail::pointer_element_impl<Ptr>::type type;
};

template <typename T>
struct pointer_element<T*>
{ typedef T type; };

}
}
# 24 "/usr/include/boost/intrusive/pointer_traits.hpp" 2 3 4
# 1 "/usr/include/boost/intrusive/detail/mpl.hpp" 1 3 4
# 25 "/usr/include/boost/intrusive/detail/mpl.hpp" 3 4
# 1 "/usr/include/boost/intrusive/detail/config_begin.hpp" 1 3 4
# 26 "/usr/include/boost/intrusive/detail/mpl.hpp" 2 3 4
# 1 "/usr/include/boost/move/detail/type_traits.hpp" 1 3 4
# 27 "/usr/include/boost/move/detail/type_traits.hpp" 3 4
# 1 "/usr/include/boost/move/detail/config_begin.hpp" 1 3 4
# 28 "/usr/include/boost/move/detail/type_traits.hpp" 2 3 4



# 1 "/usr/include/boost/move/detail/meta_utils.hpp" 1 3 4
# 20 "/usr/include/boost/move/detail/meta_utils.hpp" 3 4
# 1 "/usr/include/boost/move/detail/config_begin.hpp" 1 3 4
# 21 "/usr/include/boost/move/detail/meta_utils.hpp" 2 3 4

# 1 "/usr/include/boost/move/detail/meta_utils_core.hpp" 1 3 4
# 27 "/usr/include/boost/move/detail/meta_utils_core.hpp" 3 4
namespace boost {
namespace move_detail {

template<typename T>
struct voider { typedef void type; };




template<bool C, typename T1, typename T2>
struct if_c
{
   typedef T1 type;
};

template<typename T1, typename T2>
struct if_c<false,T1,T2>
{
   typedef T2 type;
};




template<typename T1, typename T2, typename T3>
struct if_ : if_c<0 != T1::value, T2, T3>
{};




struct enable_if_nat{};

template <bool B, class T = enable_if_nat>
struct enable_if_c
{
   typedef T type;
};

template <class T>
struct enable_if_c<false, T> {};




template <class Cond, class T = enable_if_nat>
struct enable_if : enable_if_c<Cond::value, T> {};




template <bool B, class T = enable_if_nat>
struct disable_if_c
   : enable_if_c<!B, T>
{};




template <class Cond, class T = enable_if_nat>
struct disable_if : enable_if_c<!Cond::value, T> {};




template<class T, T v>
struct integral_constant
{
   static const T value = v;
   typedef T value_type;
   typedef integral_constant<T, v> type;

     operator T() const { return value; }
   T operator()() const { return value; }
};

typedef integral_constant<bool, true > true_type;
typedef integral_constant<bool, false > false_type;





template<class T, class U>
struct is_same
{
   static const bool value = false;
};

template<class T>
struct is_same<T, T>
{
   static const bool value = true;
};




template <class T, class U, class R = enable_if_nat>
struct enable_if_same : enable_if<is_same<T, U>, R> {};




template <class T, class U, class R = enable_if_nat>
struct disable_if_same : disable_if<is_same<T, U>, R> {};

}
}
# 23 "/usr/include/boost/move/detail/meta_utils.hpp" 2 3 4

# 1 "/usr/include/boost/move/detail/addressof.hpp" 1 3 4
# 23 "/usr/include/boost/move/detail/addressof.hpp" 3 4
namespace boost {
namespace move_detail {
# 38 "/usr/include/boost/move/detail/addressof.hpp" 3 4
template<class T>
inline __attribute__ ((__always_inline__)) T *addressof( T & v ) noexcept
{
   return __builtin_addressof(v);
}
# 58 "/usr/include/boost/move/detail/addressof.hpp" 3 4
}
}
# 25 "/usr/include/boost/move/detail/meta_utils.hpp" 2 3 4



namespace boost {


template <class T> class rv;

namespace move_detail {




template<class T, class U>
struct is_different
{
   static const bool value = !is_same<T, U>::value;
};




template<class F, class Param>
struct apply
{
   typedef typename F::template apply<Param>::type type;
};





template< bool C_ >
struct bool_ : integral_constant<bool, C_>
{
   inline __attribute__ ((__always_inline__)) operator bool() const { return C_; }
   inline __attribute__ ((__always_inline__)) bool operator()() const { return C_; }
};

typedef bool_<true> true_;
typedef bool_<false> false_;




struct nat{};
struct nat2{};
struct nat3{};

template <unsigned N>
struct natN
{};




typedef char yes_type;

struct no_type
{
   char _[2];
};




template <class T> struct natify{};




template<class T>
struct remove_reference
{
   typedef T type;
};

template<class T>
struct remove_reference<T&>
{
   typedef T type;
};



template<class T>
struct remove_reference<T&&>
{
   typedef T type;
};
# 142 "/usr/include/boost/move/detail/meta_utils.hpp" 3 4
template< class T > struct remove_pointer { typedef T type; };
template< class T > struct remove_pointer<T*> { typedef T type; };
template< class T > struct remove_pointer<T* const> { typedef T type; };
template< class T > struct remove_pointer<T* volatile> { typedef T type; };
template< class T > struct remove_pointer<T* const volatile> { typedef T type; };




template< class T >
struct add_pointer
{
   typedef typename remove_reference<T>::type* type;
};




template<class T>
struct add_const
{
   typedef const T type;
};

template<class T>
struct add_const<T&>
{
   typedef const T& type;
};



template<class T>
struct add_const<T&&>
{
   typedef T&& type;
};






template<class T>
struct add_lvalue_reference
{ typedef T& type; };

template<class T> struct add_lvalue_reference<T&> { typedef T& type; };
template<> struct add_lvalue_reference<void> { typedef void type; };
template<> struct add_lvalue_reference<const void> { typedef const void type; };
template<> struct add_lvalue_reference<volatile void> { typedef volatile void type; };
template<> struct add_lvalue_reference<const volatile void>{ typedef const volatile void type; };

template<class T>
struct add_const_lvalue_reference
{
   typedef typename remove_reference<T>::type t_unreferenced;
   typedef typename add_const<t_unreferenced>::type t_unreferenced_const;
   typedef typename add_lvalue_reference
      <t_unreferenced_const>::type type;
};




template<class T>
struct is_lvalue_reference
{
    static const bool value = false;
};

template<class T>
struct is_lvalue_reference<T&>
{
    static const bool value = true;
};





template <class T>
struct identity
{
   typedef T type;
   typedef typename add_const_lvalue_reference<T>::type reference;
   inline __attribute__ ((__always_inline__)) reference operator()(reference t) const
   { return t; }
};




template<class T>
struct is_class_or_union
{
   struct twochar { char dummy[2]; };
   template <class U>
   static char is_class_or_union_tester(void(U::*)(void));
   template <class U>
   static twochar is_class_or_union_tester(...);
   static const bool value = sizeof(is_class_or_union_tester<T>(0)) == sizeof(char);
};
# 254 "/usr/include/boost/move/detail/meta_utils.hpp" 3 4
template <class T>
struct has_pointer_type
{
   struct two { char c[2]; };
   template <class U> static two test(...);
   template <class U> static char test(typename U::pointer* = 0);
   static const bool value = sizeof(test<T>(0)) == 1;
};
# 278 "/usr/include/boost/move/detail/meta_utils.hpp" 3 4
template <class T, class U>
class is_convertible
{
   typedef typename add_lvalue_reference<T>::type t_reference;
   typedef char true_t;
   class false_t { char dummy[2]; };
   static false_t dispatch(...);
   static true_t dispatch(U);
   static t_reference trigger();
   public:
   static const bool value = sizeof(dispatch(trigger())) == sizeof(true_t);
};



template <class T, class U, bool IsSame = is_same<T, U>::value>
struct is_same_or_convertible
   : is_convertible<T, U>
{};

template <class T, class U>
struct is_same_or_convertible<T, U, true>
{
   static const bool value = true;
};

template<
      bool C
    , typename F1
    , typename F2
    >
struct eval_if_c
    : if_c<C,F1,F2>::type
{};

template<
      typename C
    , typename T1
    , typename T2
    >
struct eval_if
    : if_<C,T1,T2>::type
{};






template<class T, class U, class R = void>
struct enable_if_convertible
   : enable_if< is_convertible<T, U>, R>
{};

template<class T, class U, class R = void>
struct disable_if_convertible
   : disable_if< is_convertible<T, U>, R>
{};

template<class T, class U, class R = void>
struct enable_if_same_or_convertible
   : enable_if< is_same_or_convertible<T, U>, R>
{};

template<class T, class U, class R = void>
struct disable_if_same_or_convertible
   : disable_if< is_same_or_convertible<T, U>, R>
{};






template<bool, class B = true_, class C = true_, class D = true_>
struct and_impl
   : and_impl<B::value, C, D>
{};

template<>
struct and_impl<true, true_, true_, true_>
{
   static const bool value = true;
};

template<class B, class C, class D>
struct and_impl<false, B, C, D>
{
   static const bool value = false;
};

template<class A, class B, class C = true_, class D = true_>
struct and_
   : and_impl<A::value, B, C, D>
{};






template<bool, class B = false_, class C = false_, class D = false_>
struct or_impl
   : or_impl<B::value, C, D>
{};

template<>
struct or_impl<false, false_, false_, false_>
{
   static const bool value = false;
};

template<class B, class C, class D>
struct or_impl<true, B, C, D>
{
   static const bool value = true;
};

template<class A, class B, class C = false_, class D = false_>
struct or_
   : or_impl<A::value, B, C, D>
{};






template<class T>
struct not_
{
   static const bool value = !T::value;
};







template<class R, class A, class B, class C = true_, class D = true_>
struct enable_if_and
   : enable_if_c< and_<A, B, C, D>::value, R>
{};

template<class R, class A, class B, class C = true_, class D = true_>
struct disable_if_and
   : disable_if_c< and_<A, B, C, D>::value, R>
{};

template<class R, class A, class B, class C = false_, class D = false_>
struct enable_if_or
   : enable_if_c< or_<A, B, C, D>::value, R>
{};

template<class R, class A, class B, class C = false_, class D = false_>
struct disable_if_or
   : disable_if_c< or_<A, B, C, D>::value, R>
{};






template<class T>
struct has_move_emulation_enabled_impl
   : is_convertible< T, ::boost::rv<T>& >
{};

template<class T>
struct has_move_emulation_enabled_impl<T&>
{ static const bool value = false; };

template<class T>
struct has_move_emulation_enabled_impl< ::boost::rv<T> >
{ static const bool value = false; };







template <class T>
struct is_rv_impl
{ static const bool value = false; };

template <class T>
struct is_rv_impl< rv<T> >
{ static const bool value = true; };

template <class T>
struct is_rv_impl< const rv<T> >
{ static const bool value = true; };



template< class T >
struct is_rvalue_reference
{ static const bool value = false; };



template< class T >
struct is_rvalue_reference< T&& >
{ static const bool value = true; };
# 500 "/usr/include/boost/move/detail/meta_utils.hpp" 3 4
template< class T >
struct add_rvalue_reference
{ typedef T&& type; };
# 531 "/usr/include/boost/move/detail/meta_utils.hpp" 3 4
template< class T > struct remove_rvalue_reference { typedef T type; };


   template< class T > struct remove_rvalue_reference< T&& > { typedef T type; };
# 558 "/usr/include/boost/move/detail/meta_utils.hpp" 3 4
}
}

# 1 "/usr/include/boost/move/detail/config_end.hpp" 1 3 4
# 562 "/usr/include/boost/move/detail/meta_utils.hpp" 2 3 4
# 32 "/usr/include/boost/move/detail/type_traits.hpp" 2 3 4

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 1 3 4
# 42 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 3


# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 45 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 2 3
# 34 "/usr/include/boost/move/detail/type_traits.hpp" 2 3 4
# 482 "/usr/include/boost/move/detail/type_traits.hpp" 3 4
namespace boost {
namespace move_detail {




template<class T>
struct is_reference
{ static const bool value = false; };

template<class T>
struct is_reference<T&>
{ static const bool value = true; };


template<class T>
struct is_reference<T&&>
{ static const bool value = true; };





template<class T>
struct is_pointer
{ static const bool value = false; };

template<class T>
struct is_pointer<T*>
{ static const bool value = true; };




template<class T>
struct is_const
{ static const bool value = false; };

template<class T>
struct is_const<const T>
{ static const bool value = true; };




template <typename T> struct unvoid_ref : add_lvalue_reference<T>{};
template <> struct unvoid_ref<void> { typedef unvoid_ref & type; };
template <> struct unvoid_ref<const void> { typedef unvoid_ref & type; };
template <> struct unvoid_ref<volatile void> { typedef unvoid_ref & type; };
template <> struct unvoid_ref<const volatile void> { typedef unvoid_ref & type; };

template <typename T>
struct add_reference : add_lvalue_reference<T>
{};




template <class T>
struct add_const_reference
{ typedef const T &type; };

template <class T>
struct add_const_reference<T&>
{ typedef T& type; };




template<class T, bool Add>
struct add_const_if_c
   : if_c<Add, typename add_const<T>::type, T>
{};




template<class T>
struct remove_const
{ typedef T type; };

template<class T>
struct remove_const< const T>
{ typedef T type; };




template<typename T> struct remove_cv { typedef T type; };
template<typename T> struct remove_cv<const T> { typedef T type; };
template<typename T> struct remove_cv<const volatile T> { typedef T type; };
template<typename T> struct remove_cv<volatile T> { typedef T type; };




template<class T>
struct remove_cvref
   : remove_cv<typename remove_reference<T>::type>
{
};




template <class T>
struct make_unsigned_impl { typedef T type; };
template <> struct make_unsigned_impl<signed char> { typedef unsigned char type; };
template <> struct make_unsigned_impl<signed short> { typedef unsigned short type; };
template <> struct make_unsigned_impl<signed int> { typedef unsigned int type; };
template <> struct make_unsigned_impl<signed long> { typedef unsigned long type; };

template <> struct make_unsigned_impl< ::boost::long_long_type > { typedef ::boost::ulong_long_type type; };


template <class T>
struct make_unsigned
   : make_unsigned_impl<typename remove_cv<T>::type>
{};




template<class T> struct is_floating_point_cv { static const bool value = false; };
template<> struct is_floating_point_cv<float> { static const bool value = true; };
template<> struct is_floating_point_cv<double> { static const bool value = true; };
template<> struct is_floating_point_cv<long double> { static const bool value = true; };

template<class T>
struct is_floating_point
   : is_floating_point_cv<typename remove_cv<T>::type>
{};




template<class T> struct is_integral_cv { static const bool value = false; };
template<> struct is_integral_cv< bool>{ static const bool value = true; };
template<> struct is_integral_cv< char>{ static const bool value = true; };
template<> struct is_integral_cv< unsigned char>{ static const bool value = true; };
template<> struct is_integral_cv< signed char>{ static const bool value = true; };

template<> struct is_integral_cv< char16_t>{ static const bool value = true; };


template<> struct is_integral_cv< char32_t>{ static const bool value = true; };


template<> struct is_integral_cv< wchar_t>{ static const bool value = true; };

template<> struct is_integral_cv< short>{ static const bool value = true; };
template<> struct is_integral_cv< unsigned short>{ static const bool value = true; };
template<> struct is_integral_cv< int>{ static const bool value = true; };
template<> struct is_integral_cv< unsigned int>{ static const bool value = true; };
template<> struct is_integral_cv< long>{ static const bool value = true; };
template<> struct is_integral_cv< unsigned long>{ static const bool value = true; };

template<> struct is_integral_cv< ::boost:: long_long_type>{ static const bool value = true; };
template<> struct is_integral_cv< ::boost::ulong_long_type>{ static const bool value = true; };


template<class T>
struct is_integral
   : public is_integral_cv<typename remove_cv<T>::type>
{};




template <class T>
struct remove_all_extents
{ typedef T type;};

template <class T>
struct remove_all_extents<T[]>
{ typedef typename remove_all_extents<T>::type type; };

template <class T, std::size_t N>
struct remove_all_extents<T[N]>
{ typedef typename remove_all_extents<T>::type type;};




template<class T>
struct is_scalar
{ static const bool value = is_integral<T>::value || is_floating_point<T>::value; };




template<class T>
struct is_void_cv
{ static const bool value = false; };

template<>
struct is_void_cv<void>
{ static const bool value = true; };

template<class T>
struct is_void
   : is_void_cv<typename remove_cv<T>::type>
{};




template<class T>
struct is_array
{ static const bool value = false; };

template<class T>
struct is_array<T[]>
{ static const bool value = true; };

template<class T, std::size_t N>
struct is_array<T[N]>
{ static const bool value = true; };




template <class T> struct is_member_pointer_cv { static const bool value = false; };
template <class T, class U>struct is_member_pointer_cv<T U::*> { static const bool value = true; };

template <class T>
struct is_member_pointer
    : is_member_pointer_cv<typename remove_cv<T>::type>
{};




template <class T>
struct is_nullptr_t_cv
{ static const bool value = false; };


template <>
struct is_nullptr_t_cv

   <decltype(nullptr)>



{ static const bool value = true; };


template <class T>
struct is_nullptr_t
   : is_nullptr_t_cv<typename remove_cv<T>::type>
{};
# 742 "/usr/include/boost/move/detail/type_traits.hpp" 3 4
template <class T>
struct is_reference_convertible_to_pointer
{
   struct twochar { char dummy[2]; };
   template <class U> static char test(U*);
   template <class U> static twochar test(...);
   static T& source();
   static const bool value = sizeof(char) == sizeof(test<T>(source()));
};





template < class T
         , bool Filter = is_class_or_union<T>::value ||
                         is_void<T>::value ||
                         is_reference<T>::value ||
                         is_nullptr_t<T>::value >
struct is_function_impl
{ static const bool value = is_reference_convertible_to_pointer<T>::value; };

template <class T>
struct is_function_impl<T, true>
{ static const bool value = false; };

template <class T>
struct is_function
   : is_function_impl<T>
{};




template<class T>
struct is_union_noextents_cv
{ static const bool value = __is_union(T); };

template<class T>
struct is_union
   : is_union_noextents_cv<typename remove_cv<typename remove_all_extents<T>::type>::type>
{};




template <class T>
struct is_class
{
   static const bool value = is_class_or_union<T>::value && ! is_union<T>::value;
};





template <class T>
struct is_arithmetic
{
   static const bool value = is_floating_point<T>::value ||
                             is_integral<T>::value;
};




template <class T>
struct is_member_function_pointer_cv
{
   static const bool value = false;
};

template <class T, class C>
struct is_member_function_pointer_cv<T C::*>
   : is_function<T>
{};

template <class T>
struct is_member_function_pointer
    : is_member_function_pointer_cv<typename remove_cv<T>::type>
{};
# 844 "/usr/include/boost/move/detail/type_traits.hpp" 3 4
template <class T>
struct is_enum
{ static const bool value = __is_enum(T); };




template<class T>
struct is_pod_noextents_cv
{ static const bool value = (::boost::move_detail::is_scalar<T>::value || ::boost::move_detail::is_void<T>::value || __is_pod(T)); };

template<class T>
struct is_pod
   : is_pod_noextents_cv<typename remove_cv<typename remove_all_extents<T>::type>::type>
{};
# 891 "/usr/include/boost/move/detail/type_traits.hpp" 3 4
template <class T>
struct is_empty
{ static const bool value = __is_empty(T); };


template<class T>
struct has_boost_move_no_copy_constructor_or_assign_type
{
   template <class U>
   static yes_type test(typename U::boost_move_no_copy_constructor_or_assign*);

   template <class U>
   static no_type test(...);

   static const bool value = sizeof(test<T>(0)) == sizeof(yes_type);
};
# 917 "/usr/include/boost/move/detail/type_traits.hpp" 3 4
template<class T>
struct is_copy_constructible
{
# 928 "/usr/include/boost/move/detail/type_traits.hpp" 3 4
      template<class U> static typename add_reference<U>::type source();
      static no_type test(...);




         template <class U>
         static yes_type test(U&, decltype(U(source<U>()))* = 0);

      static const bool value = sizeof(test(source<T>())) == sizeof(yes_type);



};
# 953 "/usr/include/boost/move/detail/type_traits.hpp" 3 4
template <class T>
struct is_copy_assignable
{
# 965 "/usr/include/boost/move/detail/type_traits.hpp" 3 4
   typedef char yes_type;
   struct no_type { char dummy[2]; };

   template <class U> static typename add_reference<U>::type source();
   template <class U> static decltype(source<U&>() = source<const U&>(), yes_type() ) test(int);
   template <class> static no_type test(...);

   static const bool value = sizeof(test<T>(0)) == sizeof(yes_type);



};




template<class T>
struct is_trivially_destructible
{ static const bool value = __is_trivially_destructible(T) || ::boost::move_detail::is_pod<T>::value; };




template<class T>
struct is_trivially_default_constructible
{ static const bool value = __is_trivially_constructible(T) || ::boost::move_detail::is_pod<T>::value; };




template<class T>
struct is_trivially_copy_constructible
{
   static const bool value = ::boost::move_detail::is_pod<T>::value || (::boost::move_detail::is_copy_constructible<T>::value && (__is_constructible(T, const T &) && __is_trivially_constructible(T, const T &)));
};




template<class T>
struct is_trivially_move_constructible
{ static const bool value = (__is_constructible(T, T&&) && __is_trivially_constructible(T, T&&)) || ::boost::move_detail::is_pod<T>::value; };




template<class T>
struct is_trivially_copy_assignable
{
   static const bool value = ::boost::move_detail::is_pod<T>::value || ( ::boost::move_detail::is_copy_assignable<T>::value && (__is_assignable(T, const T &) && __is_trivially_assignable(T, const T &)));
};




template<class T>
struct is_trivially_move_assignable
{ static const bool value = (__is_assignable(T, T&&) && __is_trivially_assignable(T, T&&)) || ::boost::move_detail::is_pod<T>::value; };




template<class T>
struct is_nothrow_default_constructible
{ static const bool value = __is_nothrow_constructible(T) || ::boost::move_detail::is_pod<T>::value; };




template<class T>
struct is_nothrow_copy_constructible
{ static const bool value = (__is_constructible(T, const T &) && __is_nothrow_constructible(T, const T &)) || ::boost::move_detail::is_pod<T>::value; };




template<class T>
struct is_nothrow_move_constructible
{ static const bool value = (__is_constructible(T, T&&) && __is_nothrow_constructible(T, T&&)) || ::boost::move_detail::is_pod<T>::value; };




template<class T>
struct is_nothrow_copy_assignable
{ static const bool value = (__is_assignable(T, const T &) && __is_nothrow_assignable(T, const T &)) || ::boost::move_detail::is_pod<T>::value; };




template<class T>
struct is_nothrow_move_assignable
{ static const bool value = (__is_assignable(T, T&&) && __is_nothrow_assignable(T, T&&)) || ::boost::move_detail::is_pod<T>::value; };




template<class T>
struct is_nothrow_swappable
{
   static const bool value = is_empty<T>::value || is_pod<T>::value;
};




template <typename T>
struct alignment_of_hack
{
   T t1;
   char c;
   T t2;
   alignment_of_hack();
   ~alignment_of_hack();
};

template <unsigned A, unsigned S>
struct alignment_logic
{ static const std::size_t value = A < S ? A : S; };

template< typename T >
struct alignment_of_impl
# 1097 "/usr/include/boost/move/detail/type_traits.hpp" 3 4
{ static const std::size_t value = __alignof(T); };


template< typename T >
struct alignment_of
   : alignment_of_impl<T>
{};

class alignment_dummy;
typedef void (*function_ptr)();
typedef int (alignment_dummy::*member_ptr);

struct alignment_struct
{ long double dummy[4]; };





union max_align
{
   char char_;
   short short_;
   int int_;
   long long_;

   ::boost::long_long_type long_long_;

   float float_;
   double double_;
   void * void_ptr_;
   long double long_double_[4];
   alignment_dummy *unknown_class_ptr_;
   function_ptr function_ptr_;
   alignment_struct alignment_struct_;
};

typedef union max_align max_align_t;
# 1181 "/usr/include/boost/move/detail/type_traits.hpp" 3 4
template<std::size_t Len, std::size_t Align>
struct aligned_struct;
# 1193 "/usr/include/boost/move/detail/type_traits.hpp" 3 4
template<std::size_t Len>struct alignas(0x1) aligned_struct<Len, 0x1>{ unsigned char data[Len];};
template<std::size_t Len>struct alignas(0x2) aligned_struct<Len, 0x2>{ unsigned char data[Len];};
template<std::size_t Len>struct alignas(0x4) aligned_struct<Len, 0x4>{ unsigned char data[Len];};
template<std::size_t Len>struct alignas(0x8) aligned_struct<Len, 0x8>{ unsigned char data[Len];};
template<std::size_t Len>struct alignas(0x10) aligned_struct<Len, 0x10>{ unsigned char data[Len];};
template<std::size_t Len>struct alignas(0x20) aligned_struct<Len, 0x20>{ unsigned char data[Len];};
template<std::size_t Len>struct alignas(0x40) aligned_struct<Len, 0x40>{ unsigned char data[Len];};
template<std::size_t Len>struct alignas(0x80) aligned_struct<Len, 0x80>{ unsigned char data[Len];};
template<std::size_t Len>struct alignas(0x100) aligned_struct<Len, 0x100>{ unsigned char data[Len];};
template<std::size_t Len>struct alignas(0x200) aligned_struct<Len, 0x200>{ unsigned char data[Len];};
template<std::size_t Len>struct alignas(0x400) aligned_struct<Len, 0x400>{ unsigned char data[Len];};
template<std::size_t Len>struct alignas(0x800) aligned_struct<Len, 0x800>{ unsigned char data[Len];};
template<std::size_t Len>struct alignas(0x1000) aligned_struct<Len, 0x1000>{ unsigned char data[Len];};





template<std::size_t Len, std::size_t Align>
union aligned_struct_wrapper
{
   typedef aligned_struct<Len, Align> aligner_t;
   aligned_struct<Len, Align> aligner;
   unsigned char data[Len > sizeof(aligner_t) ? Len : sizeof(aligner_t)];
};

template<std::size_t Len, std::size_t Align>
struct aligned_storage_impl
{
   typedef aligned_struct_wrapper<Len, Align> type;
};
# 1276 "/usr/include/boost/move/detail/type_traits.hpp" 3 4
template<std::size_t Len, std::size_t Align = alignment_of<max_align_t>::value>
struct aligned_storage
{

   static_assert(Align > 0, "Align > 0");


   typedef typename aligned_storage_impl<Len ? Len : 1, Align>::type type;
   static const std::size_t value = alignment_of<type>::value;
   static_assert(value >= Align, "value >= Align");
   static_assert((value % Align) == 0, "(value % Align) == 0");



   private:
   aligned_storage();
};

}
}

# 1 "/usr/include/boost/move/detail/config_end.hpp" 1 3 4
# 1298 "/usr/include/boost/move/detail/type_traits.hpp" 2 3 4
# 27 "/usr/include/boost/intrusive/detail/mpl.hpp" 2 3 4


namespace boost {
namespace intrusive {
namespace detail {

using boost::move_detail::is_same;
using boost::move_detail::add_const;
using boost::move_detail::remove_const;
using boost::move_detail::remove_cv;
using boost::move_detail::remove_reference;
using boost::move_detail::add_reference;
using boost::move_detail::remove_pointer;
using boost::move_detail::add_pointer;
using boost::move_detail::true_type;
using boost::move_detail::false_type;
using boost::move_detail::voider;
using boost::move_detail::enable_if_c;
using boost::move_detail::enable_if;
using boost::move_detail::disable_if_c;
using boost::move_detail::disable_if;
using boost::move_detail::is_convertible;
using boost::move_detail::if_c;
using boost::move_detail::if_;
using boost::move_detail::is_const;
using boost::move_detail::identity;
using boost::move_detail::alignment_of;
using boost::move_detail::is_empty;
using boost::move_detail::addressof;
using boost::move_detail::integral_constant;
using boost::move_detail::enable_if_convertible;
using boost::move_detail::disable_if_convertible;
using boost::move_detail::bool_;
using boost::move_detail::true_;
using boost::move_detail::false_;
using boost::move_detail::yes_type;
using boost::move_detail::no_type;
using boost::move_detail::apply;
using boost::move_detail::eval_if_c;
using boost::move_detail::eval_if;
using boost::move_detail::unvoid_ref;
using boost::move_detail::add_const_if_c;

template<std::size_t S>
struct ls_zeros
{
   static const std::size_t value = (S & std::size_t(1)) ? 0 : (1 + ls_zeros<(S>>1u)>::value);
};

template<>
struct ls_zeros<0>
{
   static const std::size_t value = 0;
};

template<>
struct ls_zeros<1>
{
   static const std::size_t value = 0;
};
# 211 "/usr/include/boost/intrusive/detail/mpl.hpp" 3 4
}
}
}

# 1 "/usr/include/boost/intrusive/detail/config_end.hpp" 1 3 4
# 216 "/usr/include/boost/intrusive/detail/mpl.hpp" 2 3 4
# 25 "/usr/include/boost/intrusive/pointer_traits.hpp" 2 3 4






namespace boost {
namespace intrusive {
namespace detail {


template <typename U, typename Signature> class has_member_function_callable_with_pointer_to { private: template<Signature> struct helper; template<typename T> static ::boost::intrusive::detail::yes_type test(helper<&T::pointer_to>*); template<typename T> static ::boost::intrusive::detail::no_type test(...); public: static const bool value = sizeof(test<U>(0)) == sizeof(::boost::intrusive::detail::yes_type); };
template <typename U, typename Signature> class has_member_function_callable_with_dynamic_cast_from { private: template<Signature> struct helper; template<typename T> static ::boost::intrusive::detail::yes_type test(helper<&T::dynamic_cast_from>*); template<typename T> static ::boost::intrusive::detail::no_type test(...); public: static const bool value = sizeof(test<U>(0)) == sizeof(::boost::intrusive::detail::yes_type); };
template <typename U, typename Signature> class has_member_function_callable_with_static_cast_from { private: template<Signature> struct helper; template<typename T> static ::boost::intrusive::detail::yes_type test(helper<&T::static_cast_from>*); template<typename T> static ::boost::intrusive::detail::no_type test(...); public: static const bool value = sizeof(test<U>(0)) == sizeof(::boost::intrusive::detail::yes_type); };
template <typename U, typename Signature> class has_member_function_callable_with_const_cast_from { private: template<Signature> struct helper; template<typename T> static ::boost::intrusive::detail::yes_type test(helper<&T::const_cast_from>*); template<typename T> static ::boost::intrusive::detail::no_type test(...); public: static const bool value = sizeof(test<U>(0)) == sizeof(::boost::intrusive::detail::yes_type); };







template <typename T, typename DefaultType> struct boost_intrusive_eval_default_type_element_type { template <typename X> static char test(int, typename X::element_type*); template <typename X> static int test(...); struct DefaultWrap { typedef typename DefaultType::type element_type; }; static const bool value = (1 == sizeof(test<T>(0, 0))); typedef typename ::boost::intrusive::detail::eval_if_c < value , ::boost::intrusive::detail::identity<T> , ::boost::intrusive::detail::identity<DefaultWrap> >::type::element_type type; };
template <typename T> struct boost_intrusive_has_type_difference_type { template <typename X> static char test(int, typename X::difference_type*); template <typename X> static int test(...); static const bool value = (1 == sizeof(test<T>(0, 0))); }; template <typename T, typename DefaultType> struct boost_intrusive_default_type_difference_type { struct DefaultWrap { typedef DefaultType difference_type; }; typedef typename ::boost::intrusive::detail::if_c < boost_intrusive_has_type_difference_type<T>::value , T, DefaultWrap>::type::difference_type type; };
template <typename T> struct boost_intrusive_has_type_size_type { template <typename X> static char test(int, typename X::size_type*); template <typename X> static int test(...); static const bool value = (1 == sizeof(test<T>(0, 0))); }; template <typename T, typename DefaultType> struct boost_intrusive_default_type_size_type { struct DefaultWrap { typedef DefaultType size_type; }; typedef typename ::boost::intrusive::detail::if_c < boost_intrusive_has_type_size_type<T>::value , T, DefaultWrap>::type::size_type type; };
template <typename T> struct boost_intrusive_has_type_reference { template <typename X> static char test(int, typename X::reference*); template <typename X> static int test(...); static const bool value = (1 == sizeof(test<T>(0, 0))); }; template <typename T, typename DefaultType> struct boost_intrusive_default_type_reference { struct DefaultWrap { typedef DefaultType reference; }; typedef typename ::boost::intrusive::detail::if_c < boost_intrusive_has_type_reference<T>::value , T, DefaultWrap>::type::reference type; };
template <typename T> struct boost_intrusive_has_type_value_traits_ptr { template <typename X> static char test(int, typename X::value_traits_ptr*); template <typename X> static int test(...); static const bool value = (1 == sizeof(test<T>(0, 0))); }; template <typename T, typename DefaultType> struct boost_intrusive_default_type_value_traits_ptr { struct DefaultWrap { typedef DefaultType value_traits_ptr; }; typedef typename ::boost::intrusive::detail::if_c < boost_intrusive_has_type_value_traits_ptr<T>::value , T, DefaultWrap>::type::value_traits_ptr type; };

}
# 68 "/usr/include/boost/intrusive/pointer_traits.hpp" 3 4
template <typename Ptr>
struct pointer_traits
{
# 97 "/usr/include/boost/intrusive/pointer_traits.hpp" 3 4
      typedef Ptr pointer;

      typedef typename boost::intrusive::detail:: boost_intrusive_eval_default_type_element_type< Ptr, boost::movelib::detail::first_param<Ptr> >::type element_type;



      typedef typename boost::intrusive::detail:: boost_intrusive_default_type_difference_type< Ptr, std::ptrdiff_t >::type difference_type;


      typedef typename boost::intrusive::detail:: boost_intrusive_default_type_size_type< Ptr, typename boost::move_detail:: make_unsigned<difference_type>::type >::type size_type;




      typedef typename boost::intrusive::detail:: boost_intrusive_default_type_reference< Ptr, typename boost::intrusive::detail::unvoid_ref<element_type>::type >::type reference;



      template <class U> struct rebind_pointer
      {
         typedef typename boost::intrusive::pointer_rebind<Ptr, U>::type type;
      };


         template <class U> using rebind = typename boost::intrusive::pointer_rebind<Ptr, U>::type;
# 133 "/usr/include/boost/intrusive/pointer_traits.hpp" 3 4
   inline __attribute__ ((__always_inline__)) static pointer pointer_to(reference r) noexcept
   {


      const bool value = boost::intrusive::detail::
         has_member_function_callable_with_pointer_to
            <Ptr, Ptr (*)(reference)>::value;
      boost::intrusive::detail::bool_<value> flag;
      return pointer_traits::priv_pointer_to(flag, r);
   }
# 152 "/usr/include/boost/intrusive/pointer_traits.hpp" 3 4
   template<class UPtr>
   inline __attribute__ ((__always_inline__)) static pointer static_cast_from(const UPtr &uptr) noexcept
   {
      typedef const UPtr &RefArg;
      const bool value = boost::intrusive::detail::
         has_member_function_callable_with_static_cast_from
            <pointer, pointer(*)(RefArg)>::value
         || boost::intrusive::detail::
               has_member_function_callable_with_static_cast_from
                  <pointer, pointer(*)(UPtr)>::value;
      return pointer_traits::priv_static_cast_from(boost::intrusive::detail::bool_<value>(), uptr);
   }
# 173 "/usr/include/boost/intrusive/pointer_traits.hpp" 3 4
   template<class UPtr>
   inline __attribute__ ((__always_inline__)) static pointer const_cast_from(const UPtr &uptr) noexcept
   {
      typedef const UPtr &RefArg;
      const bool value = boost::intrusive::detail::
         has_member_function_callable_with_const_cast_from
            <pointer, pointer(*)(RefArg)>::value
         || boost::intrusive::detail::
               has_member_function_callable_with_const_cast_from
                  <pointer, pointer(*)(UPtr)>::value;
      return pointer_traits::priv_const_cast_from(boost::intrusive::detail::bool_<value>(), uptr);
   }
# 194 "/usr/include/boost/intrusive/pointer_traits.hpp" 3 4
   template<class UPtr>
   inline __attribute__ ((__always_inline__)) static pointer dynamic_cast_from(const UPtr &uptr) noexcept
   {
      typedef const UPtr &RefArg;
      const bool value = boost::intrusive::detail::
         has_member_function_callable_with_dynamic_cast_from
            <pointer, pointer(*)(RefArg)>::value
         || boost::intrusive::detail::
               has_member_function_callable_with_dynamic_cast_from
                  <pointer, pointer(*)(UPtr)>::value;
      return pointer_traits::priv_dynamic_cast_from(boost::intrusive::detail::bool_<value>(), uptr);
   }


   private:

   template <class T>
   inline __attribute__ ((__always_inline__)) static T* to_raw_pointer(T* p) noexcept
   { return p; }

   template <class Pointer>
   inline __attribute__ ((__always_inline__)) static typename pointer_traits<Pointer>::element_type*
      to_raw_pointer(const Pointer &p) noexcept
   { return pointer_traits::to_raw_pointer(p.operator->()); }


   inline __attribute__ ((__always_inline__)) static pointer priv_pointer_to(boost::intrusive::detail::true_, reference r) noexcept
   { return Ptr::pointer_to(r); }

   inline __attribute__ ((__always_inline__)) static pointer priv_pointer_to(boost::intrusive::detail::false_, reference r) noexcept
   { return pointer(boost::intrusive::detail::addressof(r)); }


   template<class UPtr>
   inline __attribute__ ((__always_inline__)) static pointer priv_static_cast_from(boost::intrusive::detail::true_, const UPtr &uptr) noexcept
   { return Ptr::static_cast_from(uptr); }

   template<class UPtr>
   inline __attribute__ ((__always_inline__)) static pointer priv_static_cast_from(boost::intrusive::detail::false_, const UPtr &uptr) noexcept
   { return uptr ? pointer_to(*static_cast<element_type*>(to_raw_pointer(uptr))) : pointer(); }


   template<class UPtr>
   inline __attribute__ ((__always_inline__)) static pointer priv_const_cast_from(boost::intrusive::detail::true_, const UPtr &uptr) noexcept
   { return Ptr::const_cast_from(uptr); }

   template<class UPtr>
   inline __attribute__ ((__always_inline__)) static pointer priv_const_cast_from(boost::intrusive::detail::false_, const UPtr &uptr) noexcept
   { return uptr ? pointer_to(const_cast<element_type&>(*uptr)) : pointer(); }


   template<class UPtr>
   inline __attribute__ ((__always_inline__)) static pointer priv_dynamic_cast_from(boost::intrusive::detail::true_, const UPtr &uptr) noexcept
   { return Ptr::dynamic_cast_from(uptr); }

   template<class UPtr>
   inline __attribute__ ((__always_inline__)) static pointer priv_dynamic_cast_from(boost::intrusive::detail::false_, const UPtr &uptr) noexcept
   { return uptr ? pointer_to(dynamic_cast<element_type&>(*uptr)) : pointer(); }

};




template <typename Ptr>
struct pointer_traits<const Ptr> : pointer_traits<Ptr> {};
template <typename Ptr>
struct pointer_traits<volatile Ptr> : pointer_traits<Ptr> { };
template <typename Ptr>
struct pointer_traits<const volatile Ptr> : pointer_traits<Ptr> { };

template <typename Ptr>
struct pointer_traits<Ptr&> : pointer_traits<Ptr> { };





template <typename T>
struct pointer_traits<T*>
{
   typedef T element_type;
   typedef T* pointer;
   typedef std::ptrdiff_t difference_type;
   typedef std::size_t size_type;
# 288 "/usr/include/boost/intrusive/pointer_traits.hpp" 3 4
      typedef typename boost::intrusive::detail::unvoid_ref<element_type>::type reference;

         template <class U> using rebind = U*;



   template <class U> struct rebind_pointer
   { typedef U* type; };



   inline __attribute__ ((__always_inline__)) static pointer pointer_to(reference r) noexcept
   { return boost::intrusive::detail::addressof(r); }



   template<class U>
   inline __attribute__ ((__always_inline__)) static pointer static_cast_from(U *uptr) noexcept
   { return static_cast<pointer>(uptr); }



   template<class U>
   inline __attribute__ ((__always_inline__)) static pointer const_cast_from(U *uptr) noexcept
   { return const_cast<pointer>(uptr); }



   template<class U>
   inline __attribute__ ((__always_inline__)) static pointer dynamic_cast_from(U *uptr) noexcept
   { return dynamic_cast<pointer>(uptr); }
};

}
}

# 1 "/usr/include/boost/intrusive/detail/config_end.hpp" 1 3 4
# 325 "/usr/include/boost/intrusive/pointer_traits.hpp" 2 3 4
# 25 "/usr/include/boost/intrusive/detail/generic_hook.hpp" 2 3 4



# 1 "/usr/include/boost/intrusive/detail/node_holder.hpp" 1 3 4
# 24 "/usr/include/boost/intrusive/detail/node_holder.hpp" 3 4
namespace boost {
namespace intrusive {

template<class Node, class Tag, unsigned int>
struct node_holder
   : public Node
{};

}
}
# 29 "/usr/include/boost/intrusive/detail/generic_hook.hpp" 2 3 4

# 1 "/usr/include/boost/static_assert.hpp" 1 3 4
# 18 "/usr/include/boost/static_assert.hpp" 3 4
# 1 "/usr/include/boost/detail/workaround.hpp" 1 3 4







# 1 "/usr/include/boost/config/workaround.hpp" 1 3 4
# 9 "/usr/include/boost/detail/workaround.hpp" 2 3 4
# 19 "/usr/include/boost/static_assert.hpp" 2 3 4
# 31 "/usr/include/boost/intrusive/detail/generic_hook.hpp" 2 3 4

namespace boost {
namespace intrusive {



namespace detail {

template <link_mode_type LinkMode>
struct link_dispatch
{};

template<class Hook>
inline __attribute__ ((__always_inline__)) void destructor_impl(Hook &hook, detail::link_dispatch<safe_link>)
{


   (void)hook; (static_cast <bool> (!hook.is_linked()) ? void (0) : __assert_fail ("!hook.is_linked()", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
}

template<class Hook>
inline __attribute__ ((__always_inline__)) void destructor_impl(Hook &hook, detail::link_dispatch<auto_unlink>)
{ hook.unlink(); }

template<class Hook>
inline __attribute__ ((__always_inline__)) void destructor_impl(Hook &, detail::link_dispatch<normal_link>)
{}

}

enum base_hook_type
{ NoBaseHookId
, ListBaseHookId
, SlistBaseHookId
, RbTreeBaseHookId
, HashBaseHookId
, AvlTreeBaseHookId
, BsTreeBaseHookId
, TreapTreeBaseHookId
, AnyBaseHookId
};


template <class HookTags, unsigned int>
struct hook_tags_definer{};

template <class HookTags>
struct hook_tags_definer<HookTags, ListBaseHookId>
{ typedef HookTags default_list_hook; };

template <class HookTags>
struct hook_tags_definer<HookTags, SlistBaseHookId>
{ typedef HookTags default_slist_hook; };

template <class HookTags>
struct hook_tags_definer<HookTags, RbTreeBaseHookId>
{ typedef HookTags default_rbtree_hook; };

template <class HookTags>
struct hook_tags_definer<HookTags, HashBaseHookId>
{ typedef HookTags default_hashtable_hook; };

template <class HookTags>
struct hook_tags_definer<HookTags, AvlTreeBaseHookId>
{ typedef HookTags default_avltree_hook; };

template <class HookTags>
struct hook_tags_definer<HookTags, BsTreeBaseHookId>
{ typedef HookTags default_bstree_hook; };

template <class HookTags>
struct hook_tags_definer<HookTags, AnyBaseHookId>
{ typedef HookTags default_any_hook; };

template
   < class NodeTraits
   , class Tag
   , link_mode_type LinkMode
   , base_hook_type BaseHookType
   >
struct hooktags_impl
{
   static const link_mode_type link_mode = LinkMode;
   typedef Tag tag;
   typedef NodeTraits node_traits;
   static const bool is_base_hook = !detail::is_same<Tag, member_tag>::value;
   static const bool safemode_or_autounlink = is_safe_autounlink<link_mode>::value;
   static const unsigned int type = BaseHookType;
};



template
   < boost::intrusive::algo_types Algo
   , class NodeTraits
   , class Tag
   , link_mode_type LinkMode
   , base_hook_type BaseHookType
   >
class generic_hook







   : public detail::if_c
      < detail::is_same<Tag, member_tag>::value
      , typename NodeTraits::node
      , node_holder<typename NodeTraits::node, Tag, BaseHookType>
      >::type




   , public hook_tags_definer
      < generic_hook<Algo, NodeTraits, Tag, LinkMode, BaseHookType>
      , detail::is_same<Tag, dft_tag>::value ? BaseHookType : NoBaseHookId>

{

   typedef typename get_algo<Algo, NodeTraits>::type node_algorithms;
   typedef typename node_algorithms::node node;
   typedef typename node_algorithms::node_ptr node_ptr;
   typedef typename node_algorithms::const_node_ptr const_node_ptr;

   public:

   typedef hooktags_impl
      < NodeTraits
      , Tag, LinkMode, BaseHookType> hooktags;

   inline __attribute__ ((__always_inline__)) node_ptr this_ptr() noexcept
   { return pointer_traits<node_ptr>::pointer_to(static_cast<node&>(*this)); }

   inline __attribute__ ((__always_inline__)) const_node_ptr this_ptr() const noexcept
   { return pointer_traits<const_node_ptr>::pointer_to(static_cast<const node&>(*this)); }

   public:


   inline __attribute__ ((__always_inline__)) generic_hook() noexcept
   {
      if(hooktags::safemode_or_autounlink){
         node_algorithms::init(this->this_ptr());
      }
   }

   inline __attribute__ ((__always_inline__)) generic_hook(const generic_hook& ) noexcept
   {
      if(hooktags::safemode_or_autounlink){
         node_algorithms::init(this->this_ptr());
      }
   }

   inline __attribute__ ((__always_inline__)) generic_hook& operator=(const generic_hook& ) noexcept
   { return *this; }

   inline __attribute__ ((__always_inline__)) ~generic_hook()
   {
      destructor_impl
         (*this, detail::link_dispatch<hooktags::link_mode>());
   }

   inline __attribute__ ((__always_inline__)) void swap_nodes(generic_hook &other) noexcept
   {
      node_algorithms::swap_nodes
         (this->this_ptr(), other.this_ptr());
   }

   inline __attribute__ ((__always_inline__)) bool is_linked() const noexcept
   {

      static_assert(( hooktags::safemode_or_autounlink ), "( hooktags::safemode_or_autounlink )");
      return !node_algorithms::unique(this->this_ptr());
   }

   inline __attribute__ ((__always_inline__)) void unlink() noexcept
   {
      static_assert(( (int)hooktags::link_mode == (int)auto_unlink ), "( (int)hooktags::link_mode == (int)auto_unlink )");
      node_ptr n(this->this_ptr());
      if(!node_algorithms::inited(n)){
         node_algorithms::unlink(n);
         node_algorithms::init(n);
      }
   }
};

}
}
# 24 "/usr/include/boost/intrusive/list_hook.hpp" 2 3 4






namespace boost {
namespace intrusive {




template<class ...Options>



struct make_list_base_hook
{

   typedef typename pack_options
      < hook_defaults,



      Options...

      >::type packed_options;

   typedef generic_hook
   < CircularListAlgorithms
   , list_node_traits<typename packed_options::void_pointer>
   , typename packed_options::tag
   , packed_options::link_mode
   , ListBaseHookId
   > implementation_defined;

   typedef implementation_defined type;
};
# 80 "/usr/include/boost/intrusive/list_hook.hpp" 3 4
template<class ...Options>



class list_base_hook
   : public make_list_base_hook



      <Options...>

      ::type
{
# 159 "/usr/include/boost/intrusive/list_hook.hpp" 3 4
};




template<class ...Options>



struct make_list_member_hook
{

   typedef typename pack_options
      < hook_defaults,



      Options...

      >::type packed_options;

   typedef generic_hook
   < CircularListAlgorithms
   , list_node_traits<typename packed_options::void_pointer>
   , member_tag
   , packed_options::link_mode
   , NoBaseHookId
   > implementation_defined;

   typedef implementation_defined type;
};
# 203 "/usr/include/boost/intrusive/list_hook.hpp" 3 4
template<class ...Options>



class list_member_hook
   : public make_list_member_hook



      <Options...>

      ::type
{
# 282 "/usr/include/boost/intrusive/list_hook.hpp" 3 4
};

}
}

# 1 "/usr/include/boost/intrusive/detail/config_end.hpp" 1 3 4
# 288 "/usr/include/boost/intrusive/list_hook.hpp" 2 3 4
# 21 "/usr/include/boost/intrusive/list.hpp" 2 3 4




# 1 "/usr/include/boost/intrusive/detail/get_value_traits.hpp" 1 3 4
# 24 "/usr/include/boost/intrusive/detail/get_value_traits.hpp" 3 4
# 1 "/usr/include/boost/intrusive/detail/config_begin.hpp" 1 3 4
# 25 "/usr/include/boost/intrusive/detail/get_value_traits.hpp" 2 3 4

# 1 "/usr/include/boost/intrusive/detail/hook_traits.hpp" 1 3 4
# 26 "/usr/include/boost/intrusive/detail/hook_traits.hpp" 3 4
# 1 "/usr/include/boost/intrusive/detail/parent_from_member.hpp" 1 3 4
# 23 "/usr/include/boost/intrusive/detail/parent_from_member.hpp" 3 4
# 1 "/usr/include/boost/intrusive/detail/config_begin.hpp" 1 3 4
# 24 "/usr/include/boost/intrusive/detail/parent_from_member.hpp" 2 3 4








namespace boost {
namespace intrusive {
namespace detail {

template<class Parent, class Member>
inline __attribute__ ((__always_inline__)) std::ptrdiff_t offset_from_pointer_to_member(const Member Parent::* ptr_to_member)
{
# 76 "/usr/include/boost/intrusive/detail/parent_from_member.hpp" 3 4
   const Parent * const parent = 0;
   const char *const member = static_cast<const char*>(static_cast<const void*>(&(parent->*ptr_to_member)));
   return std::ptrdiff_t(member - static_cast<const char*>(static_cast<const void*>(parent)));
# 89 "/usr/include/boost/intrusive/detail/parent_from_member.hpp" 3 4
}

template<class Parent, class Member>
inline __attribute__ ((__always_inline__)) Parent *parent_from_member(Member *member, const Member Parent::* ptr_to_member)
{
   return static_cast<Parent*>
      (
         static_cast<void*>
         (
            static_cast<char*>(static_cast<void*>(member)) - offset_from_pointer_to_member(ptr_to_member)
         )
      );
}

template<class Parent, class Member>
inline __attribute__ ((__always_inline__)) const Parent *parent_from_member(const Member *member, const Member Parent::* ptr_to_member)
{
   return static_cast<const Parent*>
      (
         static_cast<const void*>
         (
            static_cast<const char*>(static_cast<const void*>(member)) - offset_from_pointer_to_member(ptr_to_member)
         )
      );
}

}
}
}

# 1 "/usr/include/boost/intrusive/detail/config_end.hpp" 1 3 4
# 120 "/usr/include/boost/intrusive/detail/parent_from_member.hpp" 2 3 4
# 27 "/usr/include/boost/intrusive/detail/hook_traits.hpp" 2 3 4


# 1 "/usr/include/boost/move/detail/to_raw_pointer.hpp" 1 3 4
# 24 "/usr/include/boost/move/detail/to_raw_pointer.hpp" 3 4
# 1 "/usr/include/boost/move/detail/config_begin.hpp" 1 3 4
# 25 "/usr/include/boost/move/detail/to_raw_pointer.hpp" 2 3 4



namespace boost {
namespace movelib {

template <class T>
inline __attribute__ ((__always_inline__)) T* to_raw_pointer(T* p)
{ return p; }

template <class Pointer>
inline __attribute__ ((__always_inline__)) typename boost::movelib::pointer_element<Pointer>::type*
to_raw_pointer(const Pointer &p)
{ return ::boost::movelib::to_raw_pointer(p.operator->()); }

}
}

# 1 "/usr/include/boost/move/detail/config_end.hpp" 1 3 4
# 44 "/usr/include/boost/move/detail/to_raw_pointer.hpp" 2 3 4
# 30 "/usr/include/boost/intrusive/detail/hook_traits.hpp" 2 3 4

# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 58 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 59 "/usr/include/boost/assert.hpp" 2 3 4
# 32 "/usr/include/boost/intrusive/detail/hook_traits.hpp" 2 3 4

namespace boost {
namespace intrusive {

template<class T, class NodePtr, class Tag, unsigned int Type>
struct bhtraits_base
{
   public:
   typedef NodePtr node_ptr;
   typedef typename pointer_traits<node_ptr>::element_type node;
   typedef node_holder<node, Tag, Type> node_holder_type;
   typedef T value_type;
   typedef typename pointer_traits<node_ptr>::
      template rebind_pointer<const node>::type const_node_ptr;
   typedef typename pointer_traits<node_ptr>::
      template rebind_pointer<T>::type pointer;
   typedef typename pointer_traits<node_ptr>::
      template rebind_pointer<const T>::type const_pointer;


   typedef T & reference;
   typedef const T & const_reference;
   typedef node_holder_type & node_holder_reference;
   typedef const node_holder_type & const_node_holder_reference;
   typedef node& node_reference;
   typedef const node & const_node_reference;

   inline __attribute__ ((__always_inline__)) static pointer to_value_ptr(node_ptr n)
   {
      pointer p = pointer_traits<pointer>::pointer_to
         (static_cast<reference>(static_cast<node_holder_reference>(*n)));
      (static_cast <bool> (!!p) ? void (0) : __assert_fail ("!!p", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      return p;
   }

   inline __attribute__ ((__always_inline__)) static const_pointer to_value_ptr(const_node_ptr n)
   {
      const_pointer p = pointer_traits<const_pointer>::pointer_to
         (static_cast<const_reference>(static_cast<const_node_holder_reference>(*n)));
      (static_cast <bool> (!!p) ? void (0) : __assert_fail ("!!p", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      return p;
   }

   inline __attribute__ ((__always_inline__)) static node_ptr to_node_ptr(reference value)
   {
      node_ptr p = pointer_traits<node_ptr>::pointer_to
         (static_cast<node_reference>(static_cast<node_holder_reference>(value)));
      (static_cast <bool> (!!p) ? void (0) : __assert_fail ("!!p", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      return p;
   }

   inline __attribute__ ((__always_inline__)) static const_node_ptr to_node_ptr(const_reference value)
   {
      const_node_ptr p = pointer_traits<const_node_ptr>::pointer_to
         (static_cast<const_node_reference>(static_cast<const_node_holder_reference>(value)));
      (static_cast <bool> (!!p) ? void (0) : __assert_fail ("!!p", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      return p;
   }
};

template<class T, class NodeTraits, link_mode_type LinkMode, class Tag, unsigned int Type>
struct bhtraits
   : public bhtraits_base<T, typename NodeTraits::node_ptr, Tag, Type>
{
   static const link_mode_type link_mode = LinkMode;
   typedef NodeTraits node_traits;
};


template<class T, class Hook, Hook T::* P>
struct mhtraits
{
   public:
   typedef Hook hook_type;
   typedef typename hook_type::hooktags::node_traits node_traits;
   typedef typename node_traits::node node;
   typedef T value_type;
   typedef typename node_traits::node_ptr node_ptr;
   typedef typename node_traits::const_node_ptr const_node_ptr;
   typedef typename pointer_traits<node_ptr>::
      template rebind_pointer<T>::type pointer;
   typedef typename pointer_traits<node_ptr>::
      template rebind_pointer<const T>::type const_pointer;
   typedef T & reference;
   typedef const T & const_reference;
   typedef node& node_reference;
   typedef const node & const_node_reference;
   typedef hook_type& hook_reference;
   typedef const hook_type & const_hook_reference;

   static const link_mode_type link_mode = Hook::hooktags::link_mode;

   inline __attribute__ ((__always_inline__)) static node_ptr to_node_ptr(reference value)
   {
      return pointer_traits<node_ptr>::pointer_to
         (static_cast<node_reference>(static_cast<hook_reference>(value.*P)));
   }

   inline __attribute__ ((__always_inline__)) static const_node_ptr to_node_ptr(const_reference value)
   {
      return pointer_traits<const_node_ptr>::pointer_to
         (static_cast<const_node_reference>(static_cast<const_hook_reference>(value.*P)));
   }

   inline __attribute__ ((__always_inline__)) static pointer to_value_ptr(node_ptr n)
   {
      return pointer_traits<pointer>::pointer_to
         (*detail::parent_from_member<T, Hook>
            (static_cast<Hook*>(boost::movelib::to_raw_pointer(n)), P));
   }

   inline __attribute__ ((__always_inline__)) static const_pointer to_value_ptr(const_node_ptr n)
   {
      return pointer_traits<const_pointer>::pointer_to
         (*detail::parent_from_member<T, Hook>
            (static_cast<const Hook*>(boost::movelib::to_raw_pointer(n)), P));
   }
};


template<class Functor>
struct fhtraits
{
   public:
   typedef typename Functor::hook_type hook_type;
   typedef typename Functor::hook_ptr hook_ptr;
   typedef typename Functor::const_hook_ptr const_hook_ptr;
   typedef typename hook_type::hooktags::node_traits node_traits;
   typedef typename node_traits::node node;
   typedef typename Functor::value_type value_type;
   typedef typename node_traits::node_ptr node_ptr;
   typedef typename node_traits::const_node_ptr const_node_ptr;
   typedef typename pointer_traits<node_ptr>::
      template rebind_pointer<value_type>::type pointer;
   typedef typename pointer_traits<node_ptr>::
      template rebind_pointer<const value_type>::type const_pointer;
   typedef value_type & reference;
   typedef const value_type & const_reference;
   static const link_mode_type link_mode = hook_type::hooktags::link_mode;

   static node_ptr to_node_ptr(reference value)
   { return static_cast<node*>(boost::movelib::to_raw_pointer(Functor::to_hook_ptr(value))); }

   static const_node_ptr to_node_ptr(const_reference value)
   { return static_cast<const node*>(boost::movelib::to_raw_pointer(Functor::to_hook_ptr(value))); }

   static pointer to_value_ptr(node_ptr n)
   { return Functor::to_value_ptr(to_hook_ptr(n)); }

   static const_pointer to_value_ptr(const_node_ptr n)
   { return Functor::to_value_ptr(to_hook_ptr(n)); }

   private:
   static hook_ptr to_hook_ptr(node_ptr n)
   { return hook_ptr(&*static_cast<hook_type*>(&*n)); }

   static const_hook_ptr to_hook_ptr(const_node_ptr n)
   { return const_hook_ptr(&*static_cast<const hook_type*>(&*n)); }
};


}
}
# 27 "/usr/include/boost/intrusive/detail/get_value_traits.hpp" 2 3 4

namespace boost {
namespace intrusive {



template<class SupposedValueTraits>
struct is_default_hook_tag
{ static const bool value = false; };

namespace detail{

template <class T, class BaseHook>
struct concrete_hook_base_value_traits
{
   typedef typename BaseHook::hooktags tags;
   typedef bhtraits
      < T
      , typename tags::node_traits
      , tags::link_mode
      , typename tags::tag
      , tags::type> type;
};

template <class BaseHook>
struct concrete_hook_base_value_traits<void, BaseHook>
{
   typedef typename BaseHook::hooktags type;
};

template <class T, class AnyToSomeHook_ProtoValueTraits>
struct any_hook_base_value_traits
{







   typedef typename AnyToSomeHook_ProtoValueTraits::basic_hook_t basic_hook_t;
   typedef typename pointer_rebind
      < typename basic_hook_t::hooktags::node_traits::node_ptr
      , void>::type void_pointer;
   typedef typename AnyToSomeHook_ProtoValueTraits::template
      node_traits_from_voidptr<void_pointer>::type node_traits;

   typedef bhtraits
      < T
      , node_traits
      , basic_hook_t::hooktags::link_mode
      , typename basic_hook_t::hooktags::tag
      , basic_hook_t::hooktags::type
      > type;
};

template <class AnyToSomeHook_ProtoValueTraits>
struct any_hook_base_value_traits<void, AnyToSomeHook_ProtoValueTraits>
{
   typedef typename AnyToSomeHook_ProtoValueTraits::basic_hook_t basic_hook_t;
   typedef typename pointer_rebind
      < typename basic_hook_t::hooktags::node_traits::node_ptr
      , void>::type void_pointer;

   struct type
   {
      typedef typename AnyToSomeHook_ProtoValueTraits::template
         node_traits_from_voidptr<void_pointer>::type node_traits;
   };
};

template<class MemberHook>
struct get_member_value_traits
{
   typedef typename MemberHook::member_value_traits type;
};

template <class T>struct internal_any_hook_bool{ template<bool Add> struct two_or_three {yes_type _[2u + (unsigned)Add];}; template <class U> static yes_type test(...); template <class U> static two_or_three<U::is_any_hook> test (int); static const std::size_t value = sizeof(test<T>(0));};template <class T>struct internal_any_hook_bool_is_true{ static const bool value = internal_any_hook_bool<T>::value > sizeof(yes_type)*2;};
template <class T>struct internal_base_hook_bool{ template<bool Add> struct two_or_three {yes_type _[2u + (unsigned)Add];}; template <class U> static yes_type test(...); template <class U> static two_or_three<U::hooktags::is_base_hook> test (int); static const std::size_t value = sizeof(test<T>(0));};template <class T>struct internal_base_hook_bool_is_true{ static const bool value = internal_base_hook_bool<T>::value > sizeof(yes_type)*2;};

template <class T>
struct internal_member_value_traits
{
   template <class U> static yes_type test(...);
   template <class U> static no_type test(typename U::member_value_traits* = 0);
   static const bool value = sizeof(test<T>(0)) == sizeof(no_type);
};

template<class SupposedValueTraits, class T, bool = is_default_hook_tag<SupposedValueTraits>::value>
struct supposed_value_traits;

template<class T, class BaseHook, bool = internal_any_hook_bool_is_true<BaseHook>::value>
struct get_base_value_traits;

template<class SupposedValueTraits, class T, bool = internal_base_hook_bool_is_true<SupposedValueTraits>::value>
struct supposed_base_value_traits;

template<class SupposedValueTraits, bool = internal_member_value_traits<SupposedValueTraits>::value>
struct supposed_member_value_traits;

template<class SupposedValueTraits, bool = internal_any_hook_bool_is_true<SupposedValueTraits>::value>
struct any_or_concrete_value_traits;


template<class T, class BaseHook>
struct get_base_value_traits<T, BaseHook, true>
   : any_hook_base_value_traits<T, BaseHook>
{};


template<class T, class BaseHook>
struct get_base_value_traits<T, BaseHook, false>
   : concrete_hook_base_value_traits<T, BaseHook>
{};


template<class SupposedValueTraits, class T>
struct supposed_value_traits<SupposedValueTraits, T, true>
{ typedef typename SupposedValueTraits::template apply<T>::type type; };


template<class SupposedValueTraits, class T>
struct supposed_value_traits<SupposedValueTraits, T, false>
{ typedef SupposedValueTraits type; };


template<class BaseHook, class T>
struct supposed_base_value_traits<BaseHook, T, true>
   : get_base_value_traits<T, BaseHook>
{};


template<class SupposedValueTraits, class T>
struct supposed_base_value_traits<SupposedValueTraits, T, false>
   : supposed_member_value_traits<SupposedValueTraits>
{};


template<class MemberHook>
struct supposed_member_value_traits<MemberHook, true>
   : get_member_value_traits<MemberHook>
{};


template<class SupposedValueTraits>
struct supposed_member_value_traits<SupposedValueTraits, false>
   : any_or_concrete_value_traits<SupposedValueTraits>
{};

template<class AnyToSomeHook_ProtoValueTraits>
struct any_or_concrete_value_traits<AnyToSomeHook_ProtoValueTraits, true>
{

   typedef typename AnyToSomeHook_ProtoValueTraits::basic_hook_t basic_hook_t;
   typedef typename pointer_rebind
      <typename basic_hook_t::node_ptr, void>::type void_pointer;
   typedef typename AnyToSomeHook_ProtoValueTraits::template
      node_traits_from_voidptr<void_pointer>::type any_node_traits;

   struct type : basic_hook_t
   {
      typedef any_node_traits node_traits;
   };
};

template<class SupposedValueTraits>
struct any_or_concrete_value_traits<SupposedValueTraits, false>
{
   typedef SupposedValueTraits type;
};





template<class T, class SupposedValueTraits>
struct get_value_traits
   : supposed_base_value_traits<typename supposed_value_traits<SupposedValueTraits, T>::type, T>
{};

template<class SupposedValueTraits>
struct get_node_traits
{
   typedef typename get_value_traits<void, SupposedValueTraits>::type::node_traits type;
};

}



}
}

# 1 "/usr/include/boost/intrusive/detail/config_end.hpp" 1 3 4
# 221 "/usr/include/boost/intrusive/detail/get_value_traits.hpp" 2 3 4
# 26 "/usr/include/boost/intrusive/list.hpp" 2 3 4
# 1 "/usr/include/boost/intrusive/detail/is_stateful_value_traits.hpp" 1 3 4
# 42 "/usr/include/boost/intrusive/detail/is_stateful_value_traits.hpp" 3 4
# 1 "/usr/include/boost/intrusive/detail/function_detector.hpp" 1 3 4
# 33 "/usr/include/boost/intrusive/detail/function_detector.hpp" 3 4
namespace boost {
namespace intrusive {
namespace function_detector {

    typedef char NotFoundType;
    struct StaticFunctionType { NotFoundType x [2]; };
    struct NonStaticFunctionType { NotFoundType x [3]; };

    enum
         { NotFound = 0,
           StaticFunction = sizeof( StaticFunctionType ) - sizeof( NotFoundType ),
           NonStaticFunction = sizeof( NonStaticFunctionType ) - sizeof( NotFoundType )
         };

}
}
}
# 43 "/usr/include/boost/intrusive/detail/is_stateful_value_traits.hpp" 2 3 4

namespace boost { namespace intrusive { namespace function_detector { template < class T, class NonStaticType, class NonStaticConstType, class StaticType > class DetectMember_InstantiationKey_to_node_ptr { template < NonStaticType > struct TestNonStaticNonConst ; template < NonStaticConstType > struct TestNonStaticConst ; template < StaticType > struct TestStatic ; template <class U > static NonStaticFunctionType Test( TestNonStaticNonConst<&U::to_node_ptr>*, int ); template <class U > static NonStaticFunctionType Test( TestNonStaticConst<&U::to_node_ptr>*, int ); template <class U> static StaticFunctionType Test( TestStatic<&U::to_node_ptr>*, int ); template <class U> static NotFoundType Test( ... ); public : static const int check = NotFound + (sizeof(Test<T>(0, 0)) - sizeof(NotFoundType)); };}}}
namespace boost { namespace intrusive { namespace function_detector { template < class T, class NonStaticType, class NonStaticConstType, class StaticType > class DetectMember_InstantiationKey_to_value_ptr { template < NonStaticType > struct TestNonStaticNonConst ; template < NonStaticConstType > struct TestNonStaticConst ; template < StaticType > struct TestStatic ; template <class U > static NonStaticFunctionType Test( TestNonStaticNonConst<&U::to_value_ptr>*, int ); template <class U > static NonStaticFunctionType Test( TestNonStaticConst<&U::to_value_ptr>*, int ); template <class U> static StaticFunctionType Test( TestStatic<&U::to_value_ptr>*, int ); template <class U> static NotFoundType Test( ... ); public : static const int check = NotFound + (sizeof(Test<T>(0, 0)) - sizeof(NotFoundType)); };}}}

namespace boost {
namespace intrusive {
namespace detail {

template<class ValueTraits>
struct is_stateful_value_traits
{
   typedef typename ValueTraits::node_ptr node_ptr;
   typedef typename ValueTraits::pointer pointer;
   typedef typename ValueTraits::value_type value_type;
   typedef typename ValueTraits::const_node_ptr const_node_ptr;
   typedef typename ValueTraits::const_pointer const_pointer;

   typedef ValueTraits value_traits;

   static const bool value =
      (boost::intrusive::function_detector::NonStaticFunction ==
         (::boost::intrusive::function_detector::DetectMember_InstantiationKey_to_node_ptr< ValueTraits, node_ptr (ValueTraits::*)(value_type&), node_ptr (ValueTraits::*)(value_type&) const, node_ptr (*)(value_type&) >::check))
      ||
      (boost::intrusive::function_detector::NonStaticFunction ==
         (::boost::intrusive::function_detector::DetectMember_InstantiationKey_to_value_ptr< ValueTraits, pointer (ValueTraits::*)(node_ptr), pointer (ValueTraits::*)(node_ptr) const, pointer (*)(node_ptr) >::check))
      ||
      (boost::intrusive::function_detector::NonStaticFunction ==
         (::boost::intrusive::function_detector::DetectMember_InstantiationKey_to_node_ptr< ValueTraits, const_node_ptr (ValueTraits::*)(const value_type&), const_node_ptr (ValueTraits::*)(const value_type&) const, const_node_ptr (*)(const value_type&) >::check))
      ||
      (boost::intrusive::function_detector::NonStaticFunction ==
         (::boost::intrusive::function_detector::DetectMember_InstantiationKey_to_value_ptr< ValueTraits, const_pointer (ValueTraits::*)(const_node_ptr), const_pointer (ValueTraits::*)(const_node_ptr) const, const_pointer (*)(const_node_ptr) >::check))
      ;
};

}}}
# 27 "/usr/include/boost/intrusive/list.hpp" 2 3 4
# 1 "/usr/include/boost/intrusive/detail/default_header_holder.hpp" 1 3 4
# 28 "/usr/include/boost/intrusive/detail/default_header_holder.hpp" 3 4
namespace boost {
namespace intrusive {
namespace detail {


template < typename NodeTraits >
struct default_header_holder : public NodeTraits::node
{
   typedef NodeTraits node_traits;
   typedef typename node_traits::node node;
   typedef typename node_traits::node_ptr node_ptr;
   typedef typename node_traits::const_node_ptr const_node_ptr;

   default_header_holder() : node() {}

   inline __attribute__ ((__always_inline__)) const_node_ptr get_node() const
   { return pointer_traits< const_node_ptr >::pointer_to(*static_cast< const node* >(this)); }

   inline __attribute__ ((__always_inline__)) node_ptr get_node()
   { return pointer_traits< node_ptr >::pointer_to(*static_cast< node* >(this)); }


   inline __attribute__ ((__always_inline__)) static default_header_holder* get_holder(node_ptr p)
   { return static_cast< default_header_holder* >(boost::movelib::to_raw_pointer(p)); }
};


template < typename ValueTraits, typename HeaderHolder >
struct get_header_holder_type
{
   typedef HeaderHolder type;
};
template < typename ValueTraits >
struct get_header_holder_type< ValueTraits, void >
{
   typedef default_header_holder< typename ValueTraits::node_traits > type;
};

}
}
}
# 28 "/usr/include/boost/intrusive/list.hpp" 2 3 4
# 1 "/usr/include/boost/intrusive/detail/reverse_iterator.hpp" 1 3 4
# 16 "/usr/include/boost/intrusive/detail/reverse_iterator.hpp" 3 4
# 1 "/usr/include/boost/move/detail/reverse_iterator.hpp" 1 3 4
# 24 "/usr/include/boost/move/detail/reverse_iterator.hpp" 3 4
# 1 "/usr/include/boost/move/detail/config_begin.hpp" 1 3 4
# 25 "/usr/include/boost/move/detail/reverse_iterator.hpp" 2 3 4
# 1 "/usr/include/boost/move/detail/iterator_traits.hpp" 1 3 4
# 27 "/usr/include/boost/move/detail/iterator_traits.hpp" 3 4
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/iterator" 1 3 4
# 59 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/iterator" 3






# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stream_iterator.h" 1 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stream_iterator.h" 3

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/iosfwd" 1 3
# 37 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/iosfwd" 3




# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stringfwd.h" 1 3
# 38 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stringfwd.h" 3




namespace std __attribute__ ((__visibility__ ("default")))
{
# 52 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stringfwd.h" 3
  template<class _CharT>
    struct char_traits;

  template<> struct char_traits<char>;

  template<> struct char_traits<wchar_t>;


  template<> struct char_traits<char8_t>;



  template<> struct char_traits<char16_t>;
  template<> struct char_traits<char32_t>;


namespace __cxx11 {

  template<typename _CharT, typename _Traits = char_traits<_CharT>,
           typename _Alloc = allocator<_CharT> >
    class basic_string;

}


  typedef basic_string<char> string;


  typedef basic_string<wchar_t> wstring;



  typedef basic_string<char8_t> u8string;




  typedef basic_string<char16_t> u16string;


  typedef basic_string<char32_t> u32string;





}
# 42 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/iosfwd" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/postypes.h" 1 3
# 39 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/postypes.h" 3

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cwchar" 1 3
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cwchar" 3




# 1 "/usr/include/wchar.h" 1 3 4
# 27 "/usr/include/wchar.h" 3 4
# 1 "/usr/include/bits/libc-header-start.h" 1 3 4
# 28 "/usr/include/wchar.h" 2 3 4







# 1 "/usr/bin/../lib/clang/18/include/stddef.h" 1 3 4
# 77 "/usr/bin/../lib/clang/18/include/stddef.h" 3 4
# 1 "/usr/bin/../lib/clang/18/include/__stddef_size_t.h" 1 3 4
# 18 "/usr/bin/../lib/clang/18/include/__stddef_size_t.h" 3 4
typedef long unsigned int size_t;
# 78 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3 4
# 87 "/usr/bin/../lib/clang/18/include/stddef.h" 3 4
# 1 "/usr/bin/../lib/clang/18/include/__stddef_wchar_t.h" 1 3 4
# 88 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3 4




# 1 "/usr/bin/../lib/clang/18/include/__stddef_null.h" 1 3 4
# 93 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3 4
# 36 "/usr/include/wchar.h" 2 3 4


# 1 "/usr/bin/../lib/clang/18/include/stdarg.h" 1 3 4
# 55 "/usr/bin/../lib/clang/18/include/stdarg.h" 3 4
# 1 "/usr/bin/../lib/clang/18/include/__stdarg___gnuc_va_list.h" 1 3 4
# 12 "/usr/bin/../lib/clang/18/include/__stdarg___gnuc_va_list.h" 3 4
typedef __builtin_va_list __gnuc_va_list;
# 56 "/usr/bin/../lib/clang/18/include/stdarg.h" 2 3 4
# 39 "/usr/include/wchar.h" 2 3 4




typedef __gnuc_va_list va_list;
# 52 "/usr/include/wchar.h" 3 4
# 1 "/usr/include/bits/types/wint_t.h" 1 3 4
# 20 "/usr/include/bits/types/wint_t.h" 3 4
typedef unsigned int wint_t;
# 53 "/usr/include/wchar.h" 2 3 4
# 1 "/usr/include/bits/types/mbstate_t.h" 1 3 4



# 1 "/usr/include/bits/types/__mbstate_t.h" 1 3 4
# 13 "/usr/include/bits/types/__mbstate_t.h" 3 4
typedef struct
{
  int __count;
  union
  {
    unsigned int __wch;
    char __wchb[4];
  } __value;
} __mbstate_t;
# 5 "/usr/include/bits/types/mbstate_t.h" 2 3 4

typedef __mbstate_t mbstate_t;
# 54 "/usr/include/wchar.h" 2 3 4
# 1 "/usr/include/bits/types/__FILE.h" 1 3 4



struct _IO_FILE;
typedef struct _IO_FILE __FILE;
# 55 "/usr/include/wchar.h" 2 3 4


# 1 "/usr/include/bits/types/FILE.h" 1 3 4



struct _IO_FILE;


typedef struct _IO_FILE FILE;
# 58 "/usr/include/wchar.h" 2 3 4
# 90 "/usr/include/wchar.h" 3 4
extern "C" {



struct tm;



extern wchar_t *wcscpy (wchar_t *__restrict __dest,
   const wchar_t *__restrict __src)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern wchar_t *wcsncpy (wchar_t *__restrict __dest,
    const wchar_t *__restrict __src, size_t __n)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));



extern size_t wcslcpy (wchar_t *__restrict __dest,
         const wchar_t *__restrict __src, size_t __n)
  noexcept (true) __attribute__ ((__nonnull__ (1, 2))) ;



extern size_t wcslcat (wchar_t *__restrict __dest,
         const wchar_t *__restrict __src, size_t __n)
  noexcept (true) __attribute__ ((__nonnull__ (1, 2))) ;



extern wchar_t *wcscat (wchar_t *__restrict __dest,
   const wchar_t *__restrict __src)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));

extern wchar_t *wcsncat (wchar_t *__restrict __dest,
    const wchar_t *__restrict __src, size_t __n)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern int wcscmp (const wchar_t *__s1, const wchar_t *__s2)
     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern int wcsncmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n)
     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));



extern int wcscasecmp (const wchar_t *__s1, const wchar_t *__s2) noexcept (true);


extern int wcsncasecmp (const wchar_t *__s1, const wchar_t *__s2,
   size_t __n) noexcept (true);



extern int wcscasecmp_l (const wchar_t *__s1, const wchar_t *__s2,
    locale_t __loc) noexcept (true);

extern int wcsncasecmp_l (const wchar_t *__s1, const wchar_t *__s2,
     size_t __n, locale_t __loc) noexcept (true);




extern int wcscoll (const wchar_t *__s1, const wchar_t *__s2) noexcept (true);



extern size_t wcsxfrm (wchar_t *__restrict __s1,
         const wchar_t *__restrict __s2, size_t __n) noexcept (true);







extern int wcscoll_l (const wchar_t *__s1, const wchar_t *__s2,
        locale_t __loc) noexcept (true);




extern size_t wcsxfrm_l (wchar_t *__s1, const wchar_t *__s2,
    size_t __n, locale_t __loc) noexcept (true);


extern wchar_t *wcsdup (const wchar_t *__s) noexcept (true)
  __attribute__ ((__malloc__)) ;
# 189 "/usr/include/wchar.h" 3 4
extern wchar_t *wcschr (const wchar_t *__wcs, wchar_t __wc)
     noexcept (true) __attribute__ ((__pure__));
# 199 "/usr/include/wchar.h" 3 4
extern wchar_t *wcsrchr (const wchar_t *__wcs, wchar_t __wc)
     noexcept (true) __attribute__ ((__pure__));





extern wchar_t *wcschrnul (const wchar_t *__s, wchar_t __wc)
     noexcept (true) __attribute__ ((__pure__));




extern size_t wcscspn (const wchar_t *__wcs, const wchar_t *__reject)
     noexcept (true) __attribute__ ((__pure__));


extern size_t wcsspn (const wchar_t *__wcs, const wchar_t *__accept)
     noexcept (true) __attribute__ ((__pure__));
# 226 "/usr/include/wchar.h" 3 4
extern wchar_t *wcspbrk (const wchar_t *__wcs, const wchar_t *__accept)
     noexcept (true) __attribute__ ((__pure__));
# 237 "/usr/include/wchar.h" 3 4
extern wchar_t *wcsstr (const wchar_t *__haystack, const wchar_t *__needle)
     noexcept (true) __attribute__ ((__pure__));



extern wchar_t *wcstok (wchar_t *__restrict __s,
   const wchar_t *__restrict __delim,
   wchar_t **__restrict __ptr) noexcept (true);


extern size_t wcslen (const wchar_t *__s) noexcept (true) __attribute__ ((__pure__));
# 258 "/usr/include/wchar.h" 3 4
extern wchar_t *wcswcs (const wchar_t *__haystack, const wchar_t *__needle)
     noexcept (true) __attribute__ ((__pure__));





extern size_t wcsnlen (const wchar_t *__s, size_t __maxlen)
     noexcept (true) __attribute__ ((__pure__));
# 278 "/usr/include/wchar.h" 3 4
extern wchar_t *wmemchr (const wchar_t *__s, wchar_t __c, size_t __n)
     noexcept (true) __attribute__ ((__pure__));



extern int wmemcmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n)
     noexcept (true) __attribute__ ((__pure__));


extern wchar_t *wmemcpy (wchar_t *__restrict __s1,
    const wchar_t *__restrict __s2, size_t __n) noexcept (true);



extern wchar_t *wmemmove (wchar_t *__s1, const wchar_t *__s2, size_t __n)
     noexcept (true);


extern wchar_t *wmemset (wchar_t *__s, wchar_t __c, size_t __n) noexcept (true);




extern wchar_t *wmempcpy (wchar_t *__restrict __s1,
     const wchar_t *__restrict __s2, size_t __n)
     noexcept (true);





extern wint_t btowc (int __c) noexcept (true);



extern int wctob (wint_t __c) noexcept (true);



extern int mbsinit (const mbstate_t *__ps) noexcept (true) __attribute__ ((__pure__));



extern size_t mbrtowc (wchar_t *__restrict __pwc,
         const char *__restrict __s, size_t __n,
         mbstate_t *__restrict __p) noexcept (true);


extern size_t wcrtomb (char *__restrict __s, wchar_t __wc,
         mbstate_t *__restrict __ps) noexcept (true);


extern size_t __mbrlen (const char *__restrict __s, size_t __n,
   mbstate_t *__restrict __ps) noexcept (true);
extern size_t mbrlen (const char *__restrict __s, size_t __n,
        mbstate_t *__restrict __ps) noexcept (true);







extern wint_t __btowc_alias (int __c) __asm ("btowc");
extern __inline __attribute__ ((__gnu_inline__)) wint_t
 btowc (int __c) noexcept (true)
{ return (__builtin_constant_p (__c) && __c >= '\0' && __c <= '\x7f'
   ? (wint_t) __c : __btowc_alias (__c)); }

extern int __wctob_alias (wint_t __c) __asm ("wctob");
extern __inline __attribute__ ((__gnu_inline__)) int
 wctob (wint_t __wc) noexcept (true)
{ return (__builtin_constant_p (__wc) && __wc >= L'\0' && __wc <= L'\x7f'
   ? (int) __wc : __wctob_alias (__wc)); }

extern __inline __attribute__ ((__gnu_inline__)) size_t
 mbrlen (const char *__restrict __s, size_t __n, mbstate_t *__restrict __ps) noexcept (true)

{ return (__ps != __null
   ? mbrtowc (__null, __s, __n, __ps) : __mbrlen (__s, __n, __null)); }




extern size_t mbsrtowcs (wchar_t *__restrict __dst,
    const char **__restrict __src, size_t __len,
    mbstate_t *__restrict __ps) noexcept (true);



extern size_t wcsrtombs (char *__restrict __dst,
    const wchar_t **__restrict __src, size_t __len,
    mbstate_t *__restrict __ps) noexcept (true);





extern size_t mbsnrtowcs (wchar_t *__restrict __dst,
     const char **__restrict __src, size_t __nmc,
     size_t __len, mbstate_t *__restrict __ps) noexcept (true);



extern size_t wcsnrtombs (char *__restrict __dst,
     const wchar_t **__restrict __src,
     size_t __nwc, size_t __len,
     mbstate_t *__restrict __ps) noexcept (true);






extern int wcwidth (wchar_t __c) noexcept (true);



extern int wcswidth (const wchar_t *__s, size_t __n) noexcept (true);





extern double wcstod (const wchar_t *__restrict __nptr,
        wchar_t **__restrict __endptr) noexcept (true);



extern float wcstof (const wchar_t *__restrict __nptr,
       wchar_t **__restrict __endptr) noexcept (true);
extern long double wcstold (const wchar_t *__restrict __nptr,
       wchar_t **__restrict __endptr) noexcept (true);
# 422 "/usr/include/wchar.h" 3 4
extern _Float32 wcstof32 (const wchar_t *__restrict __nptr,
     wchar_t **__restrict __endptr) noexcept (true);



extern _Float64 wcstof64 (const wchar_t *__restrict __nptr,
     wchar_t **__restrict __endptr) noexcept (true);
# 437 "/usr/include/wchar.h" 3 4
extern _Float32x wcstof32x (const wchar_t *__restrict __nptr,
       wchar_t **__restrict __endptr) noexcept (true);



extern _Float64x wcstof64x (const wchar_t *__restrict __nptr,
       wchar_t **__restrict __endptr) noexcept (true);
# 455 "/usr/include/wchar.h" 3 4
extern long int wcstol (const wchar_t *__restrict __nptr,
   wchar_t **__restrict __endptr, int __base) noexcept (true);



extern unsigned long int wcstoul (const wchar_t *__restrict __nptr,
      wchar_t **__restrict __endptr, int __base)
     noexcept (true);




__extension__
extern long long int wcstoll (const wchar_t *__restrict __nptr,
         wchar_t **__restrict __endptr, int __base)
     noexcept (true);



__extension__
extern unsigned long long int wcstoull (const wchar_t *__restrict __nptr,
     wchar_t **__restrict __endptr,
     int __base) noexcept (true);





__extension__
extern long long int wcstoq (const wchar_t *__restrict __nptr,
        wchar_t **__restrict __endptr, int __base)
     noexcept (true);



__extension__
extern unsigned long long int wcstouq (const wchar_t *__restrict __nptr,
           wchar_t **__restrict __endptr,
           int __base) noexcept (true);






extern long int wcstol (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstol");


extern unsigned long int wcstoul (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoul");



__extension__
extern long long int wcstoll (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoll");



__extension__
extern unsigned long long int wcstoull (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoull");




__extension__
extern long long int wcstoq (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoll");


__extension__
extern unsigned long long int wcstouq (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoull");
# 561 "/usr/include/wchar.h" 3 4
extern long int wcstol_l (const wchar_t *__restrict __nptr,
     wchar_t **__restrict __endptr, int __base,
     locale_t __loc) noexcept (true);

extern unsigned long int wcstoul_l (const wchar_t *__restrict __nptr,
        wchar_t **__restrict __endptr,
        int __base, locale_t __loc) noexcept (true);

__extension__
extern long long int wcstoll_l (const wchar_t *__restrict __nptr,
    wchar_t **__restrict __endptr,
    int __base, locale_t __loc) noexcept (true);

__extension__
extern unsigned long long int wcstoull_l (const wchar_t *__restrict __nptr,
       wchar_t **__restrict __endptr,
       int __base, locale_t __loc)
     noexcept (true);





extern long int wcstol_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_wcstol_l");



extern unsigned long int wcstoul_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_wcstoul_l");




__extension__
extern long long int wcstoll_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_wcstoll_l");




__extension__
extern unsigned long long int wcstoull_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_wcstoull_l");
# 630 "/usr/include/wchar.h" 3 4
extern double wcstod_l (const wchar_t *__restrict __nptr,
   wchar_t **__restrict __endptr, locale_t __loc)
     noexcept (true);

extern float wcstof_l (const wchar_t *__restrict __nptr,
         wchar_t **__restrict __endptr, locale_t __loc)
     noexcept (true);

extern long double wcstold_l (const wchar_t *__restrict __nptr,
         wchar_t **__restrict __endptr,
         locale_t __loc) noexcept (true);
# 649 "/usr/include/wchar.h" 3 4
extern _Float32 wcstof32_l (const wchar_t *__restrict __nptr,
       wchar_t **__restrict __endptr,
       locale_t __loc) noexcept (true);



extern _Float64 wcstof64_l (const wchar_t *__restrict __nptr,
       wchar_t **__restrict __endptr,
       locale_t __loc) noexcept (true);
# 667 "/usr/include/wchar.h" 3 4
extern _Float32x wcstof32x_l (const wchar_t *__restrict __nptr,
         wchar_t **__restrict __endptr,
         locale_t __loc) noexcept (true);



extern _Float64x wcstof64x_l (const wchar_t *__restrict __nptr,
         wchar_t **__restrict __endptr,
         locale_t __loc) noexcept (true);
# 689 "/usr/include/wchar.h" 3 4
extern wchar_t *wcpcpy (wchar_t *__restrict __dest,
   const wchar_t *__restrict __src) noexcept (true);



extern wchar_t *wcpncpy (wchar_t *__restrict __dest,
    const wchar_t *__restrict __src, size_t __n)
     noexcept (true);
# 718 "/usr/include/wchar.h" 3 4
extern __FILE *open_wmemstream (wchar_t **__bufloc, size_t *__sizeloc) noexcept (true)
  __attribute__ ((__malloc__)) ;





extern int fwide (__FILE *__fp, int __mode) noexcept (true);






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, ...)
     noexcept (true) ;





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)
     noexcept (true) ;






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, ...)
     noexcept (true) ;
# 795 "/usr/include/wchar.h" 3 4
extern int fwscanf (__FILE *__restrict __stream, const wchar_t *__restrict __format, ...) __asm__ ("" "__isoc23_fwscanf")


                                                          ;
extern int wscanf (const wchar_t *__restrict __format, ...) __asm__ ("" "__isoc23_wscanf")

                                                          ;
extern int swscanf (const wchar_t *__restrict __s, const wchar_t *__restrict __format, ...) noexcept (true) __asm__ ("" "__isoc23_swscanf")


                                                          ;
# 851 "/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)
     noexcept (true) ;
# 875 "/usr/include/wchar.h" 3 4
extern int vfwscanf (__FILE *__restrict __s, const wchar_t *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc23_vfwscanf")


                                                          ;
extern int vwscanf (const wchar_t *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc23_vwscanf")

                                                          ;
extern int vswscanf (const wchar_t *__restrict __s, const wchar_t *__restrict __format, __gnuc_va_list __arg) noexcept (true) __asm__ ("" "__isoc23_vswscanf")


                                                          ;
# 935 "/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);
# 990 "/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);
# 1016 "/usr/include/wchar.h" 3 4
extern wint_t putwc_unlocked (wchar_t __wc, __FILE *__stream);
extern wint_t putwchar_unlocked (wchar_t __wc);
# 1026 "/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) noexcept (true);




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) noexcept (true);
# 1073 "/usr/include/wchar.h" 3 4
}
# 45 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cwchar" 2 3
# 62 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cwchar" 3
namespace std
{
  using ::mbstate_t;
}
# 135 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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;


  inline wchar_t*
  wcschr(wchar_t* __p, wchar_t __c)
  { return wcschr(const_cast<const wchar_t*>(__p), __c); }

  inline wchar_t*
  wcspbrk(wchar_t* __s1, const wchar_t* __s2)
  { return wcspbrk(const_cast<const wchar_t*>(__s1), __s2); }

  inline wchar_t*
  wcsrchr(wchar_t* __p, wchar_t __c)
  { return wcsrchr(const_cast<const wchar_t*>(__p), __c); }

  inline wchar_t*
  wcsstr(wchar_t* __s1, const wchar_t* __s2)
  { return wcsstr(const_cast<const wchar_t*>(__s1), __s2); }

  inline wchar_t*
  wmemchr(wchar_t* __p, wchar_t __c, size_t __n)
  { return wmemchr(const_cast<const wchar_t*>(__p), __c, __n); }



}
}







namespace __gnu_cxx
{





  using ::wcstold;
# 260 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cwchar" 3
  using ::wcstoll;
  using ::wcstoull;

}

namespace std
{
  using ::__gnu_cxx::wcstold;
  using ::__gnu_cxx::wcstoll;
  using ::__gnu_cxx::wcstoull;
}
# 280 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/postypes.h" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{
# 62 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/postypes.h" 3
  typedef long int streamoff;





  typedef ptrdiff_t streamsize;
# 81 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/postypes.h" 3
  template<typename _StateT>
    class fpos
    {
    private:
      streamoff _M_off;
      _StateT _M_state;

    public:




      fpos()
      : _M_off(0), _M_state() { }
# 103 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/postypes.h" 3
      fpos(streamoff __off)
      : _M_off(__off), _M_state() { }


      fpos(const fpos&) = default;
      fpos& operator=(const fpos&) = default;
      ~fpos() = default;



      operator streamoff() const { return _M_off; }


      void
      state(_StateT __st)
      { _M_state = __st; }


      _StateT
      state() const
      { return _M_state; }





      fpos&
      operator+=(streamoff __off)
      {
 _M_off += __off;
 return *this;
      }





      fpos&
      operator-=(streamoff __off)
      {
 _M_off -= __off;
 return *this;
      }







      fpos
      operator+(streamoff __off) const
      {
 fpos __pos(*this);
 __pos += __off;
 return __pos;
      }







      fpos
      operator-(streamoff __off) const
      {
 fpos __pos(*this);
 __pos -= __off;
 return __pos;
      }






      streamoff
      operator-(const fpos& __other) const
      { return _M_off - __other._M_off; }
    };






  template<typename _StateT>
    inline bool
    operator==(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
    { return streamoff(__lhs) == streamoff(__rhs); }

  template<typename _StateT>
    inline bool
    operator!=(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
    { return streamoff(__lhs) != streamoff(__rhs); }





  typedef fpos<mbstate_t> streampos;

  typedef fpos<mbstate_t> wstreampos;



  typedef fpos<mbstate_t> u8streampos;




  typedef fpos<mbstate_t> u16streampos;

  typedef fpos<mbstate_t> u32streampos;



}
# 43 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/iosfwd" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{
# 76 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/iosfwd" 3
  class ios_base;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_ios;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_streambuf;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_istream;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_ostream;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_iostream;


namespace __cxx11 {

  template<typename _CharT, typename _Traits = char_traits<_CharT>,
     typename _Alloc = allocator<_CharT> >
    class basic_stringbuf;

  template<typename _CharT, typename _Traits = char_traits<_CharT>,
    typename _Alloc = allocator<_CharT> >
    class basic_istringstream;

  template<typename _CharT, typename _Traits = char_traits<_CharT>,
    typename _Alloc = allocator<_CharT> >
    class basic_ostringstream;

  template<typename _CharT, typename _Traits = char_traits<_CharT>,
    typename _Alloc = allocator<_CharT> >
    class basic_stringstream;

}

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_filebuf;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_ifstream;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_ofstream;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class basic_fstream;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class istreambuf_iterator;

  template<typename _CharT, typename _Traits = char_traits<_CharT> >
    class ostreambuf_iterator;



  typedef basic_ios<char> ios;


  typedef basic_streambuf<char> streambuf;


  typedef basic_istream<char> istream;


  typedef basic_ostream<char> ostream;


  typedef basic_iostream<char> iostream;


  typedef basic_stringbuf<char> stringbuf;


  typedef basic_istringstream<char> istringstream;


  typedef basic_ostringstream<char> ostringstream;


  typedef basic_stringstream<char> stringstream;


  typedef basic_filebuf<char> filebuf;


  typedef basic_ifstream<char> ifstream;


  typedef basic_ofstream<char> ofstream;


  typedef basic_fstream<char> fstream;



  typedef basic_ios<wchar_t> wios;


  typedef basic_streambuf<wchar_t> wstreambuf;


  typedef basic_istream<wchar_t> wistream;


  typedef basic_ostream<wchar_t> wostream;


  typedef basic_iostream<wchar_t> wiostream;


  typedef basic_stringbuf<wchar_t> wstringbuf;


  typedef basic_istringstream<wchar_t> wistringstream;


  typedef basic_ostringstream<wchar_t> wostringstream;


  typedef basic_stringstream<wchar_t> wstringstream;


  typedef basic_filebuf<wchar_t> wfilebuf;


  typedef basic_ifstream<wchar_t> wifstream;


  typedef basic_ofstream<wchar_t> wofstream;


  typedef basic_fstream<wchar_t> wfstream;



  template<typename _CharT, typename _Traits = char_traits<_CharT>,
           typename _Allocator = allocator<_CharT>>
    class basic_syncbuf;
  template<typename _CharT, typename _Traits = char_traits<_CharT>,
           typename _Allocator = allocator<_CharT>>
    class basic_osyncstream;

  using syncbuf = basic_syncbuf<char>;
  using osyncstream = basic_osyncstream<char>;


  using wsyncbuf = basic_syncbuf<wchar_t>;
  using wosyncstream = basic_osyncstream<wchar_t>;




  template<typename _CharT, typename _Traits = char_traits<_CharT>>
    class basic_spanbuf;
  template<typename _CharT, typename _Traits = char_traits<_CharT>>
    class basic_ispanstream;
  template<typename _CharT, typename _Traits = char_traits<_CharT>>
    class basic_ospanstream;
  template<typename _CharT, typename _Traits = char_traits<_CharT>>
    class basic_spanstream;

  using spanbuf = basic_spanbuf<char>;
  using ispanstream = basic_ispanstream<char>;
  using ospanstream = basic_ospanstream<char>;
  using spanstream = basic_spanstream<char>;


  using wspanbuf = basic_spanbuf<wchar_t>;
  using wispanstream = basic_ispanstream<wchar_t>;
  using wospanstream = basic_ospanstream<wchar_t>;
  using wspanstream = basic_spanstream<wchar_t>;






}
# 36 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stream_iterator.h" 2 3




namespace std __attribute__ ((__visibility__ ("default")))
{








#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"


  template<typename _Tp, typename _CharT = char,
           typename _Traits = char_traits<_CharT>, typename _Dist = ptrdiff_t>
    class istream_iterator
    : public iterator<input_iterator_tag, _Tp, _Dist, const _Tp*, const _Tp&>
    {
    public:
      typedef _CharT char_type;
      typedef _Traits traits_type;
      typedef basic_istream<_CharT, _Traits> istream_type;

    private:
      istream_type* _M_stream;
      _Tp _M_value;



      bool _M_ok;

    public:

      constexpr istream_iterator()
      noexcept(is_nothrow_default_constructible<_Tp>::value)
      : _M_stream(0), _M_value(), _M_ok(false) {}


      istream_iterator(istream_type& __s)
      : _M_stream(std::__addressof(__s)), _M_ok(true)
      { _M_read(); }

      constexpr
      istream_iterator(const istream_iterator& __obj)
      noexcept(is_nothrow_copy_constructible<_Tp>::value)
      : _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;


      [[__nodiscard__]]
      const _Tp&
      operator*() const noexcept
      {


                        ;
 return _M_value;
      }

      [[__nodiscard__]]
      const _Tp*
      operator->() const noexcept
      { 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 noexcept
      {


 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;
          }
      }



      [[__nodiscard__]]
      friend bool
      operator==(const istream_iterator& __x, const istream_iterator& __y)
      noexcept
      { return __x._M_equal(__y); }
# 176 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stream_iterator.h" 3
      [[nodiscard]]
      friend bool
      operator==(const istream_iterator& __i, default_sentinel_t) noexcept
      { return !__i._M_stream; }

    };
# 194 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stream_iterator.h" 3
  template<typename _Tp, typename _CharT = char,
           typename _Traits = char_traits<_CharT> >
    class ostream_iterator
    : public iterator<output_iterator_tag, void, void, void, void>
    {
    public:



      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:

      ostream_iterator(ostream_type& __s) noexcept
      : _M_stream(std::__addressof(__s)), _M_string(0) {}
# 229 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stream_iterator.h" 3
      ostream_iterator(ostream_type& __s, const _CharT* __c) noexcept
      : _M_stream(std::__addressof(__s)), _M_string(__c) { }


      ostream_iterator(const ostream_iterator& __obj) noexcept
      : _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;
      }

      [[__nodiscard__]]
      ostream_iterator&
      operator*() noexcept
      { return *this; }

      ostream_iterator&
      operator++() noexcept
      { return *this; }

      ostream_iterator&
      operator++(int) noexcept
      { return *this; }
    };
#pragma GCC diagnostic pop




}
# 66 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/iterator" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/streambuf_iterator.h" 1 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/streambuf_iterator.h" 3

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/streambuf" 1 3
# 37 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/streambuf" 3





# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/localefwd.h" 1 3
# 38 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/localefwd.h" 3


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/c++locale.h" 1 3
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/c++locale.h" 3

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/clocale" 1 3
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/clocale" 3


# 1 "/usr/include/locale.h" 1 3 4
# 28 "/usr/include/locale.h" 3 4
# 1 "/usr/bin/../lib/clang/18/include/stddef.h" 1 3 4
# 92 "/usr/bin/../lib/clang/18/include/stddef.h" 3 4
# 1 "/usr/bin/../lib/clang/18/include/__stddef_null.h" 1 3 4
# 93 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3 4
# 29 "/usr/include/locale.h" 2 3 4
# 1 "/usr/include/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) noexcept (true);


extern struct lconv *localeconv (void) noexcept (true);
# 141 "/usr/include/locale.h" 3 4
extern locale_t newlocale (int __category_mask, const char *__locale,
      locale_t __base) noexcept (true);
# 176 "/usr/include/locale.h" 3 4
extern locale_t duplocale (locale_t __dataset) noexcept (true);



extern void freelocale (locale_t __dataset) noexcept (true);






extern locale_t uselocale (locale_t __dataset) noexcept (true);







}
# 43 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/clocale" 2 3








namespace std
{
  using ::lconv;
  using ::setlocale;
  using ::localeconv;
}
# 42 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/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;
# 73 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/c++locale.h" 3
  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);
# 93 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/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/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/localefwd.h" 2 3

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cctype" 1 3
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cctype" 3


# 1 "/usr/include/ctype.h" 1 3 4
# 28 "/usr/include/ctype.h" 3 4
extern "C" {
# 46 "/usr/include/ctype.h" 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)
     noexcept (true) __attribute__ ((__const__));
extern const __int32_t **__ctype_tolower_loc (void)
     noexcept (true) __attribute__ ((__const__));
extern const __int32_t **__ctype_toupper_loc (void)
     noexcept (true) __attribute__ ((__const__));
# 108 "/usr/include/ctype.h" 3 4
extern int isalnum (int) noexcept (true);
extern int isalpha (int) noexcept (true);
extern int iscntrl (int) noexcept (true);
extern int isdigit (int) noexcept (true);
extern int islower (int) noexcept (true);
extern int isgraph (int) noexcept (true);
extern int isprint (int) noexcept (true);
extern int ispunct (int) noexcept (true);
extern int isspace (int) noexcept (true);
extern int isupper (int) noexcept (true);
extern int isxdigit (int) noexcept (true);



extern int tolower (int __c) noexcept (true);


extern int toupper (int __c) noexcept (true);




extern int isblank (int) noexcept (true);




extern int isctype (int __c, int __mask) noexcept (true);






extern int isascii (int __c) noexcept (true);



extern int toascii (int __c) noexcept (true);



extern int _toupper (int) noexcept (true);
extern int _tolower (int) noexcept (true);
# 251 "/usr/include/ctype.h" 3 4
extern int isalnum_l (int, locale_t) noexcept (true);
extern int isalpha_l (int, locale_t) noexcept (true);
extern int iscntrl_l (int, locale_t) noexcept (true);
extern int isdigit_l (int, locale_t) noexcept (true);
extern int islower_l (int, locale_t) noexcept (true);
extern int isgraph_l (int, locale_t) noexcept (true);
extern int isprint_l (int, locale_t) noexcept (true);
extern int ispunct_l (int, locale_t) noexcept (true);
extern int isspace_l (int, locale_t) noexcept (true);
extern int isupper_l (int, locale_t) noexcept (true);
extern int isxdigit_l (int, locale_t) noexcept (true);

extern int isblank_l (int, locale_t) noexcept (true);



extern int __tolower_l (int __c, locale_t __l) noexcept (true);
extern int tolower_l (int __c, locale_t __l) noexcept (true);


extern int __toupper_l (int __c, locale_t __l) noexcept (true);
extern int toupper_l (int __c, locale_t __l) noexcept (true);
# 327 "/usr/include/ctype.h" 3 4
}
# 43 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cctype" 2 3
# 62 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/localefwd.h" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{
# 55 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/localefwd.h" 3
  class locale;

  template<typename _Facet>
    bool
    has_facet(const locale&) throw();

  template<typename _Facet>
    const _Facet&
    use_facet(const locale&);


  template<typename _CharT>
    bool
    isspace(_CharT, const locale&);

  template<typename _CharT>
    bool
    isprint(_CharT, const locale&);

  template<typename _CharT>
    bool
    iscntrl(_CharT, const locale&);

  template<typename _CharT>
    bool
    isupper(_CharT, const locale&);

  template<typename _CharT>
    bool
    islower(_CharT, const locale&);

  template<typename _CharT>
    bool
    isalpha(_CharT, const locale&);

  template<typename _CharT>
    bool
    isdigit(_CharT, const locale&);

  template<typename _CharT>
    bool
    ispunct(_CharT, const locale&);

  template<typename _CharT>
    bool
    isxdigit(_CharT, const locale&);

  template<typename _CharT>
    bool
    isalnum(_CharT, const locale&);

  template<typename _CharT>
    bool
    isgraph(_CharT, const locale&);


  template<typename _CharT>
    bool
    isblank(_CharT, const locale&);


  template<typename _CharT>
    _CharT
    toupper(_CharT, const locale&);

  template<typename _CharT>
    _CharT
    tolower(_CharT, const locale&);


  struct ctype_base;
  template<typename _CharT>
    class ctype;
  template<> class ctype<char>;

  template<> class ctype<wchar_t>;

  template<typename _CharT>
    class ctype_byname;


  class codecvt_base;
  template<typename _InternT, typename _ExternT, typename _StateT>
    class codecvt;
  template<> class codecvt<char, char, mbstate_t>;

  template<> class codecvt<wchar_t, char, mbstate_t>;


  template<> class codecvt<char16_t, char, mbstate_t>;
  template<> class codecvt<char32_t, char, mbstate_t>;

  template<> class codecvt<char16_t, char8_t, mbstate_t>;
  template<> class codecvt<char32_t, char8_t, mbstate_t>;


  template<typename _InternT, typename _ExternT, typename _StateT>
    class codecvt_byname;



  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
    class num_get;
  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
    class num_put;

namespace __cxx11 {
  template<typename _CharT> class numpunct;
  template<typename _CharT> class numpunct_byname;
}

namespace __cxx11 {

  template<typename _CharT>
    class collate;
  template<typename _CharT>
    class collate_byname;
}


  class time_base;
namespace __cxx11 {
  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
    class time_get;
  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
    class time_get_byname;
}
  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
    class time_put;
  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
    class time_put_byname;


  class money_base;
namespace __cxx11 {
  template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> >
    class money_get;
  template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> >
    class money_put;
}
namespace __cxx11 {
  template<typename _CharT, bool _Intl = false>
    class moneypunct;
  template<typename _CharT, bool _Intl = false>
    class moneypunct_byname;
}


  struct messages_base;
namespace __cxx11 {
  template<typename _CharT>
    class messages;
  template<typename _CharT>
    class messages_byname;
}


}
# 43 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/streambuf" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ios_base.h" 1 3
# 38 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ios_base.h" 3

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ext/atomicity.h" 1 3
# 33 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ext/atomicity.h" 3


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/gthr.h" 1 3
# 30 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/gthr.h" 3
#pragma GCC visibility push(default)
# 157 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/gthr.h" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/gthr-default.h" 1 3
# 35 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/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/bin/../lib/clang/18/include/stddef.h" 1 3 4
# 77 "/usr/bin/../lib/clang/18/include/stddef.h" 3 4
# 1 "/usr/bin/../lib/clang/18/include/__stddef_size_t.h" 1 3 4
# 18 "/usr/bin/../lib/clang/18/include/__stddef_size_t.h" 3 4
typedef long unsigned int size_t;
# 78 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3 4
# 92 "/usr/bin/../lib/clang/18/include/stddef.h" 3 4
# 1 "/usr/bin/../lib/clang/18/include/__stddef_null.h" 1 3 4
# 93 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3 4
# 30 "/usr/include/sched.h" 2 3 4
# 43 "/usr/include/sched.h" 3 4
# 1 "/usr/include/bits/sched.h" 1 3 4
# 80 "/usr/include/bits/sched.h" 3 4
# 1 "/usr/include/bits/types/struct_sched_param.h" 1 3 4
# 23 "/usr/include/bits/types/struct_sched_param.h" 3 4
struct sched_param
{
  int sched_priority;
};
# 81 "/usr/include/bits/sched.h" 2 3 4

extern "C" {



extern int clone (int (*__fn) (void *__arg), void *__child_stack,
    int __flags, void *__arg, ...) noexcept (true);


extern int unshare (int __flags) noexcept (true);


extern int sched_getcpu (void) noexcept (true);


extern int getcpu (unsigned int *, unsigned int *) noexcept (true);


extern int setns (int __fd, int __nstype) noexcept (true);


}
# 44 "/usr/include/sched.h" 2 3 4
# 1 "/usr/include/bits/cpu-set.h" 1 3 4
# 32 "/usr/include/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/bits/cpu-set.h" 3 4
extern "C" {

extern int __sched_cpucount (size_t __setsize, const cpu_set_t *__setp)
     noexcept (true);
extern cpu_set_t *__sched_cpualloc (size_t __count) noexcept (true) ;
extern void __sched_cpufree (cpu_set_t *__set) noexcept (true);

}
# 45 "/usr/include/sched.h" 2 3 4






extern "C" {


extern int sched_setparam (__pid_t __pid, const struct sched_param *__param)
     noexcept (true);


extern int sched_getparam (__pid_t __pid, struct sched_param *__param) noexcept (true);


extern int sched_setscheduler (__pid_t __pid, int __policy,
          const struct sched_param *__param) noexcept (true);


extern int sched_getscheduler (__pid_t __pid) noexcept (true);


extern int sched_yield (void) noexcept (true);


extern int sched_get_priority_max (int __algorithm) noexcept (true);


extern int sched_get_priority_min (int __algorithm) noexcept (true);



extern int sched_rr_get_interval (__pid_t __pid, struct timespec *__t) noexcept (true);
# 130 "/usr/include/sched.h" 3 4
extern int sched_setaffinity (__pid_t __pid, size_t __cpusetsize,
         const cpu_set_t *__cpuset) noexcept (true);


extern int sched_getaffinity (__pid_t __pid, size_t __cpusetsize,
         cpu_set_t *__cpuset) noexcept (true);


}
# 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/bin/../lib/clang/18/include/stddef.h" 1 3 4
# 77 "/usr/bin/../lib/clang/18/include/stddef.h" 3 4
# 1 "/usr/bin/../lib/clang/18/include/__stddef_size_t.h" 1 3 4
# 18 "/usr/bin/../lib/clang/18/include/__stddef_size_t.h" 3 4
typedef long unsigned int size_t;
# 78 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3 4
# 92 "/usr/bin/../lib/clang/18/include/stddef.h" 3 4
# 1 "/usr/bin/../lib/clang/18/include/__stddef_null.h" 1 3 4
# 93 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3 4
# 30 "/usr/include/time.h" 2 3 4



# 1 "/usr/include/bits/time.h" 1 3 4
# 73 "/usr/include/bits/time.h" 3 4
# 1 "/usr/include/bits/timex.h" 1 3 4
# 26 "/usr/include/bits/timex.h" 3 4
struct timex
{
# 58 "/usr/include/bits/timex.h" 3 4
  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/bits/time.h" 2 3 4

extern "C" {


extern int clock_adjtime (__clockid_t __clock_id, struct timex *__utx) noexcept (true) __attribute__ ((__nonnull__ (2)));
# 90 "/usr/include/bits/time.h" 3 4
}
# 34 "/usr/include/time.h" 2 3 4





# 1 "/usr/include/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








# 1 "/usr/include/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) noexcept (true);



extern time_t time (time_t *__timer) noexcept (true);


extern double difftime (time_t __time1, time_t __time0)
     noexcept (true) __attribute__ ((__const__));


extern time_t mktime (struct tm *__tp) noexcept (true);
# 100 "/usr/include/time.h" 3 4
extern size_t strftime (char *__restrict __s, size_t __maxsize,
   const char *__restrict __format,
   const struct tm *__restrict __tp)
   noexcept (true) __attribute__ ((__nonnull__ (1, 3, 4)));




extern char *strptime (const char *__restrict __s,
         const char *__restrict __fmt, struct tm *__tp)
     noexcept (true);






extern size_t strftime_l (char *__restrict __s, size_t __maxsize,
     const char *__restrict __format,
     const struct tm *__restrict __tp,
     locale_t __loc) noexcept (true);



extern char *strptime_l (const char *__restrict __s,
    const char *__restrict __fmt, struct tm *__tp,
    locale_t __loc) noexcept (true);






extern struct tm *gmtime (const time_t *__timer) noexcept (true);



extern struct tm *localtime (const time_t *__timer) noexcept (true);
# 155 "/usr/include/time.h" 3 4
extern struct tm *gmtime_r (const time_t *__restrict __timer,
       struct tm *__restrict __tp) noexcept (true);



extern struct tm *localtime_r (const time_t *__restrict __timer,
          struct tm *__restrict __tp) noexcept (true);
# 180 "/usr/include/time.h" 3 4
extern char *asctime (const struct tm *__tp) noexcept (true);



extern char *ctime (const time_t *__timer) noexcept (true);
# 198 "/usr/include/time.h" 3 4
extern char *asctime_r (const struct tm *__restrict __tp,
   char *__restrict __buf) noexcept (true);



extern char *ctime_r (const time_t *__restrict __timer,
        char *__restrict __buf) noexcept (true);
# 218 "/usr/include/time.h" 3 4
extern char *__tzname[2];
extern int __daylight;
extern long int __timezone;




extern char *tzname[2];



extern void tzset (void) noexcept (true);



extern int daylight;
extern long int timezone;
# 247 "/usr/include/time.h" 3 4
extern time_t timegm (struct tm *__tp) noexcept (true);
# 264 "/usr/include/time.h" 3 4
extern time_t timelocal (struct tm *__tp) noexcept (true);







extern int dysize (int __year) noexcept (true) __attribute__ ((__const__));
# 282 "/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) noexcept (true);


extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp)
     noexcept (true) __attribute__ ((__nonnull__ (2)));


extern int clock_settime (clockid_t __clock_id, const struct timespec *__tp)
     noexcept (true) __attribute__ ((__nonnull__ (2)));
# 324 "/usr/include/time.h" 3 4
extern int clock_nanosleep (clockid_t __clock_id, int __flags,
       const struct timespec *__req,
       struct timespec *__rem);
# 339 "/usr/include/time.h" 3 4
extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) noexcept (true);




extern int timer_create (clockid_t __clock_id,
    struct sigevent *__restrict __evp,
    timer_t *__restrict __timerid) noexcept (true);


extern int timer_delete (timer_t __timerid) noexcept (true);



extern int timer_settime (timer_t __timerid, int __flags,
     const struct itimerspec *__restrict __value,
     struct itimerspec *__restrict __ovalue) noexcept (true);


extern int timer_gettime (timer_t __timerid, struct itimerspec *__value)
     noexcept (true);
# 377 "/usr/include/time.h" 3 4
extern int timer_getoverrun (timer_t __timerid) noexcept (true);






extern int timespec_get (struct timespec *__ts, int __base)
     noexcept (true) __attribute__ ((__nonnull__ (1)));
# 400 "/usr/include/time.h" 3 4
extern int timespec_getres (struct timespec *__ts, int __base)
     noexcept (true);
# 426 "/usr/include/time.h" 3 4
extern int getdate_err;
# 435 "/usr/include/time.h" 3 4
extern struct tm *getdate (const char *__string);
# 449 "/usr/include/time.h" 3 4
extern int getdate_r (const char *__restrict __string,
        struct tm *__restrict __resbufp);


}
# 24 "/usr/include/pthread.h" 2 3 4



# 1 "/usr/include/bits/setjmp.h" 1 3 4
# 26 "/usr/include/bits/setjmp.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 27 "/usr/include/bits/setjmp.h" 2 3 4




typedef long int __jmp_buf[8];
# 28 "/usr/include/pthread.h" 2 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 29 "/usr/include/pthread.h" 2 3 4


# 1 "/usr/include/bits/types/struct___jmp_buf_tag.h" 1 3 4
# 26 "/usr/include/bits/types/struct___jmp_buf_tag.h" 3 4
struct __jmp_buf_tag
  {




    __jmp_buf __jmpbuf;
    int __mask_was_saved;
    __sigset_t __saved_mask;
  };
# 32 "/usr/include/pthread.h" 2 3 4

# 1 "/usr/include/bits/pthread_stack_min-dynamic.h" 1 3 4
# 23 "/usr/include/bits/pthread_stack_min-dynamic.h" 3 4
extern "C" {
extern long int __sysconf (int __name) noexcept (true);
}
# 34 "/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
};
# 104 "/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
};
# 124 "/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

};
# 159 "/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

};
# 197 "/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) noexcept (true) __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) noexcept (true);
# 233 "/usr/include/pthread.h" 3 4
extern int pthread_timedjoin_np (pthread_t __th, void **__thread_return,
     const struct timespec *__abstime);
# 243 "/usr/include/pthread.h" 3 4
extern int pthread_clockjoin_np (pthread_t __th, void **__thread_return,
                                 clockid_t __clockid,
     const struct timespec *__abstime);
# 269 "/usr/include/pthread.h" 3 4
extern int pthread_detach (pthread_t __th) noexcept (true);



extern pthread_t pthread_self (void) noexcept (true) __attribute__ ((__const__));


extern int pthread_equal (pthread_t __thread1, pthread_t __thread2)
  noexcept (true) __attribute__ ((__const__));







extern int pthread_attr_init (pthread_attr_t *__attr) noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_attr_destroy (pthread_attr_t *__attr)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_attr_getdetachstate (const pthread_attr_t *__attr,
     int *__detachstate)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_attr_setdetachstate (pthread_attr_t *__attr,
     int __detachstate)
     noexcept (true) __attribute__ ((__nonnull__ (1)));



extern int pthread_attr_getguardsize (const pthread_attr_t *__attr,
          size_t *__guardsize)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_attr_setguardsize (pthread_attr_t *__attr,
          size_t __guardsize)
     noexcept (true) __attribute__ ((__nonnull__ (1)));



extern int pthread_attr_getschedparam (const pthread_attr_t *__restrict __attr,
           struct sched_param *__restrict __param)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_attr_setschedparam (pthread_attr_t *__restrict __attr,
           const struct sched_param *__restrict
           __param) noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_attr_getschedpolicy (const pthread_attr_t *__restrict
     __attr, int *__restrict __policy)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_attr_setschedpolicy (pthread_attr_t *__attr, int __policy)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_attr_getinheritsched (const pthread_attr_t *__restrict
      __attr, int *__restrict __inherit)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_attr_setinheritsched (pthread_attr_t *__attr,
      int __inherit)
     noexcept (true) __attribute__ ((__nonnull__ (1)));



extern int pthread_attr_getscope (const pthread_attr_t *__restrict __attr,
      int *__restrict __scope)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_attr_setscope (pthread_attr_t *__attr, int __scope)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_attr_getstackaddr (const pthread_attr_t *__restrict
          __attr, void **__restrict __stackaddr)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__deprecated__));





extern int pthread_attr_setstackaddr (pthread_attr_t *__attr,
          void *__stackaddr)
     noexcept (true) __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__));


extern int pthread_attr_getstacksize (const pthread_attr_t *__restrict
          __attr, size_t *__restrict __stacksize)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));




extern int pthread_attr_setstacksize (pthread_attr_t *__attr,
          size_t __stacksize)
     noexcept (true) __attribute__ ((__nonnull__ (1)));



extern int pthread_attr_getstack (const pthread_attr_t *__restrict __attr,
      void **__restrict __stackaddr,
      size_t *__restrict __stacksize)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2, 3)));




extern int pthread_attr_setstack (pthread_attr_t *__attr, void *__stackaddr,
      size_t __stacksize) noexcept (true) __attribute__ ((__nonnull__ (1)));





extern int pthread_attr_setaffinity_np (pthread_attr_t *__attr,
     size_t __cpusetsize,
     const cpu_set_t *__cpuset)
     noexcept (true) __attribute__ ((__nonnull__ (1, 3)));



extern int pthread_attr_getaffinity_np (const pthread_attr_t *__attr,
     size_t __cpusetsize,
     cpu_set_t *__cpuset)
     noexcept (true) __attribute__ ((__nonnull__ (1, 3)));


extern int pthread_getattr_default_np (pthread_attr_t *__attr)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_attr_setsigmask_np (pthread_attr_t *__attr,
           const __sigset_t *sigmask);




extern int pthread_attr_getsigmask_np (const pthread_attr_t *__attr,
           __sigset_t *sigmask);







extern int pthread_setattr_default_np (const pthread_attr_t *__attr)
     noexcept (true) __attribute__ ((__nonnull__ (1)));




extern int pthread_getattr_np (pthread_t __th, pthread_attr_t *__attr)
     noexcept (true) __attribute__ ((__nonnull__ (2)));







extern int pthread_setschedparam (pthread_t __target_thread, int __policy,
      const struct sched_param *__param)
     noexcept (true) __attribute__ ((__nonnull__ (3)));


extern int pthread_getschedparam (pthread_t __target_thread,
      int *__restrict __policy,
      struct sched_param *__restrict __param)
     noexcept (true) __attribute__ ((__nonnull__ (2, 3)));


extern int pthread_setschedprio (pthread_t __target_thread, int __prio)
     noexcept (true);




extern int pthread_getname_np (pthread_t __target_thread, char *__buf,
          size_t __buflen)
     noexcept (true) __attribute__ ((__nonnull__ (2)));


extern int pthread_setname_np (pthread_t __target_thread, const char *__name)
     noexcept (true) __attribute__ ((__nonnull__ (2)));





extern int pthread_getconcurrency (void) noexcept (true);


extern int pthread_setconcurrency (int __level) noexcept (true);



extern int pthread_yield (void) noexcept (true);

extern int pthread_yield (void) noexcept (true) __asm__ ("" "sched_yield")
  __attribute__ ((__deprecated__ ("pthread_yield is deprecated, use sched_yield instead")));
# 489 "/usr/include/pthread.h" 3 4
extern int pthread_setaffinity_np (pthread_t __th, size_t __cpusetsize,
       const cpu_set_t *__cpuset)
     noexcept (true) __attribute__ ((__nonnull__ (3)));


extern int pthread_getaffinity_np (pthread_t __th, size_t __cpusetsize,
       cpu_set_t *__cpuset)
     noexcept (true) __attribute__ ((__nonnull__ (3)));
# 509 "/usr/include/pthread.h" 3 4
extern int pthread_once (pthread_once_t *__once_control,
    void (*__init_routine) (void)) __attribute__ ((__nonnull__ (1, 2)));
# 521 "/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);




struct __cancel_jmp_buf_tag
{
  __jmp_buf __cancel_jmp_buf;
  int __mask_was_saved;
};

typedef struct
{
  struct __cancel_jmp_buf_tag __cancel_jmp_buf[1];
  void *__pad[4];
} __pthread_unwind_buf_t __attribute__ ((__aligned__));
# 557 "/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); }
};
# 773 "/usr/include/pthread.h" 3 4
extern int __sigsetjmp (struct __jmp_buf_tag __env[1],
   int __savemask) noexcept (true);






extern int pthread_mutex_init (pthread_mutex_t *__mutex,
          const pthread_mutexattr_t *__mutexattr)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_mutex_destroy (pthread_mutex_t *__mutex)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_mutex_trylock (pthread_mutex_t *__mutex)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_mutex_lock (pthread_mutex_t *__mutex)
     noexcept (true) __attribute__ ((__nonnull__ (1)));




extern int pthread_mutex_timedlock (pthread_mutex_t *__restrict __mutex,
        const struct timespec *__restrict
        __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
# 817 "/usr/include/pthread.h" 3 4
extern int pthread_mutex_clocklock (pthread_mutex_t *__restrict __mutex,
        clockid_t __clockid,
        const struct timespec *__restrict
        __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 3)));
# 835 "/usr/include/pthread.h" 3 4
extern int pthread_mutex_unlock (pthread_mutex_t *__mutex)
     noexcept (true) __attribute__ ((__nonnull__ (1)));



extern int pthread_mutex_getprioceiling (const pthread_mutex_t *
      __restrict __mutex,
      int *__restrict __prioceiling)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));



extern int pthread_mutex_setprioceiling (pthread_mutex_t *__restrict __mutex,
      int __prioceiling,
      int *__restrict __old_ceiling)
     noexcept (true) __attribute__ ((__nonnull__ (1, 3)));




extern int pthread_mutex_consistent (pthread_mutex_t *__mutex)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_mutex_consistent_np (pthread_mutex_t *) noexcept (true) __asm__ ("" "pthread_mutex_consistent") __attribute__ ((__nonnull__ (1)))

  __attribute__ ((__deprecated__ ("pthread_mutex_consistent_np is deprecated, use pthread_mutex_consistent")));
# 874 "/usr/include/pthread.h" 3 4
extern int pthread_mutexattr_init (pthread_mutexattr_t *__attr)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_mutexattr_destroy (pthread_mutexattr_t *__attr)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_mutexattr_getpshared (const pthread_mutexattr_t *
      __restrict __attr,
      int *__restrict __pshared)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_mutexattr_setpshared (pthread_mutexattr_t *__attr,
      int __pshared)
     noexcept (true) __attribute__ ((__nonnull__ (1)));



extern int pthread_mutexattr_gettype (const pthread_mutexattr_t *__restrict
          __attr, int *__restrict __kind)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));




extern int pthread_mutexattr_settype (pthread_mutexattr_t *__attr, int __kind)
     noexcept (true) __attribute__ ((__nonnull__ (1)));



extern int pthread_mutexattr_getprotocol (const pthread_mutexattr_t *
       __restrict __attr,
       int *__restrict __protocol)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));



extern int pthread_mutexattr_setprotocol (pthread_mutexattr_t *__attr,
       int __protocol)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_mutexattr_getprioceiling (const pthread_mutexattr_t *
          __restrict __attr,
          int *__restrict __prioceiling)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_mutexattr_setprioceiling (pthread_mutexattr_t *__attr,
          int __prioceiling)
     noexcept (true) __attribute__ ((__nonnull__ (1)));



extern int pthread_mutexattr_getrobust (const pthread_mutexattr_t *__attr,
     int *__robustness)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_mutexattr_getrobust_np (pthread_mutexattr_t *, int *) noexcept (true) __asm__ ("" "pthread_mutexattr_getrobust") __attribute__ ((__nonnull__ (1)))


  __attribute__ ((__deprecated__ ("pthread_mutexattr_getrobust_np is deprecated, use pthread_mutexattr_getrobust")));







extern int pthread_mutexattr_setrobust (pthread_mutexattr_t *__attr,
     int __robustness)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_mutexattr_setrobust_np (pthread_mutexattr_t *, int) noexcept (true) __asm__ ("" "pthread_mutexattr_setrobust") __attribute__ ((__nonnull__ (1)))


  __attribute__ ((__deprecated__ ("pthread_mutexattr_setrobust_np is deprecated, use pthread_mutexattr_setrobust")));
# 967 "/usr/include/pthread.h" 3 4
extern int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock,
    const pthread_rwlockattr_t *__restrict
    __attr) noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock)
  noexcept (true) __attribute__ ((__nonnull__ (1)));




extern int pthread_rwlock_timedrdlock (pthread_rwlock_t *__restrict __rwlock,
           const struct timespec *__restrict
           __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
# 1004 "/usr/include/pthread.h" 3 4
extern int pthread_rwlock_clockrdlock (pthread_rwlock_t *__restrict __rwlock,
           clockid_t __clockid,
           const struct timespec *__restrict
           __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 3)));
# 1023 "/usr/include/pthread.h" 3 4
extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock)
     noexcept (true) __attribute__ ((__nonnull__ (1)));




extern int pthread_rwlock_timedwrlock (pthread_rwlock_t *__restrict __rwlock,
           const struct timespec *__restrict
           __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
# 1051 "/usr/include/pthread.h" 3 4
extern int pthread_rwlock_clockwrlock (pthread_rwlock_t *__restrict __rwlock,
           clockid_t __clockid,
           const struct timespec *__restrict
           __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 3)));
# 1071 "/usr/include/pthread.h" 3 4
extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock)
     noexcept (true) __attribute__ ((__nonnull__ (1)));





extern int pthread_rwlockattr_init (pthread_rwlockattr_t *__attr)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_rwlockattr_getpshared (const pthread_rwlockattr_t *
       __restrict __attr,
       int *__restrict __pshared)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr,
       int __pshared)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_rwlockattr_getkind_np (const pthread_rwlockattr_t *
       __restrict __attr,
       int *__restrict __pref)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *__attr,
       int __pref) noexcept (true) __attribute__ ((__nonnull__ (1)));







extern int pthread_cond_init (pthread_cond_t *__restrict __cond,
         const pthread_condattr_t *__restrict __cond_attr)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_cond_destroy (pthread_cond_t *__cond)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_cond_signal (pthread_cond_t *__cond)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_cond_broadcast (pthread_cond_t *__cond)
     noexcept (true) __attribute__ ((__nonnull__ (1)));






extern int pthread_cond_wait (pthread_cond_t *__restrict __cond,
         pthread_mutex_t *__restrict __mutex)
     __attribute__ ((__nonnull__ (1, 2)));
# 1145 "/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)));
# 1171 "/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)));
# 1194 "/usr/include/pthread.h" 3 4
extern int pthread_condattr_init (pthread_condattr_t *__attr)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_condattr_destroy (pthread_condattr_t *__attr)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_condattr_getpshared (const pthread_condattr_t *
     __restrict __attr,
     int *__restrict __pshared)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_condattr_setpshared (pthread_condattr_t *__attr,
     int __pshared) noexcept (true) __attribute__ ((__nonnull__ (1)));



extern int pthread_condattr_getclock (const pthread_condattr_t *
          __restrict __attr,
          __clockid_t *__restrict __clock_id)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_condattr_setclock (pthread_condattr_t *__attr,
          __clockid_t __clock_id)
     noexcept (true) __attribute__ ((__nonnull__ (1)));
# 1230 "/usr/include/pthread.h" 3 4
extern int pthread_spin_init (pthread_spinlock_t *__lock, int __pshared)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_spin_destroy (pthread_spinlock_t *__lock)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_spin_lock (pthread_spinlock_t *__lock)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_spin_trylock (pthread_spinlock_t *__lock)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_spin_unlock (pthread_spinlock_t *__lock)
     noexcept (true) __attribute__ ((__nonnull__ (1)));






extern int pthread_barrier_init (pthread_barrier_t *__restrict __barrier,
     const pthread_barrierattr_t *__restrict
     __attr, unsigned int __count)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_barrier_destroy (pthread_barrier_t *__barrier)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_barrier_wait (pthread_barrier_t *__barrier)
     noexcept (true) __attribute__ ((__nonnull__ (1)));



extern int pthread_barrierattr_init (pthread_barrierattr_t *__attr)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_barrierattr_destroy (pthread_barrierattr_t *__attr)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_barrierattr_getpshared (const pthread_barrierattr_t *
        __restrict __attr,
        int *__restrict __pshared)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern int pthread_barrierattr_setpshared (pthread_barrierattr_t *__attr,
        int __pshared)
     noexcept (true) __attribute__ ((__nonnull__ (1)));
# 1297 "/usr/include/pthread.h" 3 4
extern int pthread_key_create (pthread_key_t *__key,
          void (*__destr_function) (void *))
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int pthread_key_delete (pthread_key_t __key) noexcept (true);


extern void *pthread_getspecific (pthread_key_t __key) noexcept (true);


extern int pthread_setspecific (pthread_key_t __key,
    const void *__pointer)
  noexcept (true) ;




extern int pthread_getcpuclockid (pthread_t __thread_id,
      __clockid_t *__clock_id)
     noexcept (true) __attribute__ ((__nonnull__ (2)));
# 1332 "/usr/include/pthread.h" 3 4
extern int pthread_atfork (void (*__prepare) (void),
      void (*__parent) (void),
      void (*__child) (void)) noexcept (true);




extern __inline __attribute__ ((__gnu_inline__)) int
 pthread_equal (pthread_t __thread1, pthread_t __thread2) noexcept (true)
{
  return __thread1 == __thread2;
}


}
# 36 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/gthr-default.h" 2 3
# 47 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/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;
# 312 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/gthr-default.h" 3
static inline int
__gthread_active_p (void)
{
  return 1;
}
# 672 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/gthr-default.h" 3
static inline int
__gthread_create (__gthread_t *__threadid, void *(*__func) (void*),
    void *__args)
{
  return pthread_create (__threadid, __null, __func, __args);
}

static inline int
__gthread_join (__gthread_t __threadid, void **__value_ptr)
{
  return pthread_join (__threadid, __value_ptr);
}

static inline int
__gthread_detach (__gthread_t __threadid)
{
  return pthread_detach (__threadid);
}

static inline int
__gthread_equal (__gthread_t __t1, __gthread_t __t2)
{
  return pthread_equal (__t1, __t2);
}

static inline __gthread_t
__gthread_self (void)
{
  return pthread_self ();
}

static inline int
__gthread_yield (void)
{
  return sched_yield ();
}

static inline int
__gthread_once (__gthread_once_t *__once, void (*__func) (void))
{
  if (__gthread_active_p ())
    return pthread_once (__once, __func);
  else
    return -1;
}

static inline int
__gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *))
{
  return pthread_key_create (__key, __dtor);
}

static inline int
__gthread_key_delete (__gthread_key_t __key)
{
  return pthread_key_delete (__key);
}

static inline void *
__gthread_getspecific (__gthread_key_t __key)
{
  return pthread_getspecific (__key);
}

static inline int
__gthread_setspecific (__gthread_key_t __key, const void *__ptr)
{
  return pthread_setspecific (__key, __ptr);
}

static inline void
__gthread_mutex_init_function (__gthread_mutex_t *__mutex)
{
  if (__gthread_active_p ())
    pthread_mutex_init (__mutex, __null);
}

static inline int
__gthread_mutex_destroy (__gthread_mutex_t *__mutex)
{
  if (__gthread_active_p ())
    return pthread_mutex_destroy (__mutex);
  else
    return 0;
}

static inline int
__gthread_mutex_lock (__gthread_mutex_t *__mutex)
{
  if (__gthread_active_p ())
    return pthread_mutex_lock (__mutex);
  else
    return 0;
}

static inline int
__gthread_mutex_trylock (__gthread_mutex_t *__mutex)
{
  if (__gthread_active_p ())
    return 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 pthread_mutex_timedlock (__mutex, __abs_timeout);
  else
    return 0;
}


static inline int
__gthread_mutex_unlock (__gthread_mutex_t *__mutex)
{
  if (__gthread_active_p ())
    return pthread_mutex_unlock (__mutex);
  else
    return 0;
}
# 821 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/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);
}
# 863 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/gthr-default.h" 3
static inline int
__gthread_cond_broadcast (__gthread_cond_t *__cond)
{
  return pthread_cond_broadcast (__cond);
}

static inline int
__gthread_cond_signal (__gthread_cond_t *__cond)
{
  return pthread_cond_signal (__cond);
}

static inline int
__gthread_cond_wait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex)
{
  return 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 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 pthread_cond_destroy (__cond);
}
# 158 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/gthr.h" 2 3


#pragma GCC visibility pop
# 36 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ext/atomicity.h" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/atomic_word.h" 1 3
# 32 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/atomic_word.h" 3
typedef int _Atomic_word;
# 37 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ext/atomicity.h" 2 3

# 1 "/usr/include/sys/single_threaded.h" 1 3 4
# 24 "/usr/include/sys/single_threaded.h" 3 4
extern "C" {




extern char __libc_single_threaded;

}
# 39 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ext/atomicity.h" 2 3


namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{


  __attribute__((__always_inline__))
  inline bool
  __is_single_threaded() noexcept
  {



    return ::__libc_single_threaded;



  }






  inline _Atomic_word
  __attribute__((__always_inline__))
  __exchange_and_add(volatile _Atomic_word* __mem, int __val)
  { return __atomic_fetch_add(__mem, __val, 4); }

  inline void
  __attribute__((__always_inline__))
  __atomic_add(volatile _Atomic_word* __mem, int __val)
  { __atomic_fetch_add(__mem, __val, 4); }
# 80 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ext/atomicity.h" 3
  inline _Atomic_word
  __attribute__((__always_inline__))
  __exchange_and_add_single(_Atomic_word* __mem, int __val)
  {
    _Atomic_word __result = *__mem;
    *__mem += __val;
    return __result;
  }

  inline void
  __attribute__((__always_inline__))
  __atomic_add_single(_Atomic_word* __mem, int __val)
  { *__mem += __val; }

  inline _Atomic_word
  __attribute__ ((__always_inline__))
  __exchange_and_add_dispatch(_Atomic_word* __mem, int __val)
  {
    if (__is_single_threaded())
      return __exchange_and_add_single(__mem, __val);
    else
      return __exchange_and_add(__mem, __val);
  }

  inline void
  __attribute__ ((__always_inline__))
  __atomic_add_dispatch(_Atomic_word* __mem, int __val)
  {
    if (__is_single_threaded())
      __atomic_add_single(__mem, __val);
    else
      __atomic_add(__mem, __val);
  }


}
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ios_base.h" 2 3

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_classes.h" 1 3
# 38 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_classes.h" 3


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/string" 1 3
# 37 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/string" 3





# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/char_traits.h" 1 3
# 38 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/char_traits.h" 3








# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cwchar" 1 3
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cwchar" 3
# 47 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/char_traits.h" 2 3
# 64 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/char_traits.h" 3
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{


#pragma GCC diagnostic push


#pragma GCC diagnostic ignored "-Warray-bounds"
# 83 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/char_traits.h" 3
  template<typename _CharT>
    struct _Char_types
    {
      typedef unsigned long int_type;

      typedef std::streampos pos_type;
      typedef std::streamoff off_type;
      typedef std::mbstate_t state_type;

    };
# 110 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/char_traits.h" 3
  template<typename _CharT>
    struct char_traits
    {
      typedef _CharT char_type;
      typedef typename _Char_types<_CharT>::int_type int_type;

      typedef typename _Char_types<_CharT>::pos_type pos_type;
      typedef typename _Char_types<_CharT>::off_type off_type;
      typedef typename _Char_types<_CharT>::state_type state_type;


      using comparison_category = std::strong_ordering;


      static constexpr void
      assign(char_type& __c1, const char_type& __c2)
      {

 if (std::__is_constant_evaluated())
   std::construct_at(__builtin_addressof(__c1), __c2);
 else

 __c1 = __c2;
      }

      static constexpr bool
      eq(const char_type& __c1, const char_type& __c2)
      { 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<char_type>(__c); }

      static constexpr int_type
      to_int_type(const char_type& __c)
      { return static_cast<int_type>(__c); }

      static constexpr bool
      eq_int_type(const int_type& __c1, const int_type& __c2)
      { return __c1 == __c2; }


      static constexpr int_type
      eof()
      { return static_cast<int_type>(-1); }

      static constexpr int_type
      not_eof(const int_type& __c)
      { return !eq_int_type(__c, eof()) ? __c : to_int_type(char_type()); }

    };

  template<typename _CharT>
    constexpr int
    char_traits<_CharT>::
    compare(const char_type* __s1, const char_type* __s2, std::size_t __n)
    {
      for (std::size_t __i = 0; __i < __n; ++__i)
 if (lt(__s1[__i], __s2[__i]))
   return -1;
 else if (lt(__s2[__i], __s1[__i]))
   return 1;
      return 0;
    }

  template<typename _CharT>
    constexpr std::size_t
    char_traits<_CharT>::
    length(const char_type* __p)
    {
      std::size_t __i = 0;
      while (!eq(__p[__i], char_type()))
        ++__i;
      return __i;
    }

  template<typename _CharT>
    constexpr const typename char_traits<_CharT>::char_type*
    char_traits<_CharT>::
    find(const char_type* __s, std::size_t __n, const char_type& __a)
    {
      for (std::size_t __i = 0; __i < __n; ++__i)
        if (eq(__s[__i], __a))
          return __s + __i;
      return 0;
    }

  template<typename _CharT>
    constexpr
    typename char_traits<_CharT>::char_type*
    char_traits<_CharT>::
    move(char_type* __s1, const char_type* __s2, std::size_t __n)
    {
      if (__n == 0)
 return __s1;

      if (std::__is_constant_evaluated())
 {

   if (__builtin_constant_p(__s2 < __s1)
  && __s1 > __s2 && __s1 < (__s2 + __n))
     {
       do
  {
    --__n;
    assign(__s1[__n], __s2[__n]);
  }
       while (__n > 0);
     }
   else
     copy(__s1, __s2, __n);
   return __s1;
 }

      __builtin_memmove(__s1, __s2, __n * sizeof(char_type));
      return __s1;
    }

  template<typename _CharT>
    constexpr
    typename char_traits<_CharT>::char_type*
    char_traits<_CharT>::
    copy(char_type* __s1, const char_type* __s2, std::size_t __n)
    {
      if (__n == 0)
 return __s1;

      if (std::__is_constant_evaluated())
 {
   for (std::size_t __i = 0; __i < __n; ++__i)
     std::construct_at(__s1 + __i, __s2[__i]);
   return __s1;
 }

      __builtin_memcpy(__s1, __s2, __n * sizeof(char_type));
      return __s1;
    }

  template<typename _CharT>
    constexpr
    typename char_traits<_CharT>::char_type*
    char_traits<_CharT>::
    assign(char_type* __s, std::size_t __n, char_type __a)
    {

      if (std::__is_constant_evaluated())
 {
   for (std::size_t __i = 0; __i < __n; ++__i)
     std::construct_at(__s + __i, __a);
   return __s;
 }


      if constexpr (sizeof(_CharT) == 1 && __is_trivial(_CharT))
 {
   if (__n)
     {
       unsigned char __c;
       __builtin_memcpy(&__c, __builtin_addressof(__a), 1);
       __builtin_memset(__s, __c, __n);
     }
 }
      else
 {
   for (std::size_t __i = 0; __i < __n; ++__i)
     __s[__i] = __a;
 }
      return __s;
    }


}

namespace std __attribute__ ((__visibility__ ("default")))
{
# 322 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/char_traits.h" 3
  template<typename _CharT>
    struct char_traits : public __gnu_cxx::char_traits<_CharT>
    { };



  template<>
    struct char_traits<char>
    {
      typedef char char_type;
      typedef int int_type;

      typedef streampos pos_type;
      typedef streamoff off_type;
      typedef mbstate_t state_type;


      using comparison_category = strong_ordering;


      static constexpr void
      assign(char_type& __c1, const char_type& __c2) noexcept
      {

 if (std::__is_constant_evaluated())
   std::construct_at(__builtin_addressof(__c1), __c2);
 else

 __c1 = __c2;
      }

      static constexpr bool
      eq(const char_type& __c1, const char_type& __c2) noexcept
      { return __c1 == __c2; }

      static constexpr bool
      lt(const char_type& __c1, const char_type& __c2) noexcept
      {

 return (static_cast<unsigned char>(__c1)
  < static_cast<unsigned char>(__c2));
      }

      static constexpr int
      compare(const char_type* __s1, const char_type* __s2, size_t __n)
      {
 if (__n == 0)
   return 0;

 if (std::__is_constant_evaluated())
   {
     for (size_t __i = 0; __i < __n; ++__i)
       if (lt(__s1[__i], __s2[__i]))
  return -1;
       else if (lt(__s2[__i], __s1[__i]))
  return 1;
     return 0;
   }

 return __builtin_memcmp(__s1, __s2, __n);
      }

      static constexpr size_t
      length(const char_type* __s)
      {

 if (std::__is_constant_evaluated())
   return __gnu_cxx::char_traits<char_type>::length(__s);

 return __builtin_strlen(__s);
      }

      static constexpr const char_type*
      find(const char_type* __s, size_t __n, const char_type& __a)
      {
 if (__n == 0)
   return 0;

 if (std::__is_constant_evaluated())
   return __gnu_cxx::char_traits<char_type>::find(__s, __n, __a);

 return static_cast<const char_type*>(__builtin_memchr(__s, __a, __n));
      }

      static constexpr char_type*
      move(char_type* __s1, const char_type* __s2, size_t __n)
      {
 if (__n == 0)
   return __s1;

 if (std::__is_constant_evaluated())
   return __gnu_cxx::char_traits<char_type>::move(__s1, __s2, __n);

 return static_cast<char_type*>(__builtin_memmove(__s1, __s2, __n));
      }

      static constexpr char_type*
      copy(char_type* __s1, const char_type* __s2, size_t __n)
      {
 if (__n == 0)
   return __s1;

 if (std::__is_constant_evaluated())
   return __gnu_cxx::char_traits<char_type>::copy(__s1, __s2, __n);

 return static_cast<char_type*>(__builtin_memcpy(__s1, __s2, __n));
      }

      static constexpr char_type*
      assign(char_type* __s, size_t __n, char_type __a)
      {
 if (__n == 0)
   return __s;

 if (std::__is_constant_evaluated())
   return __gnu_cxx::char_traits<char_type>::assign(__s, __n, __a);

 return static_cast<char_type*>(__builtin_memset(__s, __a, __n));
      }

      static constexpr char_type
      to_char_type(const int_type& __c) noexcept
      { return static_cast<char_type>(__c); }



      static constexpr int_type
      to_int_type(const char_type& __c) noexcept
      { return static_cast<int_type>(static_cast<unsigned char>(__c)); }

      static constexpr bool
      eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
      { return __c1 == __c2; }


      static constexpr int_type
      eof() noexcept
      { return static_cast<int_type>(-1); }

      static constexpr int_type
      not_eof(const int_type& __c) noexcept
      { return (__c == eof()) ? 0 : __c; }

  };




  template<>
    struct char_traits<wchar_t>
    {
      typedef wchar_t char_type;
      typedef wint_t int_type;

      typedef streamoff off_type;
      typedef wstreampos pos_type;
      typedef mbstate_t state_type;


      using comparison_category = strong_ordering;


      static constexpr void
      assign(char_type& __c1, const char_type& __c2) noexcept
      {

 if (std::__is_constant_evaluated())
   std::construct_at(__builtin_addressof(__c1), __c2);
 else

 __c1 = __c2;
      }

      static constexpr bool
      eq(const char_type& __c1, const char_type& __c2) noexcept
      { return __c1 == __c2; }

      static constexpr bool
      lt(const char_type& __c1, const char_type& __c2) noexcept
      { return __c1 < __c2; }

      static constexpr int
      compare(const char_type* __s1, const char_type* __s2, size_t __n)
      {
 if (__n == 0)
   return 0;

 if (std::__is_constant_evaluated())
   return __gnu_cxx::char_traits<char_type>::compare(__s1, __s2, __n);

 return wmemcmp(__s1, __s2, __n);
      }

      static constexpr size_t
      length(const char_type* __s)
      {

 if (std::__is_constant_evaluated())
   return __gnu_cxx::char_traits<char_type>::length(__s);

 return wcslen(__s);
      }

      static constexpr const char_type*
      find(const char_type* __s, size_t __n, const char_type& __a)
      {
 if (__n == 0)
   return 0;

 if (std::__is_constant_evaluated())
   return __gnu_cxx::char_traits<char_type>::find(__s, __n, __a);

 return wmemchr(__s, __a, __n);
      }

      static constexpr char_type*
      move(char_type* __s1, const char_type* __s2, size_t __n)
      {
 if (__n == 0)
   return __s1;

 if (std::__is_constant_evaluated())
   return __gnu_cxx::char_traits<char_type>::move(__s1, __s2, __n);

 return wmemmove(__s1, __s2, __n);
      }

      static constexpr char_type*
      copy(char_type* __s1, const char_type* __s2, size_t __n)
      {
 if (__n == 0)
   return __s1;

 if (std::__is_constant_evaluated())
   return __gnu_cxx::char_traits<char_type>::copy(__s1, __s2, __n);

 return wmemcpy(__s1, __s2, __n);
      }

      static constexpr char_type*
      assign(char_type* __s, size_t __n, char_type __a)
      {
 if (__n == 0)
   return __s;

 if (std::__is_constant_evaluated())
   return __gnu_cxx::char_traits<char_type>::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<int_type>((0xffffffffu)); }

      static constexpr int_type
      not_eof(const int_type& __c) noexcept
      { return eq_int_type(__c, eof()) ? 0 : __c; }

  };







  template<>
    struct char_traits<char8_t>
    {
      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
      {

 if (std::__is_constant_evaluated())
   std::construct_at(__builtin_addressof(__c1), __c2);
 else

 __c1 = __c2;
      }

      static constexpr bool
      eq(const char_type& __c1, const char_type& __c2) noexcept
      { return __c1 == __c2; }

      static constexpr bool
      lt(const char_type& __c1, const char_type& __c2) noexcept
      { return __c1 < __c2; }

      static constexpr int
      compare(const char_type* __s1, const char_type* __s2, size_t __n)
      {
 if (__n == 0)
   return 0;

 if (std::__is_constant_evaluated())
   return __gnu_cxx::char_traits<char_type>::compare(__s1, __s2, __n);

 return __builtin_memcmp(__s1, __s2, __n);
      }

      static constexpr size_t
      length(const char_type* __s)
      {

 if (std::__is_constant_evaluated())
   return __gnu_cxx::char_traits<char_type>::length(__s);

 size_t __i = 0;
 while (!eq(__s[__i], char_type()))
   ++__i;
 return __i;
      }

      static constexpr const char_type*
      find(const char_type* __s, size_t __n, const char_type& __a)
      {
 if (__n == 0)
   return 0;

 if (std::__is_constant_evaluated())
   return __gnu_cxx::char_traits<char_type>::find(__s, __n, __a);

 return static_cast<const char_type*>(__builtin_memchr(__s, __a, __n));
      }

      static constexpr char_type*
      move(char_type* __s1, const char_type* __s2, size_t __n)
      {
 if (__n == 0)
   return __s1;

 if (std::__is_constant_evaluated())
   return __gnu_cxx::char_traits<char_type>::move(__s1, __s2, __n);

 return static_cast<char_type*>(__builtin_memmove(__s1, __s2, __n));
      }

      static constexpr char_type*
      copy(char_type* __s1, const char_type* __s2, size_t __n)
      {
 if (__n == 0)
   return __s1;

 if (std::__is_constant_evaluated())
   return __gnu_cxx::char_traits<char_type>::copy(__s1, __s2, __n);

 return static_cast<char_type*>(__builtin_memcpy(__s1, __s2, __n));
      }

      static constexpr char_type*
      assign(char_type* __s, size_t __n, char_type __a)
      {
 if (__n == 0)
   return __s;

 if (std::__is_constant_evaluated())
   return __gnu_cxx::char_traits<char_type>::assign(__s, __n, __a);

 return static_cast<char_type*>(__builtin_memset(__s, __a, __n));
      }

      static constexpr char_type
      to_char_type(const int_type& __c) noexcept
      { return char_type(__c); }

      static constexpr int_type
      to_int_type(const char_type& __c) noexcept
      { return int_type(__c); }

      static constexpr bool
      eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
      { return __c1 == __c2; }


      static constexpr int_type
      eof() noexcept
      { return static_cast<int_type>(-1); }

      static constexpr int_type
      not_eof(const int_type& __c) noexcept
      { return eq_int_type(__c, eof()) ? 0 : __c; }

    };



}



namespace std __attribute__ ((__visibility__ ("default")))
{


  template<>
    struct char_traits<char16_t>
    {
      typedef char16_t char_type;

      typedef unsigned short int_type;




      typedef streamoff off_type;
      typedef u16streampos pos_type;
      typedef mbstate_t state_type;


      using comparison_category = strong_ordering;


      static constexpr void
      assign(char_type& __c1, const char_type& __c2) noexcept
      {

 if (std::__is_constant_evaluated())
   std::construct_at(__builtin_addressof(__c1), __c2);
 else

 __c1 = __c2;
      }

      static constexpr bool
      eq(const char_type& __c1, const char_type& __c2) noexcept
      { return __c1 == __c2; }

      static constexpr bool
      lt(const char_type& __c1, const char_type& __c2) noexcept
      { return __c1 < __c2; }

      static constexpr int
      compare(const char_type* __s1, const char_type* __s2, size_t __n)
      {
 for (size_t __i = 0; __i < __n; ++__i)
   if (lt(__s1[__i], __s2[__i]))
     return -1;
   else if (lt(__s2[__i], __s1[__i]))
     return 1;
 return 0;
      }

      static constexpr size_t
      length(const char_type* __s)
      {
 size_t __i = 0;
 while (!eq(__s[__i], char_type()))
   ++__i;
 return __i;
      }

      static constexpr const char_type*
      find(const char_type* __s, size_t __n, const char_type& __a)
      {
 for (size_t __i = 0; __i < __n; ++__i)
   if (eq(__s[__i], __a))
     return __s + __i;
 return 0;
      }

      static constexpr char_type*
      move(char_type* __s1, const char_type* __s2, size_t __n)
      {
 if (__n == 0)
   return __s1;

 if (std::__is_constant_evaluated())
   return __gnu_cxx::char_traits<char_type>::move(__s1, __s2, __n);

 return (static_cast<char_type*>
  (__builtin_memmove(__s1, __s2, __n * sizeof(char_type))));
      }

      static constexpr char_type*
      copy(char_type* __s1, const char_type* __s2, size_t __n)
      {
 if (__n == 0)
   return __s1;

 if (std::__is_constant_evaluated())
   return __gnu_cxx::char_traits<char_type>::copy(__s1, __s2, __n);

 return (static_cast<char_type*>
  (__builtin_memcpy(__s1, __s2, __n * sizeof(char_type))));
      }

      static constexpr char_type*
      assign(char_type* __s, size_t __n, char_type __a)
      {
 for (size_t __i = 0; __i < __n; ++__i)
   assign(__s[__i], __a);
 return __s;
      }

      static constexpr char_type
      to_char_type(const int_type& __c) noexcept
      { return char_type(__c); }

      static constexpr bool
      eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
      { return __c1 == __c2; }


      static constexpr int_type
      to_int_type(const char_type& __c) noexcept
      { return __c == eof() ? int_type(0xfffd) : int_type(__c); }

      static constexpr int_type
      eof() noexcept
      { return static_cast<int_type>(-1); }

      static constexpr int_type
      not_eof(const int_type& __c) noexcept
      { return eq_int_type(__c, eof()) ? 0 : __c; }





    };

  template<>
    struct char_traits<char32_t>
    {
      typedef char32_t char_type;

      typedef unsigned int int_type;




      typedef streamoff off_type;
      typedef u32streampos pos_type;
      typedef mbstate_t state_type;


      using comparison_category = strong_ordering;


      static constexpr void
      assign(char_type& __c1, const char_type& __c2) noexcept
      {

 if (std::__is_constant_evaluated())
   std::construct_at(__builtin_addressof(__c1), __c2);
 else

 __c1 = __c2;
      }

      static constexpr bool
      eq(const char_type& __c1, const char_type& __c2) noexcept
      { return __c1 == __c2; }

      static constexpr bool
      lt(const char_type& __c1, const char_type& __c2) noexcept
      { return __c1 < __c2; }

      static constexpr int
      compare(const char_type* __s1, const char_type* __s2, size_t __n)
      {
 for (size_t __i = 0; __i < __n; ++__i)
   if (lt(__s1[__i], __s2[__i]))
     return -1;
   else if (lt(__s2[__i], __s1[__i]))
     return 1;
 return 0;
      }

      static constexpr size_t
      length(const char_type* __s)
      {
 size_t __i = 0;
 while (!eq(__s[__i], char_type()))
   ++__i;
 return __i;
      }

      static constexpr const char_type*
      find(const char_type* __s, size_t __n, const char_type& __a)
      {
 for (size_t __i = 0; __i < __n; ++__i)
   if (eq(__s[__i], __a))
     return __s + __i;
 return 0;
      }

      static constexpr char_type*
      move(char_type* __s1, const char_type* __s2, size_t __n)
      {
 if (__n == 0)
   return __s1;

 if (std::__is_constant_evaluated())
   return __gnu_cxx::char_traits<char_type>::move(__s1, __s2, __n);

 return (static_cast<char_type*>
  (__builtin_memmove(__s1, __s2, __n * sizeof(char_type))));
      }

      static constexpr char_type*
      copy(char_type* __s1, const char_type* __s2, size_t __n)
      {
 if (__n == 0)
   return __s1;

 if (std::__is_constant_evaluated())
   return __gnu_cxx::char_traits<char_type>::copy(__s1, __s2, __n);

 return (static_cast<char_type*>
  (__builtin_memcpy(__s1, __s2, __n * sizeof(char_type))));
      }

      static constexpr char_type*
      assign(char_type* __s, size_t __n, char_type __a)
      {
 for (size_t __i = 0; __i < __n; ++__i)
   assign(__s[__i], __a);
 return __s;
      }

      static constexpr char_type
      to_char_type(const int_type& __c) noexcept
      { return char_type(__c); }

      static constexpr int_type
      to_int_type(const char_type& __c) noexcept
      { return int_type(__c); }

      static constexpr bool
      eq_int_type(const int_type& __c1, const int_type& __c2) noexcept
      { return __c1 == __c2; }


      static constexpr int_type
      eof() noexcept
      { return static_cast<int_type>(-1); }

      static constexpr int_type
      not_eof(const int_type& __c) noexcept
      { return eq_int_type(__c, eof()) ? 0 : __c; }

    };


  namespace __detail
  {
    template<typename _ChTraits>
      constexpr auto
      __char_traits_cmp_cat(int __cmp) noexcept
      {
 if constexpr (requires { typename _ChTraits::comparison_category; })
   {
     using _Cat = typename _ChTraits::comparison_category;
     static_assert( !is_void_v<common_comparison_category_t<_Cat>> );
     return static_cast<_Cat>(__cmp <=> 0);
   }
 else
   return static_cast<weak_ordering>(__cmp <=> 0);
      }
  }


#pragma GCC diagnostic pop


}
# 43 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/string" 2 3



# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ostream_insert.h" 1 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ostream_insert.h" 3


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/cxxabi_forced.h" 1 3
# 35 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ostream_insert.h" 2 3


namespace std __attribute__ ((__visibility__ ("default")))
{




  template<typename _CharT, typename _Traits>
    inline void
    __ostream_write(basic_ostream<_CharT, _Traits>& __out,
      const _CharT* __s, streamsize __n)
    {
      typedef basic_ostream<_CharT, _Traits> __ostream_type;
      typedef typename __ostream_type::ios_base __ios_base;

      const streamsize __put = __out.rdbuf()->sputn(__s, __n);
      if (__put != __n)
 __out.setstate(__ios_base::badbit);
    }

  template<typename _CharT, typename _Traits>
    inline void
    __ostream_fill(basic_ostream<_CharT, _Traits>& __out, streamsize __n)
    {
      typedef basic_ostream<_CharT, _Traits> __ostream_type;
      typedef typename __ostream_type::ios_base __ios_base;

      const _CharT __c = __out.fill();
      for (; __n > 0; --__n)
 {
   const typename _Traits::int_type __put = __out.rdbuf()->sputc(__c);
   if (_Traits::eq_int_type(__put, _Traits::eof()))
     {
       __out.setstate(__ios_base::badbit);
       break;
     }
 }
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    __ostream_insert(basic_ostream<_CharT, _Traits>& __out,
       const _CharT* __s, streamsize __n)
    {
      typedef basic_ostream<_CharT, _Traits> __ostream_type;
      typedef typename __ostream_type::ios_base __ios_base;

      typename __ostream_type::sentry __cerb(__out);
      if (__cerb)
 {
   try
     {
       const streamsize __w = __out.width();
       if (__w > __n)
  {
    const bool __left = ((__out.flags()
     & __ios_base::adjustfield)
           == __ios_base::left);
    if (!__left)
      __ostream_fill(__out, __w - __n);
    if (__out.good())
      __ostream_write(__out, __s, __n);
    if (__left && __out.good())
      __ostream_fill(__out, __w - __n);
  }
       else
  __ostream_write(__out, __s, __n);
       __out.width(0);
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       __out._M_setstate(__ios_base::badbit);
       throw;
     }
   catch(...)
     { __out._M_setstate(__ios_base::badbit); }
 }
      return __out;
    }




  extern template ostream& __ostream_insert(ostream&, const char*, streamsize);


  extern template wostream& __ostream_insert(wostream&, const wchar_t*,
          streamsize);






}
# 47 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/string" 2 3





# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/refwrap.h" 1 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/refwrap.h" 3
# 45 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/refwrap.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 56 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/refwrap.h" 3
  template<typename _Res, typename... _ArgTypes>
    struct _Maybe_unary_or_binary_function { };


#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"


  template<typename _Res, typename _T1>
    struct _Maybe_unary_or_binary_function<_Res, _T1>
    : std::unary_function<_T1, _Res> { };


  template<typename _Res, typename _T1, typename _T2>
    struct _Maybe_unary_or_binary_function<_Res, _T1, _T2>
    : std::binary_function<_T1, _T2, _Res> { };

#pragma GCC diagnostic pop

  template<typename _Signature>
    struct _Mem_fn_traits;

  template<typename _Res, typename _Class, typename... _ArgTypes>
    struct _Mem_fn_traits_base
    {
      using __result_type = _Res;
      using __maybe_type
 = _Maybe_unary_or_binary_function<_Res, _Class*, _ArgTypes...>;
      using __arity = integral_constant<size_t, sizeof...(_ArgTypes)>;
    };
# 107 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/refwrap.h" 3
template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) > : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) > : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const > : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const > : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile > : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile > : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile > : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile > : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; };
template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) &> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) &> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const &> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const &> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile &> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile &> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile &> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile &> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; };
template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) &&> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) &&> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const &&> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const &&> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile &&> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile &&> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile &&> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile &&> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; };


template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; };
template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) & noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) & noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const & noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const & noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile & noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile & noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile & noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile & noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; };
template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) && noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) && noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const && noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const && noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile && noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile && noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile && noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template<typename _Res, typename _Class, typename... _ArgTypes> struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile && noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; };






  template<typename _Functor, typename = __void_t<>>
    struct _Maybe_get_result_type
    { };

  template<typename _Functor>
    struct _Maybe_get_result_type<_Functor,
      __void_t<typename _Functor::result_type>>
    { typedef typename _Functor::result_type result_type; };





  template<typename _Functor>
    struct _Weak_result_type_impl
    : _Maybe_get_result_type<_Functor>
    { };


  template<typename _Res, typename... _ArgTypes , bool _NE>
    struct _Weak_result_type_impl<_Res(_ArgTypes...) noexcept (_NE)>
    { typedef _Res result_type; };


  template<typename _Res, typename... _ArgTypes , bool _NE>
    struct _Weak_result_type_impl<_Res(_ArgTypes......) noexcept (_NE)>
    { typedef _Res result_type; };


  template<typename _Res, typename... _ArgTypes , bool _NE>
    struct _Weak_result_type_impl<_Res(*)(_ArgTypes...) noexcept (_NE)>
    { typedef _Res result_type; };


  template<typename _Res, typename... _ArgTypes , bool _NE>
    struct
    _Weak_result_type_impl<_Res(*)(_ArgTypes......) noexcept (_NE)>
    { typedef _Res result_type; };


  template<typename _Functor,
    bool = is_member_function_pointer<_Functor>::value>
    struct _Weak_result_type_memfun
    : _Weak_result_type_impl<_Functor>
    { };


  template<typename _MemFunPtr>
    struct _Weak_result_type_memfun<_MemFunPtr, true>
    {
      using result_type = typename _Mem_fn_traits<_MemFunPtr>::__result_type;
    };


  template<typename _Func, typename _Class>
    struct _Weak_result_type_memfun<_Func _Class::*, false>
    { };





  template<typename _Functor>
    struct _Weak_result_type
    : _Weak_result_type_memfun<typename remove_cv<_Functor>::type>
    { };
# 306 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/refwrap.h" 3
  template<typename _Tp>
    class reference_wrapper





    {
      _Tp* _M_data;

      constexpr
      static _Tp* _S_fun(_Tp& __r) noexcept { return std::__addressof(__r); }

      static void _S_fun(_Tp&&) = delete;

      template<typename _Up, typename _Up2 = __remove_cvref_t<_Up>>
 using __not_same
   = typename enable_if<!is_same<reference_wrapper, _Up2>::value>::type;

    public:
      typedef _Tp type;




      template<typename _Up, typename = __not_same<_Up>, typename
  = decltype(reference_wrapper::_S_fun(std::declval<_Up>()))>
 constexpr
 reference_wrapper(_Up&& __uref)
 noexcept(noexcept(reference_wrapper::_S_fun(std::declval<_Up>())))
 : _M_data(reference_wrapper::_S_fun(std::forward<_Up>(__uref)))
 { }

      reference_wrapper(const reference_wrapper&) = default;

      reference_wrapper&
      operator=(const reference_wrapper&) = default;

      constexpr
      operator _Tp&() const noexcept
      { return this->get(); }

      constexpr
      _Tp&
      get() const noexcept
      { return *_M_data; }

      template<typename... _Args>
 constexpr
 typename __invoke_result<_Tp&, _Args...>::type
 operator()(_Args&&... __args) const
 noexcept(__is_nothrow_invocable<_Tp&, _Args...>::value)
 {

   if constexpr (is_object_v<type>)
     static_assert(sizeof(type), "type must be complete");

   return std::__invoke(get(), std::forward<_Args>(__args)...);
 }
# 412 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/refwrap.h" 3
    };


  template<typename _Tp>
    reference_wrapper(_Tp&) -> reference_wrapper<_Tp>;





  template<typename _Tp>
    constexpr
    inline reference_wrapper<_Tp>
    ref(_Tp& __t) noexcept
    { return reference_wrapper<_Tp>(__t); }


  template<typename _Tp>
    constexpr
    inline reference_wrapper<const _Tp>
    cref(const _Tp& __t) noexcept
    { return reference_wrapper<const _Tp>(__t); }

  template<typename _Tp>
    void ref(const _Tp&&) = delete;

  template<typename _Tp>
    void cref(const _Tp&&) = delete;


  template<typename _Tp>
    constexpr
    inline reference_wrapper<_Tp>
    ref(reference_wrapper<_Tp> __t) noexcept
    { return __t; }


  template<typename _Tp>
    constexpr
    inline reference_wrapper<const _Tp>
    cref(reference_wrapper<_Tp> __t) noexcept
    { return { __t.get() }; }




}
# 53 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/string" 2 3

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 1 3
# 38 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
# 47 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/string_view" 1 3
# 37 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/string_view" 3







# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 45 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/string_view" 2 3
# 64 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/string_view" 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;
  }
# 105 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/string_view" 3
  template<typename _CharT, typename _Traits = std::char_traits<_CharT>>
    class basic_string_view
    {
      static_assert(!is_array_v<_CharT>);
      static_assert(is_trivial_v<_CharT> && is_standard_layout_v<_CharT>);
      static_assert(is_same_v<_CharT, typename _Traits::char_type>);

    public:


      using traits_type = _Traits;
      using value_type = _CharT;
      using pointer = value_type*;
      using const_pointer = const value_type*;
      using reference = value_type&;
      using const_reference = const value_type&;
      using const_iterator = const value_type*;
      using iterator = const_iterator;
      using const_reverse_iterator = std::reverse_iterator<const_iterator>;
      using reverse_iterator = const_reverse_iterator;
      using size_type = size_t;
      using difference_type = ptrdiff_t;
      static constexpr size_type npos = size_type(-1);



      constexpr
      basic_string_view() noexcept
      : _M_len{0}, _M_str{nullptr}
      { }

      constexpr basic_string_view(const basic_string_view&) noexcept = default;

      [[__gnu__::__nonnull__]]
      constexpr
      basic_string_view(const _CharT* __str) noexcept
      : _M_len{traits_type::length(__str)},
 _M_str{__str}
      { }

      constexpr
      basic_string_view(const _CharT* __str, size_type __len) noexcept
      : _M_len{__len}, _M_str{__str}
      { }


      template<contiguous_iterator _It, sized_sentinel_for<_It> _End>
 requires same_as<iter_value_t<_It>, _CharT>
   && (!convertible_to<_End, size_type>)
 constexpr
 basic_string_view(_It __first, _End __last)
 noexcept(noexcept(__last - __first))
 : _M_len(__last - __first), _M_str(std::to_address(__first))
 { }


      template<typename _Range, typename _DRange = remove_cvref_t<_Range>>
 requires (!is_same_v<_DRange, basic_string_view>)
   && ranges::contiguous_range<_Range>
   && ranges::sized_range<_Range>
   && is_same_v<ranges::range_value_t<_Range>, _CharT>
   && (!is_convertible_v<_Range, const _CharT*>)
   && (!requires (_DRange& __d) {
  __d.operator ::std::basic_string_view<_CharT, _Traits>();
       })
 constexpr explicit
 basic_string_view(_Range&& __r)
 noexcept(noexcept(ranges::size(__r)) && noexcept(ranges::data(__r)))
 : _M_len(ranges::size(__r)), _M_str(ranges::data(__r))
 { }

      basic_string_view(nullptr_t) = delete;



      constexpr basic_string_view&
      operator=(const basic_string_view&) noexcept = default;



      [[nodiscard]]
      constexpr const_iterator
      begin() const noexcept
      { return this->_M_str; }

      [[nodiscard]]
      constexpr const_iterator
      end() const noexcept
      { return this->_M_str + this->_M_len; }

      [[nodiscard]]
      constexpr const_iterator
      cbegin() const noexcept
      { return this->_M_str; }

      [[nodiscard]]
      constexpr const_iterator
      cend() const noexcept
      { return this->_M_str + this->_M_len; }

      [[nodiscard]]
      constexpr const_reverse_iterator
      rbegin() const noexcept
      { return const_reverse_iterator(this->end()); }

      [[nodiscard]]
      constexpr const_reverse_iterator
      rend() const noexcept
      { return const_reverse_iterator(this->begin()); }

      [[nodiscard]]
      constexpr const_reverse_iterator
      crbegin() const noexcept
      { return const_reverse_iterator(this->end()); }

      [[nodiscard]]
      constexpr const_reverse_iterator
      crend() const noexcept
      { return const_reverse_iterator(this->begin()); }



      [[nodiscard]]
      constexpr size_type
      size() const noexcept
      { return this->_M_len; }

      [[nodiscard]]
      constexpr size_type
      length() const noexcept
      { return _M_len; }

      [[nodiscard]]
      constexpr size_type
      max_size() const noexcept
      {
 return (npos - sizeof(size_type) - sizeof(void*))
  / sizeof(value_type) / 4;
      }

      [[nodiscard]]
      constexpr bool
      empty() const noexcept
      { return this->_M_len == 0; }



      [[nodiscard]]
      constexpr const_reference
      operator[](size_type __pos) const noexcept
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__pos < this->_M_len), false)) std::__glibcxx_assert_fail(); } while (false);
 return *(this->_M_str + __pos);
      }

      [[nodiscard]]
      constexpr const_reference
      at(size_type __pos) const
      {
 if (__pos >= _M_len)
   __throw_out_of_range_fmt(("basic_string_view::at: __pos " "(which is %zu) >= this->size() " "(which is %zu)"), __pos, this->size());


 return *(this->_M_str + __pos);
      }

      [[nodiscard]]
      constexpr const_reference
      front() const noexcept
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(this->_M_len > 0), false)) std::__glibcxx_assert_fail(); } while (false);
 return *this->_M_str;
      }

      [[nodiscard]]
      constexpr const_reference
      back() const noexcept
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(this->_M_len > 0), false)) std::__glibcxx_assert_fail(); } while (false);
 return *(this->_M_str + this->_M_len - 1);
      }

      [[nodiscard]]
      constexpr const_pointer
      data() const noexcept
      { return this->_M_str; }



      constexpr void
      remove_prefix(size_type __n) noexcept
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(this->_M_len >= __n), false)) std::__glibcxx_assert_fail(); } while (false);
 this->_M_str += __n;
 this->_M_len -= __n;
      }

      constexpr void
      remove_suffix(size_type __n) noexcept
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(this->_M_len >= __n), false)) std::__glibcxx_assert_fail(); } while (false);
 this->_M_len -= __n;
      }

      constexpr void
      swap(basic_string_view& __sv) noexcept
      {
 auto __tmp = *this;
 *this = __sv;
 __sv = __tmp;
      }



      constexpr
      size_type
      copy(_CharT* __str, size_type __n, size_type __pos = 0) const
      {
                                          ;
 __pos = std::__sv_check(size(), __pos, "basic_string_view::copy");
 const size_type __rlen = std::min<size_t>(__n, _M_len - __pos);


 traits_type::copy(__str, data() + __pos, __rlen);
 return __rlen;
      }

      [[nodiscard]]
      constexpr basic_string_view
      substr(size_type __pos = 0, size_type __n = npos) const noexcept(false)
      {
 __pos = std::__sv_check(size(), __pos, "basic_string_view::substr");
 const size_type __rlen = std::min<size_t>(__n, _M_len - __pos);
 return basic_string_view{_M_str + __pos, __rlen};
      }

      [[nodiscard]]
      constexpr int
      compare(basic_string_view __str) const noexcept
      {
 const size_type __rlen = std::min(this->_M_len, __str._M_len);
 int __ret = traits_type::compare(this->_M_str, __str._M_str, __rlen);
 if (__ret == 0)
   __ret = _S_compare(this->_M_len, __str._M_len);
 return __ret;
      }

      [[nodiscard]]
      constexpr int
      compare(size_type __pos1, size_type __n1, basic_string_view __str) const
      { return this->substr(__pos1, __n1).compare(__str); }

      [[nodiscard]]
      constexpr int
      compare(size_type __pos1, size_type __n1,
       basic_string_view __str, size_type __pos2, size_type __n2) const
      {
 return this->substr(__pos1, __n1).compare(__str.substr(__pos2, __n2));
      }

      [[nodiscard, __gnu__::__nonnull__]]
      constexpr int
      compare(const _CharT* __str) const noexcept
      { return this->compare(basic_string_view{__str}); }

      [[nodiscard, __gnu__::__nonnull__]]
      constexpr int
      compare(size_type __pos1, size_type __n1, const _CharT* __str) const
      { return this->substr(__pos1, __n1).compare(basic_string_view{__str}); }

      [[nodiscard]]
      constexpr int
      compare(size_type __pos1, size_type __n1,
       const _CharT* __str, size_type __n2) const noexcept(false)
      {
 return this->substr(__pos1, __n1)
     .compare(basic_string_view(__str, __n2));
      }


      [[nodiscard]]
      constexpr bool
      starts_with(basic_string_view __x) const noexcept
      { return this->substr(0, __x.size()) == __x; }

      [[nodiscard]]
      constexpr bool
      starts_with(_CharT __x) const noexcept
      { return !this->empty() && traits_type::eq(this->front(), __x); }

      [[nodiscard, __gnu__::__nonnull__]]
      constexpr bool
      starts_with(const _CharT* __x) const noexcept
      { return this->starts_with(basic_string_view(__x)); }

      [[nodiscard]]
      constexpr bool
      ends_with(basic_string_view __x) const noexcept
      {
 const auto __len = this->size();
 const auto __xlen = __x.size();
 return __len >= __xlen
   && traits_type::compare(end() - __xlen, __x.data(), __xlen) == 0;
      }

      [[nodiscard]]
      constexpr bool
      ends_with(_CharT __x) const noexcept
      { return !this->empty() && traits_type::eq(this->back(), __x); }

      [[nodiscard, __gnu__::__nonnull__]]
      constexpr bool
      ends_with(const _CharT* __x) const noexcept
      { return this->ends_with(basic_string_view(__x)); }
# 427 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/string_view" 3
      [[nodiscard]]
      constexpr bool
      contains(basic_string_view __x) const noexcept
      { return this->find(__x) != npos; }

      [[nodiscard]]
      constexpr bool
      contains(_CharT __x) const noexcept
      { return this->find(__x) != npos; }

      [[nodiscard, __gnu__::__nonnull__]]
      constexpr bool
      contains(const _CharT* __x) const noexcept
      { return this->find(__x) != npos; }




      [[nodiscard]]
      constexpr size_type
      find(basic_string_view __str, size_type __pos = 0) const noexcept
      { return this->find(__str._M_str, __pos, __str._M_len); }

      [[nodiscard]]
      constexpr size_type
      find(_CharT __c, size_type __pos = 0) const noexcept;

      [[nodiscard]]
      constexpr size_type
      find(const _CharT* __str, size_type __pos, size_type __n) const noexcept;

      [[nodiscard, __gnu__::__nonnull__]]
      constexpr size_type
      find(const _CharT* __str, size_type __pos = 0) const noexcept
      { return this->find(__str, __pos, traits_type::length(__str)); }

      [[nodiscard]]
      constexpr size_type
      rfind(basic_string_view __str, size_type __pos = npos) const noexcept
      { return this->rfind(__str._M_str, __pos, __str._M_len); }

      [[nodiscard]]
      constexpr size_type
      rfind(_CharT __c, size_type __pos = npos) const noexcept;

      [[nodiscard]]
      constexpr size_type
      rfind(const _CharT* __str, size_type __pos, size_type __n) const noexcept;

      [[nodiscard, __gnu__::__nonnull__]]
      constexpr size_type
      rfind(const _CharT* __str, size_type __pos = npos) const noexcept
      { return this->rfind(__str, __pos, traits_type::length(__str)); }

      [[nodiscard]]
      constexpr size_type
      find_first_of(basic_string_view __str, size_type __pos = 0) const noexcept
      { return this->find_first_of(__str._M_str, __pos, __str._M_len); }

      [[nodiscard]]
      constexpr size_type
      find_first_of(_CharT __c, size_type __pos = 0) const noexcept
      { return this->find(__c, __pos); }

      [[nodiscard]]
      constexpr size_type
      find_first_of(const _CharT* __str, size_type __pos,
      size_type __n) const noexcept;

      [[nodiscard, __gnu__::__nonnull__]]
      constexpr size_type
      find_first_of(const _CharT* __str, size_type __pos = 0) const noexcept
      { return this->find_first_of(__str, __pos, traits_type::length(__str)); }

      [[nodiscard]]
      constexpr size_type
      find_last_of(basic_string_view __str,
     size_type __pos = npos) const noexcept
      { return this->find_last_of(__str._M_str, __pos, __str._M_len); }

      [[nodiscard]]
      constexpr size_type
      find_last_of(_CharT __c, size_type __pos=npos) const noexcept
      { return this->rfind(__c, __pos); }

      [[nodiscard]]
      constexpr size_type
      find_last_of(const _CharT* __str, size_type __pos,
     size_type __n) const noexcept;

      [[nodiscard, __gnu__::__nonnull__]]
      constexpr size_type
      find_last_of(const _CharT* __str, size_type __pos = npos) const noexcept
      { return this->find_last_of(__str, __pos, traits_type::length(__str)); }

      [[nodiscard]]
      constexpr size_type
      find_first_not_of(basic_string_view __str,
   size_type __pos = 0) const noexcept
      { return this->find_first_not_of(__str._M_str, __pos, __str._M_len); }

      [[nodiscard]]
      constexpr size_type
      find_first_not_of(_CharT __c, size_type __pos = 0) const noexcept;

      [[nodiscard]]
      constexpr size_type
      find_first_not_of(const _CharT* __str,
   size_type __pos, size_type __n) const noexcept;

      [[nodiscard, __gnu__::__nonnull__]]
      constexpr size_type
      find_first_not_of(const _CharT* __str, size_type __pos = 0) const noexcept
      {
 return this->find_first_not_of(__str, __pos,
           traits_type::length(__str));
      }

      [[nodiscard]]
      constexpr size_type
      find_last_not_of(basic_string_view __str,
         size_type __pos = npos) const noexcept
      { return this->find_last_not_of(__str._M_str, __pos, __str._M_len); }

      [[nodiscard]]
      constexpr size_type
      find_last_not_of(_CharT __c, size_type __pos = npos) const noexcept;

      [[nodiscard]]
      constexpr size_type
      find_last_not_of(const _CharT* __str,
         size_type __pos, size_type __n) const noexcept;

      [[nodiscard, __gnu__::__nonnull__]]
      constexpr size_type
      find_last_not_of(const _CharT* __str,
         size_type __pos = npos) const noexcept
      {
 return this->find_last_not_of(__str, __pos,
          traits_type::length(__str));
      }

    private:

      static constexpr int
      _S_compare(size_type __n1, size_type __n2) noexcept
      {
 using __limits = __gnu_cxx::__int_traits<int>;
 const difference_type __diff = __n1 - __n2;
 if (__diff > __limits::__max)
   return __limits::__max;
 if (__diff < __limits::__min)
   return __limits::__min;
 return static_cast<int>(__diff);
      }

      size_t _M_len;
      const _CharT* _M_str;
    };


  template<contiguous_iterator _It, sized_sentinel_for<_It> _End>
    basic_string_view(_It, _End) -> basic_string_view<iter_value_t<_It>>;


  template<ranges::contiguous_range _Range>
    basic_string_view(_Range&&)
      -> basic_string_view<ranges::range_value_t<_Range>>;
# 606 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/string_view" 3
  template<typename _CharT, typename _Traits>
    [[nodiscard]]
    constexpr bool
    operator==(basic_string_view<_CharT, _Traits> __x,
        type_identity_t<basic_string_view<_CharT, _Traits>> __y)
    noexcept
    { return __x.size() == __y.size() && __x.compare(__y) == 0; }

  template<typename _CharT, typename _Traits>
    [[nodiscard]]
    constexpr auto
    operator<=>(basic_string_view<_CharT, _Traits> __x,
  __type_identity_t<basic_string_view<_CharT, _Traits>> __y)
    noexcept
    -> decltype(__detail::__char_traits_cmp_cat<_Traits>(0))
    { return __detail::__char_traits_cmp_cat<_Traits>(__x.compare(__y)); }
# 758 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/string_view" 3
  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
        basic_string_view<_CharT,_Traits> __str)
    { return __ostream_insert(__os, __str.data(), __str.size()); }




  using string_view = basic_string_view<char>;
  using wstring_view = basic_string_view<wchar_t>;

  using u8string_view = basic_string_view<char8_t>;

  using u16string_view = basic_string_view<char16_t>;
  using u32string_view = basic_string_view<char32_t>;



  template<typename _Tp>
    struct hash;

  template<>
    struct hash<string_view>
    : public __hash_base<size_t, string_view>
    {
      [[nodiscard]]
      size_t
      operator()(const string_view& __str) const noexcept
      { return std::_Hash_impl::hash(__str.data(), __str.length()); }
    };

  template<>
    struct __is_fast_hash<hash<string_view>> : std::false_type
    { };

  template<>
    struct hash<wstring_view>
    : public __hash_base<size_t, wstring_view>
    {
      [[nodiscard]]
      size_t
      operator()(const wstring_view& __s) const noexcept
      { return std::_Hash_impl::hash(__s.data(),
                                     __s.length() * sizeof(wchar_t)); }
    };

  template<>
    struct __is_fast_hash<hash<wstring_view>> : std::false_type
    { };


  template<>
    struct hash<u8string_view>
    : public __hash_base<size_t, u8string_view>
    {
      [[nodiscard]]
      size_t
      operator()(const u8string_view& __str) const noexcept
      { return std::_Hash_impl::hash(__str.data(), __str.length()); }
    };

  template<>
    struct __is_fast_hash<hash<u8string_view>> : std::false_type
    { };


  template<>
    struct hash<u16string_view>
    : public __hash_base<size_t, u16string_view>
    {
      [[nodiscard]]
      size_t
      operator()(const u16string_view& __s) const noexcept
      { return std::_Hash_impl::hash(__s.data(),
                                     __s.length() * sizeof(char16_t)); }
    };

  template<>
    struct __is_fast_hash<hash<u16string_view>> : std::false_type
    { };

  template<>
    struct hash<u32string_view>
    : public __hash_base<size_t, u32string_view>
    {
      [[nodiscard]]
      size_t
      operator()(const u32string_view& __s) const noexcept
      { return std::_Hash_impl::hash(__s.data(),
                                     __s.length() * sizeof(char32_t)); }
    };

  template<>
    struct __is_fast_hash<hash<u32string_view>> : std::false_type
    { };

  inline namespace literals
  {
  inline namespace string_view_literals
  {
#pragma GCC diagnostic push

    inline constexpr basic_string_view<char>
    operator""sv(const char* __str, size_t __len) noexcept
    { return basic_string_view<char>{__str, __len}; }

    inline constexpr basic_string_view<wchar_t>
    operator""sv(const wchar_t* __str, size_t __len) noexcept
    { return basic_string_view<wchar_t>{__str, __len}; }


    inline constexpr basic_string_view<char8_t>
    operator""sv(const char8_t* __str, size_t __len) noexcept
    { return basic_string_view<char8_t>{__str, __len}; }


    inline constexpr basic_string_view<char16_t>
    operator""sv(const char16_t* __str, size_t __len) noexcept
    { return basic_string_view<char16_t>{__str, __len}; }

    inline constexpr basic_string_view<char32_t>
    operator""sv(const char32_t* __str, size_t __len) noexcept
    { return basic_string_view<char32_t>{__str, __len}; }

#pragma GCC diagnostic pop
  }
  }


  namespace ranges
  {

    template<typename _CharT, typename _Traits>
      inline constexpr bool
 enable_borrowed_range<basic_string_view<_CharT, _Traits>> = true;


    template<typename _CharT, typename _Traits>
      inline constexpr bool
 enable_view<basic_string_view<_CharT, _Traits>> = true;
  }


}

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/string_view.tcc" 1 3
# 38 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/string_view.tcc" 3



namespace std __attribute__ ((__visibility__ ("default")))
{


  template<typename _CharT, typename _Traits>
    constexpr typename basic_string_view<_CharT, _Traits>::size_type
    basic_string_view<_CharT, _Traits>::
    find(const _CharT* __str, size_type __pos, size_type __n) const noexcept
    {
                                               ;

      if (__n == 0)
 return __pos <= _M_len ? __pos : npos;
      if (__pos >= _M_len)
 return npos;

      const _CharT __elem0 = __str[0];
      const _CharT* __first = _M_str + __pos;
      const _CharT* const __last = _M_str + _M_len;
      size_type __len = _M_len - __pos;

      while (__len >= __n)
 {

   __first = traits_type::find(__first, __len - __n + 1, __elem0);
   if (!__first)
     return npos;



   if (traits_type::compare(__first, __str, __n) == 0)
     return __first - _M_str;
   __len = __last - ++__first;
 }
      return npos;
    }

  template<typename _CharT, typename _Traits>
    constexpr typename basic_string_view<_CharT, _Traits>::size_type
    basic_string_view<_CharT, _Traits>::
    find(_CharT __c, size_type __pos) const noexcept
    {
      size_type __ret = npos;
      if (__pos < this->_M_len)
 {
   const size_type __n = this->_M_len - __pos;
   const _CharT* __p = traits_type::find(this->_M_str + __pos, __n, __c);
   if (__p)
     __ret = __p - this->_M_str;
 }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    constexpr typename basic_string_view<_CharT, _Traits>::size_type
    basic_string_view<_CharT, _Traits>::
    rfind(const _CharT* __str, size_type __pos, size_type __n) const noexcept
    {
                                               ;

      if (__n <= this->_M_len)
 {
   __pos = std::min(size_type(this->_M_len - __n), __pos);
   do
     {
       if (traits_type::compare(this->_M_str + __pos, __str, __n) == 0)
  return __pos;
     }
   while (__pos-- > 0);
 }
      return npos;
    }

  template<typename _CharT, typename _Traits>
    constexpr typename basic_string_view<_CharT, _Traits>::size_type
    basic_string_view<_CharT, _Traits>::
    rfind(_CharT __c, size_type __pos) const noexcept
    {
      size_type __size = this->_M_len;
      if (__size > 0)
 {
   if (--__size > __pos)
     __size = __pos;
   for (++__size; __size-- > 0; )
     if (traits_type::eq(this->_M_str[__size], __c))
       return __size;
 }
      return npos;
    }

  template<typename _CharT, typename _Traits>
    constexpr typename basic_string_view<_CharT, _Traits>::size_type
    basic_string_view<_CharT, _Traits>::
    find_first_of(const _CharT* __str, size_type __pos,
    size_type __n) const noexcept
    {
                                               ;
      for (; __n && __pos < this->_M_len; ++__pos)
 {
   const _CharT* __p = traits_type::find(__str, __n,
      this->_M_str[__pos]);
   if (__p)
     return __pos;
 }
      return npos;
    }

  template<typename _CharT, typename _Traits>
    constexpr typename basic_string_view<_CharT, _Traits>::size_type
    basic_string_view<_CharT, _Traits>::
    find_last_of(const _CharT* __str, size_type __pos,
   size_type __n) const noexcept
    {
                                               ;
      size_type __size = this->size();
      if (__size && __n)
 {
   if (--__size > __pos)
     __size = __pos;
   do
     {
       if (traits_type::find(__str, __n, this->_M_str[__size]))
  return __size;
     }
   while (__size-- != 0);
 }
      return npos;
    }

  template<typename _CharT, typename _Traits>
    constexpr typename basic_string_view<_CharT, _Traits>::size_type
    basic_string_view<_CharT, _Traits>::
    find_first_not_of(const _CharT* __str, size_type __pos,
        size_type __n) const noexcept
    {
                                               ;
      for (; __pos < this->_M_len; ++__pos)
 if (!traits_type::find(__str, __n, this->_M_str[__pos]))
   return __pos;
      return npos;
    }

  template<typename _CharT, typename _Traits>
    constexpr typename basic_string_view<_CharT, _Traits>::size_type
    basic_string_view<_CharT, _Traits>::
    find_first_not_of(_CharT __c, size_type __pos) const noexcept
    {
      for (; __pos < this->_M_len; ++__pos)
 if (!traits_type::eq(this->_M_str[__pos], __c))
   return __pos;
      return npos;
    }

  template<typename _CharT, typename _Traits>
    constexpr typename basic_string_view<_CharT, _Traits>::size_type
    basic_string_view<_CharT, _Traits>::
    find_last_not_of(const _CharT* __str, size_type __pos,
       size_type __n) const noexcept
    {
                                               ;
      size_type __size = this->_M_len;
      if (__size)
 {
   if (--__size > __pos)
     __size = __pos;
   do
     {
       if (!traits_type::find(__str, __n, this->_M_str[__size]))
  return __size;
     }
   while (__size--);
 }
      return npos;
    }

  template<typename _CharT, typename _Traits>
    constexpr typename basic_string_view<_CharT, _Traits>::size_type
    basic_string_view<_CharT, _Traits>::
    find_last_not_of(_CharT __c, size_type __pos) const noexcept
    {
      size_type __size = this->_M_len;
      if (__size)
 {
   if (--__size > __pos)
     __size = __pos;
   do
     {
       if (!traits_type::eq(this->_M_str[__size], __c))
  return __size;
     }
   while (__size--);
 }
      return npos;
    }


}
# 905 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/string_view" 2 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 2 3






# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 55 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 2 3





namespace std __attribute__ ((__visibility__ ("default")))
{

namespace __cxx11 {
# 85 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    class basic_string
    {

      static_assert(is_same_v<_CharT, typename _Traits::char_type>);
      static_assert(is_same_v<_CharT, typename _Alloc::value_type>);
      using _Char_alloc_type = _Alloc;





      typedef __gnu_cxx::__alloc_traits<_Char_alloc_type> _Alloc_traits;


    public:
      typedef _Traits traits_type;
      typedef typename _Traits::char_type value_type;
      typedef _Char_alloc_type allocator_type;
      typedef typename _Alloc_traits::size_type size_type;
      typedef typename _Alloc_traits::difference_type difference_type;
      typedef typename _Alloc_traits::reference reference;
      typedef typename _Alloc_traits::const_reference const_reference;
      typedef typename _Alloc_traits::pointer pointer;
      typedef typename _Alloc_traits::const_pointer const_pointer;
      typedef __gnu_cxx::__normal_iterator<pointer, basic_string> iterator;
      typedef __gnu_cxx::__normal_iterator<const_pointer, basic_string>
       const_iterator;
      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
      typedef std::reverse_iterator<iterator> reverse_iterator;


      static const size_type npos = static_cast<size_type>(-1);

    protected:




      typedef const_iterator __const_iterator;


    private:
      static constexpr pointer
      _S_allocate(_Char_alloc_type& __a, size_type __n)
      {
 pointer __p = _Alloc_traits::allocate(__a, __n);



 if constexpr (!is_same_v<_Traits, char_traits<_CharT>>)
   if (std::__is_constant_evaluated())

     for (size_type __i = 0; __i < __n; ++__i)
       std::construct_at(__builtin_addressof(__p[__i]));

 return __p;
      }



      typedef basic_string_view<_CharT, _Traits> __sv_type;

      template<typename _Tp, typename _Res>
 using _If_sv = enable_if_t<
   __and_<is_convertible<const _Tp&, __sv_type>,
   __not_<is_convertible<const _Tp*, const basic_string*>>,
   __not_<is_convertible<const _Tp&, const _CharT*>>>::value,
   _Res>;


      constexpr
      static __sv_type
      _S_to_string_view(__sv_type __svt) noexcept
      { return __svt; }





      struct __sv_wrapper
      {
 constexpr explicit
 __sv_wrapper(__sv_type __sv) noexcept : _M_sv(__sv) { }

 __sv_type _M_sv;
      };







      constexpr
      explicit
      basic_string(__sv_wrapper __svw, const _Alloc& __a)
      : basic_string(__svw._M_sv.data(), __svw._M_sv.size(), __a) { }



      struct _Alloc_hider : allocator_type
      {




 constexpr
 _Alloc_hider(pointer __dat, const _Alloc& __a)
 : allocator_type(__a), _M_p(__dat) { }

 constexpr
 _Alloc_hider(pointer __dat, _Alloc&& __a = _Alloc())
 : allocator_type(std::move(__a)), _M_p(__dat) { }


 pointer _M_p;
      };

      _Alloc_hider _M_dataplus;
      size_type _M_string_length;

      enum { _S_local_capacity = 15 / sizeof(_CharT) };

      union
      {
 _CharT _M_local_buf[_S_local_capacity + 1];
 size_type _M_allocated_capacity;
      };

      constexpr
      void
      _M_data(pointer __p)
      { _M_dataplus._M_p = __p; }

      constexpr
      void
      _M_length(size_type __length)
      { _M_string_length = __length; }

      constexpr
      pointer
      _M_data() const
      { return _M_dataplus._M_p; }

      constexpr
      pointer
      _M_local_data()
      {

 return std::pointer_traits<pointer>::pointer_to(*_M_local_buf);



      }

      constexpr
      const_pointer
      _M_local_data() const
      {

 return std::pointer_traits<const_pointer>::pointer_to(*_M_local_buf);



      }

      constexpr
      void
      _M_capacity(size_type __capacity)
      { _M_allocated_capacity = __capacity; }

      constexpr
      void
      _M_set_length(size_type __n)
      {
 _M_length(__n);
 traits_type::assign(_M_data()[__n], _CharT());
      }

      constexpr
      bool
      _M_is_local() const
      {
 if (_M_data() == _M_local_data())
   {
     if (_M_string_length > _S_local_capacity)
       __builtin_unreachable();
     return true;
   }
 return false;
      }


      constexpr
      pointer
      _M_create(size_type&, size_type);

      constexpr
      void
      _M_dispose()
      {
 if (!_M_is_local())
   _M_destroy(_M_allocated_capacity);
      }

      constexpr
      void
      _M_destroy(size_type __size) throw()
      { _Alloc_traits::deallocate(_M_get_allocator(), _M_data(), __size + 1); }
# 321 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      template<typename _InIterator>
 constexpr
        void
        _M_construct(_InIterator __beg, _InIterator __end,
       std::input_iterator_tag);



      template<typename _FwdIterator>
 constexpr
        void
        _M_construct(_FwdIterator __beg, _FwdIterator __end,
       std::forward_iterator_tag);

      constexpr
      void
      _M_construct(size_type __req, _CharT __c);

      constexpr
      allocator_type&
      _M_get_allocator()
      { return _M_dataplus; }

      constexpr
      const allocator_type&
      _M_get_allocator() const
      { return _M_dataplus; }


      __attribute__((__always_inline__))
      constexpr
      void
      _M_init_local_buf() noexcept
      {

 if (std::is_constant_evaluated())
   for (size_type __i = 0; __i <= _S_local_capacity; ++__i)
     _M_local_buf[__i] = _CharT();

      }

      __attribute__((__always_inline__))
      constexpr
      pointer
      _M_use_local_data() noexcept
      {

 _M_init_local_buf();

 return _M_local_data();
      }

    private:
# 389 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      constexpr
      size_type
      _M_check(size_type __pos, const char* __s) const
      {
 if (__pos > this->size())
   __throw_out_of_range_fmt(("%s: __pos (which is %zu) > " "this->size() (which is %zu)"),

       __s, __pos, this->size());
 return __pos;
      }

      constexpr
      void
      _M_check_length(size_type __n1, size_type __n2, const char* __s) const
      {
 if (this->max_size() - (this->size() - __n1) < __n2)
   __throw_length_error((__s));
      }



      constexpr
      size_type
      _M_limit(size_type __pos, size_type __off) const noexcept
      {
 const bool __testoff = __off < this->size() - __pos;
 return __testoff ? __off : this->size() - __pos;
      }


      bool
      _M_disjunct(const _CharT* __s) const noexcept
      {
 return (less<const _CharT*>()(__s, _M_data())
  || less<const _CharT*>()(_M_data() + this->size(), __s));
      }



      constexpr
      static void
      _S_copy(_CharT* __d, const _CharT* __s, size_type __n)
      {
 if (__n == 1)
   traits_type::assign(*__d, *__s);
 else
   traits_type::copy(__d, __s, __n);
      }

      constexpr
      static void
      _S_move(_CharT* __d, const _CharT* __s, size_type __n)
      {
 if (__n == 1)
   traits_type::assign(*__d, *__s);
 else
   traits_type::move(__d, __s, __n);
      }

      constexpr
      static void
      _S_assign(_CharT* __d, size_type __n, _CharT __c)
      {
 if (__n == 1)
   traits_type::assign(*__d, __c);
 else
   traits_type::assign(__d, __n, __c);
      }



      template<class _Iterator>
 constexpr
        static void
        _S_copy_chars(_CharT* __p, _Iterator __k1, _Iterator __k2)
        {
   for (; __k1 != __k2; ++__k1, (void)++__p)
     traits_type::assign(*__p, *__k1);
 }

      constexpr
      static void
      _S_copy_chars(_CharT* __p, iterator __k1, iterator __k2) noexcept
      { _S_copy_chars(__p, __k1.base(), __k2.base()); }

      constexpr
      static void
      _S_copy_chars(_CharT* __p, const_iterator __k1, const_iterator __k2)
      noexcept
      { _S_copy_chars(__p, __k1.base(), __k2.base()); }

      constexpr
      static void
      _S_copy_chars(_CharT* __p, _CharT* __k1, _CharT* __k2) noexcept
      { _S_copy(__p, __k1, __k2 - __k1); }

      constexpr
      static void
      _S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2)
      noexcept
      { _S_copy(__p, __k1, __k2 - __k1); }

      constexpr
      static int
      _S_compare(size_type __n1, size_type __n2) noexcept
      {
 const difference_type __d = difference_type(__n1 - __n2);

 if (__d > __gnu_cxx::__numeric_traits<int>::__max)
   return __gnu_cxx::__numeric_traits<int>::__max;
 else if (__d < __gnu_cxx::__numeric_traits<int>::__min)
   return __gnu_cxx::__numeric_traits<int>::__min;
 else
   return int(__d);
      }

      constexpr
      void
      _M_assign(const basic_string&);

      constexpr
      void
      _M_mutate(size_type __pos, size_type __len1, const _CharT* __s,
  size_type __len2);

      constexpr
      void
      _M_erase(size_type __pos, size_type __n);

    public:







      constexpr
      basic_string()
      noexcept(is_nothrow_default_constructible<_Alloc>::value)
      : _M_dataplus(_M_local_data())
      {
 _M_init_local_buf();
 _M_set_length(0);
      }




      constexpr
      explicit
      basic_string(const _Alloc& __a) noexcept
      : _M_dataplus(_M_local_data(), __a)
      {
 _M_init_local_buf();
 _M_set_length(0);
      }





      constexpr
      basic_string(const basic_string& __str)
      : _M_dataplus(_M_local_data(),
      _Alloc_traits::_S_select_on_copy(__str._M_get_allocator()))
      {
 _M_construct(__str._M_data(), __str._M_data() + __str.length(),
       std::forward_iterator_tag());
      }
# 568 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      constexpr
      basic_string(const basic_string& __str, size_type __pos,
     const _Alloc& __a = _Alloc())
      : _M_dataplus(_M_local_data(), __a)
      {
 const _CharT* __start = __str._M_data()
   + __str._M_check(__pos, "basic_string::basic_string");
 _M_construct(__start, __start + __str._M_limit(__pos, npos),
       std::forward_iterator_tag());
      }







      constexpr
      basic_string(const basic_string& __str, size_type __pos,
     size_type __n)
      : _M_dataplus(_M_local_data())
      {
 const _CharT* __start = __str._M_data()
   + __str._M_check(__pos, "basic_string::basic_string");
 _M_construct(__start, __start + __str._M_limit(__pos, __n),
       std::forward_iterator_tag());
      }
# 603 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      constexpr
      basic_string(const basic_string& __str, size_type __pos,
     size_type __n, const _Alloc& __a)
      : _M_dataplus(_M_local_data(), __a)
      {
 const _CharT* __start
   = __str._M_data() + __str._M_check(__pos, "string::string");
 _M_construct(__start, __start + __str._M_limit(__pos, __n),
       std::forward_iterator_tag());
      }
# 623 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      constexpr
      basic_string(const _CharT* __s, size_type __n,
     const _Alloc& __a = _Alloc())
      : _M_dataplus(_M_local_data(), __a)
      {

 if (__s == 0 && __n > 0)
   std::__throw_logic_error(("basic_string: " "construction from null is not valid"));

 _M_construct(__s, __s + __n, std::forward_iterator_tag());
      }
# 643 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      template<typename = _RequireAllocator<_Alloc>>

      constexpr
      basic_string(const _CharT* __s, const _Alloc& __a = _Alloc())
      : _M_dataplus(_M_local_data(), __a)
      {

 if (__s == 0)
   std::__throw_logic_error(("basic_string: " "construction from null is not valid"));

 const _CharT* __end = __s + traits_type::length(__s);
 _M_construct(__s, __end, forward_iterator_tag());
      }
# 666 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      template<typename = _RequireAllocator<_Alloc>>

      constexpr
      basic_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc())
      : _M_dataplus(_M_local_data(), __a)
      { _M_construct(__n, __c); }
# 681 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      constexpr
      basic_string(basic_string&& __str) noexcept
      : _M_dataplus(_M_local_data(), std::move(__str._M_get_allocator()))
      {
 if (__str._M_is_local())
   {
     _M_init_local_buf();
     traits_type::copy(_M_local_buf, __str._M_local_buf,
         __str.length() + 1);
   }
 else
   {
     _M_data(__str._M_data());
     _M_capacity(__str._M_allocated_capacity);
   }




 _M_length(__str.length());
 __str._M_data(__str._M_use_local_data());
 __str._M_set_length(0);
      }






      constexpr
      basic_string(initializer_list<_CharT> __l, const _Alloc& __a = _Alloc())
      : _M_dataplus(_M_local_data(), __a)
      { _M_construct(__l.begin(), __l.end(), std::forward_iterator_tag()); }

      constexpr
      basic_string(const basic_string& __str, const _Alloc& __a)
      : _M_dataplus(_M_local_data(), __a)
      { _M_construct(__str.begin(), __str.end(), std::forward_iterator_tag()); }

      constexpr
      basic_string(basic_string&& __str, const _Alloc& __a)
      noexcept(_Alloc_traits::_S_always_equal())
      : _M_dataplus(_M_local_data(), __a)
      {
 if (__str._M_is_local())
   {
     _M_init_local_buf();
     traits_type::copy(_M_local_buf, __str._M_local_buf,
         __str.length() + 1);
     _M_length(__str.length());
     __str._M_set_length(0);
   }
 else if (_Alloc_traits::_S_always_equal()
     || __str.get_allocator() == __a)
   {
     _M_data(__str._M_data());
     _M_length(__str.length());
     _M_capacity(__str._M_allocated_capacity);
     __str._M_data(__str._M_use_local_data());
     __str._M_set_length(0);
   }
 else
   _M_construct(__str.begin(), __str.end(), std::forward_iterator_tag());
      }



      basic_string(nullptr_t) = delete;
      basic_string& operator=(nullptr_t) = delete;
# 759 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      template<typename _InputIterator,
        typename = std::_RequireInputIter<_InputIterator>>



 constexpr
        basic_string(_InputIterator __beg, _InputIterator __end,
       const _Alloc& __a = _Alloc())
 : _M_dataplus(_M_local_data(), __a), _M_string_length(0)
 {

   _M_construct(__beg, __end, std::__iterator_category(__beg));




 }
# 785 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      template<typename _Tp,
        typename = enable_if_t<is_convertible_v<const _Tp&, __sv_type>>>
 constexpr
 basic_string(const _Tp& __t, size_type __pos, size_type __n,
       const _Alloc& __a = _Alloc())
 : basic_string(_S_to_string_view(__t).substr(__pos, __n), __a) { }






      template<typename _Tp, typename = _If_sv<_Tp, void>>
 constexpr
 explicit
 basic_string(const _Tp& __t, const _Alloc& __a = _Alloc())
 : basic_string(__sv_wrapper(_S_to_string_view(__t)), __a) { }





      constexpr
      ~basic_string()
      { _M_dispose(); }





      constexpr
      basic_string&
      operator=(const basic_string& __str)
      {
 return this->assign(__str);
      }





      constexpr
      basic_string&
      operator=(const _CharT* __s)
      { return this->assign(__s); }
# 838 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      constexpr
      basic_string&
      operator=(_CharT __c)
      {
 this->assign(1, __c);
 return *this;
      }
# 856 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      constexpr
      basic_string&
      operator=(basic_string&& __str)
      noexcept(_Alloc_traits::_S_nothrow_move())
      {
 const bool __equal_allocs = _Alloc_traits::_S_always_equal()
   || _M_get_allocator() == __str._M_get_allocator();
 if (!_M_is_local() && _Alloc_traits::_S_propagate_on_move_assign()
     && !__equal_allocs)
   {

     _M_destroy(_M_allocated_capacity);
     _M_data(_M_local_data());
     _M_set_length(0);
   }

 std::__alloc_on_move(_M_get_allocator(), __str._M_get_allocator());

 if (__str._M_is_local())
   {



     if (__builtin_expect(std::__addressof(__str) != this, true))
       {
  if (__str.size())
    this->_S_copy(_M_data(), __str._M_data(), __str.size());
  _M_set_length(__str.size());
       }
   }
 else if (_Alloc_traits::_S_propagate_on_move_assign() || __equal_allocs)
   {

     pointer __data = nullptr;
     size_type __capacity;
     if (!_M_is_local())
       {
  if (__equal_allocs)
    {

      __data = _M_data();
      __capacity = _M_allocated_capacity;
    }
  else
    _M_destroy(_M_allocated_capacity);
       }

     _M_data(__str._M_data());
     _M_length(__str.length());
     _M_capacity(__str._M_allocated_capacity);
     if (__data)
       {
  __str._M_data(__data);
  __str._M_capacity(__capacity);
       }
     else
       __str._M_data(__str._M_use_local_data());
   }
 else
   assign(__str);
 __str.clear();
 return *this;
      }





      constexpr
      basic_string&
      operator=(initializer_list<_CharT> __l)
      {
 this->assign(__l.begin(), __l.size());
 return *this;
      }







     template<typename _Tp>
       constexpr
       _If_sv<_Tp, basic_string&>
       operator=(const _Tp& __svt)
       { return this->assign(__svt); }





      constexpr
      operator __sv_type() const noexcept
      { return __sv_type(data(), size()); }







      [[__nodiscard__]] constexpr
      iterator
      begin() noexcept
      { return iterator(_M_data()); }





      [[__nodiscard__]] constexpr
      const_iterator
      begin() const noexcept
      { return const_iterator(_M_data()); }





      [[__nodiscard__]] constexpr
      iterator
      end() noexcept
      { return iterator(_M_data() + this->size()); }





      [[__nodiscard__]] constexpr
      const_iterator
      end() const noexcept
      { return const_iterator(_M_data() + this->size()); }






      [[__nodiscard__]] constexpr
      reverse_iterator
      rbegin() noexcept
      { return reverse_iterator(this->end()); }






      [[__nodiscard__]] constexpr
      const_reverse_iterator
      rbegin() const noexcept
      { return const_reverse_iterator(this->end()); }






      [[__nodiscard__]] constexpr
      reverse_iterator
      rend() noexcept
      { return reverse_iterator(this->begin()); }






      [[__nodiscard__]] constexpr
      const_reverse_iterator
      rend() const noexcept
      { return const_reverse_iterator(this->begin()); }






      [[__nodiscard__]] constexpr
      const_iterator
      cbegin() const noexcept
      { return const_iterator(this->_M_data()); }





      [[__nodiscard__]] constexpr
      const_iterator
      cend() const noexcept
      { return const_iterator(this->_M_data() + this->size()); }






      [[__nodiscard__]] constexpr
      const_reverse_iterator
      crbegin() const noexcept
      { return const_reverse_iterator(this->end()); }






      [[__nodiscard__]] constexpr
      const_reverse_iterator
      crend() const noexcept
      { return const_reverse_iterator(this->begin()); }


    public:



      [[__nodiscard__]] constexpr
      size_type
      size() const noexcept
      { return _M_string_length; }



      [[__nodiscard__]] constexpr
      size_type
      length() const noexcept
      { return _M_string_length; }


      [[__nodiscard__]] constexpr
      size_type
      max_size() const noexcept
      { return (_Alloc_traits::max_size(_M_get_allocator()) - 1) / 2; }
# 1102 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      constexpr
      void
      resize(size_type __n, _CharT __c);
# 1116 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      constexpr
      void
      resize(size_type __n)
      { this->resize(__n, _CharT()); }


#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"

      constexpr
      void
      shrink_to_fit() noexcept
      { reserve(); }
#pragma GCC diagnostic pop
# 1162 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      template<typename _Operation>
 constexpr void
 resize_and_overwrite(size_type __n, _Operation __op);




      template<typename _Operation>
 constexpr void
 __resize_and_overwrite(size_type __n, _Operation __op);






      [[__nodiscard__]] constexpr
      size_type
      capacity() const noexcept
      {
 return _M_is_local() ? size_type(_S_local_capacity)
                      : _M_allocated_capacity;
      }
# 1203 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      constexpr
      void
      reserve(size_type __res_arg);





      [[deprecated("use shrink_to_fit() instead")]]

      constexpr
      void
      reserve();




      constexpr
      void
      clear() noexcept
      { _M_set_length(0); }





      [[__nodiscard__]] constexpr
      bool
      empty() const noexcept
      { return this->size() == 0; }
# 1245 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      const_reference
      operator[] (size_type __pos) const noexcept
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__pos <= size()), false)) std::__glibcxx_assert_fail(); } while (false);
 return _M_data()[__pos];
      }
# 1263 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      reference
      operator[](size_type __pos)
      {


 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__pos <= size()), false)) std::__glibcxx_assert_fail(); } while (false);

                                                                   ;
 return _M_data()[__pos];
      }
# 1285 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      const_reference
      at(size_type __n) const
      {
 if (__n >= this->size())
   __throw_out_of_range_fmt(("basic_string::at: __n " "(which is %zu) >= this->size() " "(which is %zu)"),


       __n, this->size());
 return _M_data()[__n];
      }
# 1307 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      reference
      at(size_type __n)
      {
 if (__n >= size())
   __throw_out_of_range_fmt(("basic_string::at: __n " "(which is %zu) >= this->size() " "(which is %zu)"),


       __n, this->size());
 return _M_data()[__n];
      }






      [[__nodiscard__]] constexpr
      reference
      front() noexcept
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(!empty()), false)) std::__glibcxx_assert_fail(); } while (false);
 return operator[](0);
      }





      [[__nodiscard__]] constexpr
      const_reference
      front() const noexcept
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(!empty()), false)) std::__glibcxx_assert_fail(); } while (false);
 return operator[](0);
      }





      [[__nodiscard__]] constexpr
      reference
      back() noexcept
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(!empty()), false)) std::__glibcxx_assert_fail(); } while (false);
 return operator[](this->size() - 1);
      }





      [[__nodiscard__]] constexpr
      const_reference
      back() const noexcept
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(!empty()), false)) std::__glibcxx_assert_fail(); } while (false);
 return operator[](this->size() - 1);
      }
# 1375 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      constexpr
      basic_string&
      operator+=(const basic_string& __str)
      { return this->append(__str); }






      constexpr
      basic_string&
      operator+=(const _CharT* __s)
      { return this->append(__s); }






      constexpr
      basic_string&
      operator+=(_CharT __c)
      {
 this->push_back(__c);
 return *this;
      }







      constexpr
      basic_string&
      operator+=(initializer_list<_CharT> __l)
      { return this->append(__l.begin(), __l.size()); }
# 1421 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      template<typename _Tp>
 constexpr
 _If_sv<_Tp, basic_string&>
 operator+=(const _Tp& __svt)
 { return this->append(__svt); }







      constexpr
      basic_string&
      append(const basic_string& __str)
      { return this->append(__str._M_data(), __str.size()); }
# 1451 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      constexpr
      basic_string&
      append(const basic_string& __str, size_type __pos, size_type __n = npos)
      { return this->append(__str._M_data()
       + __str._M_check(__pos, "basic_string::append"),
       __str._M_limit(__pos, __n)); }







      constexpr
      basic_string&
      append(const _CharT* __s, size_type __n)
      {
                                        ;
 _M_check_length(size_type(0), __n, "basic_string::append");
 return _M_append(__s, __n);
      }






      constexpr
      basic_string&
      append(const _CharT* __s)
      {
                               ;
 const size_type __n = traits_type::length(__s);
 _M_check_length(size_type(0), __n, "basic_string::append");
 return _M_append(__s, __n);
      }
# 1496 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      constexpr
      basic_string&
      append(size_type __n, _CharT __c)
      { return _M_replace_aux(this->size(), size_type(0), __n, __c); }







      constexpr
      basic_string&
      append(initializer_list<_CharT> __l)
      { return this->append(__l.begin(), __l.size()); }
# 1522 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      template<class _InputIterator,
        typename = std::_RequireInputIter<_InputIterator>>
 constexpr



        basic_string&
        append(_InputIterator __first, _InputIterator __last)
        { return this->replace(end(), end(), __first, __last); }







      template<typename _Tp>
 constexpr
        _If_sv<_Tp, basic_string&>
        append(const _Tp& __svt)
        {
          __sv_type __sv = __svt;
          return this->append(__sv.data(), __sv.size());
        }
# 1554 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      template<typename _Tp>
 constexpr
        _If_sv<_Tp, basic_string&>
 append(const _Tp& __svt, size_type __pos, size_type __n = npos)
 {
   __sv_type __sv = __svt;
   return _M_append(__sv.data()
       + std::__sv_check(__sv.size(), __pos, "basic_string::append"),
       std::__sv_limit(__sv.size(), __pos, __n));
 }






      constexpr
      void
      push_back(_CharT __c)
      {
 const size_type __size = this->size();
 if (__size + 1 > this->capacity())
   this->_M_mutate(__size, size_type(0), 0, size_type(1));
 traits_type::assign(this->_M_data()[__size], __c);
 this->_M_set_length(__size + 1);
      }






      constexpr
      basic_string&
      assign(const basic_string& __str)
      {

 if (_Alloc_traits::_S_propagate_on_copy_assign())
   {
     if (!_Alloc_traits::_S_always_equal() && !_M_is_local()
  && _M_get_allocator() != __str._M_get_allocator())
       {


  if (__str.size() <= _S_local_capacity)
    {
      _M_destroy(_M_allocated_capacity);
      _M_data(_M_use_local_data());
      _M_set_length(0);
    }
  else
    {
      const auto __len = __str.size();
      auto __alloc = __str._M_get_allocator();

      auto __ptr = _S_allocate(__alloc, __len + 1);
      _M_destroy(_M_allocated_capacity);
      _M_data(__ptr);
      _M_capacity(__len);
      _M_set_length(__len);
    }
       }
     std::__alloc_on_copy(_M_get_allocator(), __str._M_get_allocator());
   }

 this->_M_assign(__str);
 return *this;
      }
# 1632 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      constexpr
      basic_string&
      assign(basic_string&& __str)
      noexcept(_Alloc_traits::_S_nothrow_move())
      {


 return *this = std::move(__str);
      }
# 1656 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      constexpr
      basic_string&
      assign(const basic_string& __str, size_type __pos, size_type __n = npos)
      { return _M_replace(size_type(0), this->size(), __str._M_data()
     + __str._M_check(__pos, "basic_string::assign"),
     __str._M_limit(__pos, __n)); }
# 1673 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      constexpr
      basic_string&
      assign(const _CharT* __s, size_type __n)
      {
                                        ;
 return _M_replace(size_type(0), this->size(), __s, __n);
      }
# 1690 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      constexpr
      basic_string&
      assign(const _CharT* __s)
      {
                               ;
 return _M_replace(size_type(0), this->size(), __s,
     traits_type::length(__s));
      }
# 1708 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      constexpr
      basic_string&
      assign(size_type __n, _CharT __c)
      { return _M_replace_aux(size_type(0), this->size(), __n, __c); }
# 1722 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++17-extensions"
      template<class _InputIterator,
        typename = std::_RequireInputIter<_InputIterator>>
 constexpr
 basic_string&
 assign(_InputIterator __first, _InputIterator __last)
 {

   if constexpr (contiguous_iterator<_InputIterator>
     && is_same_v<iter_value_t<_InputIterator>, _CharT>)




     {
                                                      ;
       return _M_replace(size_type(0), size(),
    std::__to_address(__first), __last - __first);
     }
   else
     return *this = basic_string(__first, __last, get_allocator());
 }
#pragma GCC diagnostic pop
# 1759 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      constexpr
      basic_string&
      assign(initializer_list<_CharT> __l)
      {


 const size_type __n = __l.size();
 if (__n > capacity())
   *this = basic_string(__l.begin(), __l.end(), get_allocator());
 else
   {
     if (__n)
       _S_copy(_M_data(), __l.begin(), __n);
     _M_set_length(__n);
   }
 return *this;
      }
# 1784 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      template<typename _Tp>
 constexpr
 _If_sv<_Tp, basic_string&>
 assign(const _Tp& __svt)
 {
   __sv_type __sv = __svt;
   return this->assign(__sv.data(), __sv.size());
 }
# 1800 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      template<typename _Tp>
 constexpr
 _If_sv<_Tp, basic_string&>
 assign(const _Tp& __svt, size_type __pos, size_type __n = npos)
 {
   __sv_type __sv = __svt;
   return _M_replace(size_type(0), this->size(),
       __sv.data()
       + std::__sv_check(__sv.size(), __pos, "basic_string::assign"),
       std::__sv_limit(__sv.size(), __pos, __n));
 }
# 1829 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      constexpr
      iterator
      insert(const_iterator __p, size_type __n, _CharT __c)
      {
                                                         ;
 const size_type __pos = __p - begin();
 this->replace(__p, __p, __n, __c);
 return iterator(this->_M_data() + __pos);
      }
# 1872 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      template<class _InputIterator,
        typename = std::_RequireInputIter<_InputIterator>>
 constexpr
 iterator
        insert(const_iterator __p, _InputIterator __beg, _InputIterator __end)
        {
                                                           ;
   const size_type __pos = __p - begin();
   this->replace(__p, __p, __beg, __end);
   return iterator(this->_M_data() + __pos);
 }
# 1909 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      constexpr
      iterator
      insert(const_iterator __p, initializer_list<_CharT> __l)
      { return this->insert(__p, __l.begin(), __l.end()); }
# 1937 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      constexpr
      basic_string&
      insert(size_type __pos1, const basic_string& __str)
      { return this->replace(__pos1, size_type(0),
        __str._M_data(), __str.size()); }
# 1961 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      constexpr
      basic_string&
      insert(size_type __pos1, const basic_string& __str,
      size_type __pos2, size_type __n = npos)
      { return this->replace(__pos1, size_type(0), __str._M_data()
        + __str._M_check(__pos2, "basic_string::insert"),
        __str._M_limit(__pos2, __n)); }
# 1985 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      constexpr
      basic_string&
      insert(size_type __pos, const _CharT* __s, size_type __n)
      { return this->replace(__pos, size_type(0), __s, __n); }
# 2005 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      constexpr
      basic_string&
      insert(size_type __pos, const _CharT* __s)
      {
                               ;
 return this->replace(__pos, size_type(0), __s,
        traits_type::length(__s));
      }
# 2030 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      constexpr
      basic_string&
      insert(size_type __pos, size_type __n, _CharT __c)
      { return _M_replace_aux(_M_check(__pos, "basic_string::insert"),
         size_type(0), __n, __c); }
# 2049 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      constexpr
      iterator
      insert(__const_iterator __p, _CharT __c)
      {
                                                         ;
 const size_type __pos = __p - begin();
 _M_replace_aux(__pos, size_type(0), size_type(1), __c);
 return iterator(_M_data() + __pos);
      }
# 2066 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      template<typename _Tp>
 constexpr
 _If_sv<_Tp, basic_string&>
 insert(size_type __pos, const _Tp& __svt)
 {
   __sv_type __sv = __svt;
   return this->insert(__pos, __sv.data(), __sv.size());
 }
# 2083 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      template<typename _Tp>
 constexpr
 _If_sv<_Tp, basic_string&>
 insert(size_type __pos1, const _Tp& __svt,
        size_type __pos2, size_type __n = npos)
 {
   __sv_type __sv = __svt;
   return this->replace(__pos1, size_type(0),
       __sv.data()
       + std::__sv_check(__sv.size(), __pos2, "basic_string::insert"),
       std::__sv_limit(__sv.size(), __pos2, __n));
 }
# 2112 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      constexpr
      basic_string&
      erase(size_type __pos = 0, size_type __n = npos)
      {
 _M_check(__pos, "basic_string::erase");
 if (__n == npos)
   this->_M_set_length(__pos);
 else if (__n != 0)
   this->_M_erase(__pos, _M_limit(__pos, __n));
 return *this;
      }
# 2132 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      constexpr
      iterator
      erase(__const_iterator __position)
      {

                           ;
 const size_type __pos = __position - begin();
 this->_M_erase(__pos, size_type(1));
 return iterator(_M_data() + __pos);
      }
# 2152 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      constexpr
      iterator
      erase(__const_iterator __first, __const_iterator __last)
      {

                        ;
        const size_type __pos = __first - begin();
 if (__last == end())
   this->_M_set_length(__pos);
 else
   this->_M_erase(__pos, __last - __first);
 return iterator(this->_M_data() + __pos);
      }







      constexpr
      void
      pop_back() noexcept
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(!empty()), false)) std::__glibcxx_assert_fail(); } while (false);
 _M_erase(size() - 1, 1);
      }
# 2198 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      constexpr
      basic_string&
      replace(size_type __pos, size_type __n, const basic_string& __str)
      { return this->replace(__pos, __n, __str._M_data(), __str.size()); }
# 2221 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      constexpr
      basic_string&
      replace(size_type __pos1, size_type __n1, const basic_string& __str,
       size_type __pos2, size_type __n2 = npos)
      { return this->replace(__pos1, __n1, __str._M_data()
        + __str._M_check(__pos2, "basic_string::replace"),
        __str._M_limit(__pos2, __n2)); }
# 2247 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      constexpr
      basic_string&
      replace(size_type __pos, size_type __n1, const _CharT* __s,
       size_type __n2)
      {
                                         ;
 return _M_replace(_M_check(__pos, "basic_string::replace"),
     _M_limit(__pos, __n1), __s, __n2);
      }
# 2273 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      constexpr
      basic_string&
      replace(size_type __pos, size_type __n1, const _CharT* __s)
      {
                               ;
 return this->replace(__pos, __n1, __s, traits_type::length(__s));
      }
# 2298 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      constexpr
      basic_string&
      replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c)
      { return _M_replace_aux(_M_check(__pos, "basic_string::replace"),
         _M_limit(__pos, __n1), __n2, __c); }
# 2317 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      constexpr
      basic_string&
      replace(__const_iterator __i1, __const_iterator __i2,
       const basic_string& __str)
      { return this->replace(__i1, __i2, __str._M_data(), __str.size()); }
# 2338 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      constexpr
      basic_string&
      replace(__const_iterator __i1, __const_iterator __i2,
       const _CharT* __s, size_type __n)
      {

                      ;
 return this->replace(__i1 - begin(), __i2 - __i1, __s, __n);
      }
# 2361 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      constexpr
      basic_string&
      replace(__const_iterator __i1, __const_iterator __i2, const _CharT* __s)
      {
                               ;
 return this->replace(__i1, __i2, __s, traits_type::length(__s));
      }
# 2383 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      constexpr
      basic_string&
      replace(__const_iterator __i1, __const_iterator __i2, size_type __n,
       _CharT __c)
      {

                      ;
 return _M_replace_aux(__i1 - begin(), __i2 - __i1, __n, __c);
      }
# 2409 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      template<class _InputIterator,
        typename = std::_RequireInputIter<_InputIterator>>
 constexpr
        basic_string&
        replace(const_iterator __i1, const_iterator __i2,
  _InputIterator __k1, _InputIterator __k2)
        {

                        ;
                                             ;
   return this->_M_replace_dispatch(__i1, __i2, __k1, __k2,
        std::__false_type());
 }
# 2442 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      constexpr
      basic_string&
      replace(__const_iterator __i1, __const_iterator __i2,
       _CharT* __k1, _CharT* __k2)
      {

                      ;
                                           ;
 return this->replace(__i1 - begin(), __i2 - __i1,
        __k1, __k2 - __k1);
      }

      constexpr
      basic_string&
      replace(__const_iterator __i1, __const_iterator __i2,
       const _CharT* __k1, const _CharT* __k2)
      {

                      ;
                                           ;
 return this->replace(__i1 - begin(), __i2 - __i1,
        __k1, __k2 - __k1);
      }

      constexpr
      basic_string&
      replace(__const_iterator __i1, __const_iterator __i2,
       iterator __k1, iterator __k2)
      {

                      ;
                                           ;
 return this->replace(__i1 - begin(), __i2 - __i1,
        __k1.base(), __k2 - __k1);
      }

      constexpr
      basic_string&
      replace(__const_iterator __i1, __const_iterator __i2,
       const_iterator __k1, const_iterator __k2)
      {

                      ;
                                           ;
 return this->replace(__i1 - begin(), __i2 - __i1,
        __k1.base(), __k2 - __k1);
      }
# 2505 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      constexpr
      basic_string& replace(const_iterator __i1, const_iterator __i2,
       initializer_list<_CharT> __l)
      { return this->replace(__i1, __i2, __l.begin(), __l.size()); }
# 2519 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      template<typename _Tp>
 constexpr
 _If_sv<_Tp, basic_string&>
 replace(size_type __pos, size_type __n, const _Tp& __svt)
 {
   __sv_type __sv = __svt;
   return this->replace(__pos, __n, __sv.data(), __sv.size());
 }
# 2537 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      template<typename _Tp>
 constexpr
 _If_sv<_Tp, basic_string&>
 replace(size_type __pos1, size_type __n1, const _Tp& __svt,
  size_type __pos2, size_type __n2 = npos)
 {
   __sv_type __sv = __svt;
   return this->replace(__pos1, __n1,
       __sv.data()
       + std::__sv_check(__sv.size(), __pos2, "basic_string::replace"),
       std::__sv_limit(__sv.size(), __pos2, __n2));
 }
# 2559 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      template<typename _Tp>
 constexpr
 _If_sv<_Tp, basic_string&>
 replace(const_iterator __i1, const_iterator __i2, const _Tp& __svt)
 {
   __sv_type __sv = __svt;
   return this->replace(__i1 - begin(), __i2 - __i1, __sv);
 }


    private:
      template<class _Integer>
 constexpr
 basic_string&
 _M_replace_dispatch(const_iterator __i1, const_iterator __i2,
       _Integer __n, _Integer __val, __true_type)
        { return _M_replace_aux(__i1 - begin(), __i2 - __i1, __n, __val); }

      template<class _InputIterator>
 constexpr
 basic_string&
 _M_replace_dispatch(const_iterator __i1, const_iterator __i2,
       _InputIterator __k1, _InputIterator __k2,
       __false_type);

      constexpr
      basic_string&
      _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
       _CharT __c);

      __attribute__((__noinline__, __noclone__, __cold__)) void
      _M_replace_cold(pointer __p, size_type __len1, const _CharT* __s,
        const size_type __len2, const size_type __how_much);

      constexpr
      basic_string&
      _M_replace(size_type __pos, size_type __len1, const _CharT* __s,
   const size_type __len2);

      constexpr
      basic_string&
      _M_append(const _CharT* __s, size_type __n);

    public:
# 2616 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      constexpr
      size_type
      copy(_CharT* __s, size_type __n, size_type __pos = 0) const;
# 2627 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      constexpr
      void
      swap(basic_string& __s) noexcept;
# 2638 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      const _CharT*
      c_str() const noexcept
      { return _M_data(); }
# 2651 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      const _CharT*
      data() const noexcept
      { return _M_data(); }
# 2663 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      _CharT*
      data() noexcept
      { return _M_data(); }





      [[__nodiscard__]] constexpr
      allocator_type
      get_allocator() const noexcept
      { return _M_get_allocator(); }
# 2689 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      size_type
      find(const _CharT* __s, size_type __pos, size_type __n) const
      noexcept;
# 2704 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      size_type
      find(const basic_string& __str, size_type __pos = 0) const
      noexcept
      { return this->find(__str.data(), __pos, __str.size()); }
# 2717 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      template<typename _Tp>
 [[__nodiscard__]] constexpr
 _If_sv<_Tp, size_type>
 find(const _Tp& __svt, size_type __pos = 0) const
 noexcept(is_same<_Tp, __sv_type>::value)
 {
   __sv_type __sv = __svt;
   return this->find(__sv.data(), __pos, __sv.size());
 }
# 2738 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      size_type
      find(const _CharT* __s, size_type __pos = 0) const noexcept
      {
                               ;
 return this->find(__s, __pos, traits_type::length(__s));
      }
# 2756 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      size_type
      find(_CharT __c, size_type __pos = 0) const noexcept;
# 2770 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      size_type
      rfind(const basic_string& __str, size_type __pos = npos) const
      noexcept
      { return this->rfind(__str.data(), __pos, __str.size()); }
# 2783 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      template<typename _Tp>
 [[__nodiscard__]] constexpr
 _If_sv<_Tp, size_type>
 rfind(const _Tp& __svt, size_type __pos = npos) const
 noexcept(is_same<_Tp, __sv_type>::value)
 {
   __sv_type __sv = __svt;
   return this->rfind(__sv.data(), __pos, __sv.size());
 }
# 2806 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      size_type
      rfind(const _CharT* __s, size_type __pos, size_type __n) const
      noexcept;
# 2821 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      size_type
      rfind(const _CharT* __s, size_type __pos = npos) const
      {
                               ;
 return this->rfind(__s, __pos, traits_type::length(__s));
      }
# 2839 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      size_type
      rfind(_CharT __c, size_type __pos = npos) const noexcept;
# 2854 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      size_type
      find_first_of(const basic_string& __str, size_type __pos = 0) const
      noexcept
      { return this->find_first_of(__str.data(), __pos, __str.size()); }
# 2868 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      template<typename _Tp>
 [[__nodiscard__]] constexpr
 _If_sv<_Tp, size_type>
 find_first_of(const _Tp& __svt, size_type __pos = 0) const
 noexcept(is_same<_Tp, __sv_type>::value)
 {
   __sv_type __sv = __svt;
   return this->find_first_of(__sv.data(), __pos, __sv.size());
 }
# 2891 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      size_type
      find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
      noexcept;
# 2906 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      size_type
      find_first_of(const _CharT* __s, size_type __pos = 0) const
      noexcept
      {
                               ;
 return this->find_first_of(__s, __pos, traits_type::length(__s));
      }
# 2927 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      size_type
      find_first_of(_CharT __c, size_type __pos = 0) const noexcept
      { return this->find(__c, __pos); }
# 2943 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      size_type
      find_last_of(const basic_string& __str, size_type __pos = npos) const
      noexcept
      { return this->find_last_of(__str.data(), __pos, __str.size()); }
# 2957 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      template<typename _Tp>
 [[__nodiscard__]] constexpr
 _If_sv<_Tp, size_type>
 find_last_of(const _Tp& __svt, size_type __pos = npos) const
 noexcept(is_same<_Tp, __sv_type>::value)
 {
   __sv_type __sv = __svt;
   return this->find_last_of(__sv.data(), __pos, __sv.size());
 }
# 2980 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      size_type
      find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
      noexcept;
# 2995 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      size_type
      find_last_of(const _CharT* __s, size_type __pos = npos) const
      noexcept
      {
                               ;
 return this->find_last_of(__s, __pos, traits_type::length(__s));
      }
# 3016 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      size_type
      find_last_of(_CharT __c, size_type __pos = npos) const noexcept
      { return this->rfind(__c, __pos); }
# 3031 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      size_type
      find_first_not_of(const basic_string& __str, size_type __pos = 0) const
      noexcept
      { return this->find_first_not_of(__str.data(), __pos, __str.size()); }
# 3045 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      template<typename _Tp>
 [[__nodiscard__]] constexpr
 _If_sv<_Tp, size_type>
 find_first_not_of(const _Tp& __svt, size_type __pos = 0) const
 noexcept(is_same<_Tp, __sv_type>::value)
 {
   __sv_type __sv = __svt;
   return this->find_first_not_of(__sv.data(), __pos, __sv.size());
 }
# 3068 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      size_type
      find_first_not_of(const _CharT* __s, size_type __pos,
   size_type __n) const noexcept;
# 3083 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      size_type
      find_first_not_of(const _CharT* __s, size_type __pos = 0) const
      noexcept
      {
                               ;
 return this->find_first_not_of(__s, __pos, traits_type::length(__s));
      }
# 3102 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      size_type
      find_first_not_of(_CharT __c, size_type __pos = 0) const
      noexcept;
# 3118 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      size_type
      find_last_not_of(const basic_string& __str, size_type __pos = npos) const
      noexcept
      { return this->find_last_not_of(__str.data(), __pos, __str.size()); }
# 3132 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      template<typename _Tp>
 [[__nodiscard__]] constexpr
 _If_sv<_Tp, size_type>
 find_last_not_of(const _Tp& __svt, size_type __pos = npos) const
 noexcept(is_same<_Tp, __sv_type>::value)
 {
   __sv_type __sv = __svt;
   return this->find_last_not_of(__sv.data(), __pos, __sv.size());
 }
# 3155 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      size_type
      find_last_not_of(const _CharT* __s, size_type __pos,
         size_type __n) const noexcept;
# 3170 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      size_type
      find_last_not_of(const _CharT* __s, size_type __pos = npos) const
      noexcept
      {
                               ;
 return this->find_last_not_of(__s, __pos, traits_type::length(__s));
      }
# 3189 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      size_type
      find_last_not_of(_CharT __c, size_type __pos = npos) const
      noexcept;
# 3206 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      basic_string
      substr(size_type __pos = 0, size_type __n = npos) const
      { return basic_string(*this,
       _M_check(__pos, "basic_string::substr"), __n); }
# 3226 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      int
      compare(const basic_string& __str) const
      {
 const size_type __size = this->size();
 const size_type __osize = __str.size();
 const size_type __len = std::min(__size, __osize);

 int __r = traits_type::compare(_M_data(), __str.data(), __len);
 if (!__r)
   __r = _S_compare(__size, __osize);
 return __r;
      }







      template<typename _Tp>
 [[__nodiscard__]] constexpr
 _If_sv<_Tp, int>
 compare(const _Tp& __svt) const
 noexcept(is_same<_Tp, __sv_type>::value)
 {
   __sv_type __sv = __svt;
   const size_type __size = this->size();
   const size_type __osize = __sv.size();
   const size_type __len = std::min(__size, __osize);

   int __r = traits_type::compare(_M_data(), __sv.data(), __len);
   if (!__r)
     __r = _S_compare(__size, __osize);
   return __r;
 }
# 3271 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      template<typename _Tp>
 [[__nodiscard__]] constexpr
 _If_sv<_Tp, int>
 compare(size_type __pos, size_type __n, const _Tp& __svt) const
 noexcept(is_same<_Tp, __sv_type>::value)
 {
   __sv_type __sv = __svt;
   return __sv_type(*this).substr(__pos, __n).compare(__sv);
 }
# 3291 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      template<typename _Tp>
 [[__nodiscard__]] constexpr
 _If_sv<_Tp, int>
 compare(size_type __pos1, size_type __n1, const _Tp& __svt,
  size_type __pos2, size_type __n2 = npos) const
 noexcept(is_same<_Tp, __sv_type>::value)
 {
   __sv_type __sv = __svt;
   return __sv_type(*this)
     .substr(__pos1, __n1).compare(__sv.substr(__pos2, __n2));
 }
# 3323 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      int
      compare(size_type __pos, size_type __n, const basic_string& __str) const
      {
 _M_check(__pos, "basic_string::compare");
 __n = _M_limit(__pos, __n);
 const size_type __osize = __str.size();
 const size_type __len = std::min(__n, __osize);
 int __r = traits_type::compare(_M_data() + __pos, __str.data(), __len);
 if (!__r)
   __r = _S_compare(__n, __osize);
 return __r;
      }
# 3360 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      int
      compare(size_type __pos1, size_type __n1, const basic_string& __str,
       size_type __pos2, size_type __n2 = npos) const
      {
 _M_check(__pos1, "basic_string::compare");
 __str._M_check(__pos2, "basic_string::compare");
 __n1 = _M_limit(__pos1, __n1);
 __n2 = __str._M_limit(__pos2, __n2);
 const size_type __len = std::min(__n1, __n2);
 int __r = traits_type::compare(_M_data() + __pos1,
           __str.data() + __pos2, __len);
 if (!__r)
   __r = _S_compare(__n1, __n2);
 return __r;
      }
# 3391 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      int
      compare(const _CharT* __s) const noexcept
      {
                               ;
 const size_type __size = this->size();
 const size_type __osize = traits_type::length(__s);
 const size_type __len = std::min(__size, __osize);
 int __r = traits_type::compare(_M_data(), __s, __len);
 if (!__r)
   __r = _S_compare(__size, __osize);
 return __r;
      }
# 3426 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      int
      compare(size_type __pos, size_type __n1, const _CharT* __s) const
      {
                               ;
 _M_check(__pos, "basic_string::compare");
 __n1 = _M_limit(__pos, __n1);
 const size_type __osize = traits_type::length(__s);
 const size_type __len = std::min(__n1, __osize);
 int __r = traits_type::compare(_M_data() + __pos, __s, __len);
 if (!__r)
   __r = _S_compare(__n1, __osize);
 return __r;
      }
# 3465 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
      [[__nodiscard__]] constexpr
      int
      compare(size_type __pos, size_type __n1, const _CharT* __s,
       size_type __n2) const
      {
                                         ;
 _M_check(__pos, "basic_string::compare");
 __n1 = _M_limit(__pos, __n1);
 const size_type __len = std::min(__n1, __n2);
 int __r = traits_type::compare(_M_data() + __pos, __s, __len);
 if (!__r)
   __r = _S_compare(__n1, __n2);
 return __r;
      }


      [[nodiscard]]
      constexpr bool
      starts_with(basic_string_view<_CharT, _Traits> __x) const noexcept
      { return __sv_type(this->data(), this->size()).starts_with(__x); }

      [[nodiscard]]
      constexpr bool
      starts_with(_CharT __x) const noexcept
      { return __sv_type(this->data(), this->size()).starts_with(__x); }

      [[nodiscard, __gnu__::__nonnull__]]
      constexpr bool
      starts_with(const _CharT* __x) const noexcept
      { return __sv_type(this->data(), this->size()).starts_with(__x); }

      [[nodiscard]]
      constexpr bool
      ends_with(basic_string_view<_CharT, _Traits> __x) const noexcept
      { return __sv_type(this->data(), this->size()).ends_with(__x); }

      [[nodiscard]]
      constexpr bool
      ends_with(_CharT __x) const noexcept
      { return __sv_type(this->data(), this->size()).ends_with(__x); }

      [[nodiscard, __gnu__::__nonnull__]]
      constexpr bool
      ends_with(const _CharT* __x) const noexcept
      { return __sv_type(this->data(), this->size()).ends_with(__x); }



      [[nodiscard]]
      constexpr bool
      contains(basic_string_view<_CharT, _Traits> __x) const noexcept
      { return __sv_type(this->data(), this->size()).contains(__x); }

      [[nodiscard]]
      constexpr bool
      contains(_CharT __x) const noexcept
      { return __sv_type(this->data(), this->size()).contains(__x); }

      [[nodiscard, __gnu__::__nonnull__]]
      constexpr bool
      contains(const _CharT* __x) const noexcept
      { return __sv_type(this->data(), this->size()).contains(__x); }



      template<typename, typename, typename> friend class basic_stringbuf;
    };
}

}


namespace std __attribute__ ((__visibility__ ("default")))
{



namespace __cxx11 {
  template<typename _InputIterator, typename _CharT
      = typename iterator_traits<_InputIterator>::value_type,
    typename _Allocator = allocator<_CharT>,
    typename = _RequireInputIter<_InputIterator>,
    typename = _RequireAllocator<_Allocator>>
    basic_string(_InputIterator, _InputIterator, _Allocator = _Allocator())
      -> basic_string<_CharT, char_traits<_CharT>, _Allocator>;



  template<typename _CharT, typename _Traits,
    typename _Allocator = allocator<_CharT>,
    typename = _RequireAllocator<_Allocator>>
    basic_string(basic_string_view<_CharT, _Traits>, const _Allocator& = _Allocator())
      -> basic_string<_CharT, _Traits, _Allocator>;

  template<typename _CharT, typename _Traits,
    typename _Allocator = allocator<_CharT>,
    typename = _RequireAllocator<_Allocator>>
    basic_string(basic_string_view<_CharT, _Traits>,
   typename basic_string<_CharT, _Traits, _Allocator>::size_type,
   typename basic_string<_CharT, _Traits, _Allocator>::size_type,
   const _Allocator& = _Allocator())
      -> basic_string<_CharT, _Traits, _Allocator>;
}


  template<typename _Str>
    constexpr
    inline _Str
    __str_concat(typename _Str::value_type const* __lhs,
   typename _Str::size_type __lhs_len,
   typename _Str::value_type const* __rhs,
   typename _Str::size_type __rhs_len,
   typename _Str::allocator_type const& __a)
    {
      typedef typename _Str::allocator_type allocator_type;
      typedef __gnu_cxx::__alloc_traits<allocator_type> _Alloc_traits;
      _Str __str(_Alloc_traits::_S_select_on_copy(__a));
      __str.reserve(__lhs_len + __rhs_len);
      __str.append(__lhs, __lhs_len);
      __str.append(__rhs, __rhs_len);
      return __str;
    }
# 3595 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    [[__nodiscard__]] constexpr
    inline basic_string<_CharT, _Traits, _Alloc>
    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    {
      typedef basic_string<_CharT, _Traits, _Alloc> _Str;
      return std::__str_concat<_Str>(__lhs.c_str(), __lhs.size(),
         __rhs.c_str(), __rhs.size(),
         __lhs.get_allocator());
    }







  template<typename _CharT, typename _Traits, typename _Alloc>
    [[__nodiscard__]] constexpr
    inline basic_string<_CharT,_Traits,_Alloc>
    operator+(const _CharT* __lhs,
       const basic_string<_CharT,_Traits,_Alloc>& __rhs)
    {
                                      ;
      typedef basic_string<_CharT, _Traits, _Alloc> _Str;
      return std::__str_concat<_Str>(__lhs, _Traits::length(__lhs),
         __rhs.c_str(), __rhs.size(),
         __rhs.get_allocator());
    }







  template<typename _CharT, typename _Traits, typename _Alloc>
    [[__nodiscard__]] constexpr
    inline basic_string<_CharT,_Traits,_Alloc>
    operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs)
    {
      typedef basic_string<_CharT, _Traits, _Alloc> _Str;
      return std::__str_concat<_Str>(__builtin_addressof(__lhs), 1,
         __rhs.c_str(), __rhs.size(),
         __rhs.get_allocator());
    }







  template<typename _CharT, typename _Traits, typename _Alloc>
    [[__nodiscard__]] constexpr
    inline basic_string<_CharT, _Traits, _Alloc>
    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
       const _CharT* __rhs)
    {
                                      ;
      typedef basic_string<_CharT, _Traits, _Alloc> _Str;
      return std::__str_concat<_Str>(__lhs.c_str(), __lhs.size(),
         __rhs, _Traits::length(__rhs),
         __lhs.get_allocator());
    }






  template<typename _CharT, typename _Traits, typename _Alloc>
    [[__nodiscard__]] constexpr
    inline basic_string<_CharT, _Traits, _Alloc>
    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, _CharT __rhs)
    {
      typedef basic_string<_CharT, _Traits, _Alloc> _Str;
      return std::__str_concat<_Str>(__lhs.c_str(), __lhs.size(),
         __builtin_addressof(__rhs), 1,
         __lhs.get_allocator());
    }


  template<typename _CharT, typename _Traits, typename _Alloc>
    [[__nodiscard__]] constexpr
    inline basic_string<_CharT, _Traits, _Alloc>
    operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
       const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    { return std::move(__lhs.append(__rhs)); }

  template<typename _CharT, typename _Traits, typename _Alloc>
    constexpr
    inline basic_string<_CharT, _Traits, _Alloc>
    operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
       basic_string<_CharT, _Traits, _Alloc>&& __rhs)
    { return std::move(__rhs.insert(0, __lhs)); }

  template<typename _CharT, typename _Traits, typename _Alloc>
    [[__nodiscard__]] constexpr
    inline basic_string<_CharT, _Traits, _Alloc>
    operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
       basic_string<_CharT, _Traits, _Alloc>&& __rhs)
    {

      using _Alloc_traits = allocator_traits<_Alloc>;
      bool __use_rhs = false;
      if constexpr (typename _Alloc_traits::is_always_equal{})
 __use_rhs = true;
      else if (__lhs.get_allocator() == __rhs.get_allocator())
 __use_rhs = true;
      if (__use_rhs)

 {
   const auto __size = __lhs.size() + __rhs.size();
   if (__size > __lhs.capacity() && __size <= __rhs.capacity())
     return std::move(__rhs.insert(0, __lhs));
 }
      return std::move(__lhs.append(__rhs));
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    [[__nodiscard__]] [[__nodiscard__]] constexpr
    inline basic_string<_CharT, _Traits, _Alloc>
    operator+(const _CharT* __lhs,
       basic_string<_CharT, _Traits, _Alloc>&& __rhs)
    { return std::move(__rhs.insert(0, __lhs)); }

  template<typename _CharT, typename _Traits, typename _Alloc>
    [[__nodiscard__]] constexpr
    inline basic_string<_CharT, _Traits, _Alloc>
    operator+(_CharT __lhs,
       basic_string<_CharT, _Traits, _Alloc>&& __rhs)
    { return std::move(__rhs.insert(0, 1, __lhs)); }

  template<typename _CharT, typename _Traits, typename _Alloc>
    [[__nodiscard__]] constexpr
    inline basic_string<_CharT, _Traits, _Alloc>
    operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
       const _CharT* __rhs)
    { return std::move(__lhs.append(__rhs)); }

  template<typename _CharT, typename _Traits, typename _Alloc>
    [[__nodiscard__]] constexpr
    inline basic_string<_CharT, _Traits, _Alloc>
    operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs,
       _CharT __rhs)
    { return std::move(__lhs.append(1, __rhs)); }
# 3752 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    [[__nodiscard__]] constexpr
    inline bool
    operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
        const basic_string<_CharT, _Traits, _Alloc>& __rhs)
    noexcept
    {
      return __lhs.size() == __rhs.size()
        && !_Traits::compare(__lhs.data(), __rhs.data(), __lhs.size());
    }







  template<typename _CharT, typename _Traits, typename _Alloc>
    [[__nodiscard__]] constexpr
    inline bool
    operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
        const _CharT* __rhs)
    {
      return __lhs.size() == _Traits::length(__rhs)
        && !_Traits::compare(__lhs.data(), __rhs, __lhs.size());
    }
# 3787 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    [[nodiscard]]
    constexpr auto
    operator<=>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
  const basic_string<_CharT, _Traits, _Alloc>& __rhs) noexcept
    -> decltype(__detail::__char_traits_cmp_cat<_Traits>(0))
    { return __detail::__char_traits_cmp_cat<_Traits>(__lhs.compare(__rhs)); }
# 3802 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    [[nodiscard]]
    constexpr auto
    operator<=>(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
  const _CharT* __rhs) noexcept
    -> decltype(__detail::__char_traits_cmp_cat<_Traits>(0))
    { return __detail::__char_traits_cmp_cat<_Traits>(__lhs.compare(__rhs)); }
# 4036 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    constexpr
    inline void
    swap(basic_string<_CharT, _Traits, _Alloc>& __lhs,
  basic_string<_CharT, _Traits, _Alloc>& __rhs)
    noexcept(noexcept(__lhs.swap(__rhs)))
    { __lhs.swap(__rhs); }
# 4057 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __is,
        basic_string<_CharT, _Traits, _Alloc>& __str);

  template<>
    basic_istream<char>&
    operator>>(basic_istream<char>& __is, basic_string<char>& __str);
# 4075 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
        const basic_string<_CharT, _Traits, _Alloc>& __str)
    {


      return __ostream_insert(__os, __str.data(), __str.size());
    }
# 4098 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_istream<_CharT, _Traits>&
    getline(basic_istream<_CharT, _Traits>& __is,
     basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim);
# 4115 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    inline basic_istream<_CharT, _Traits>&
    getline(basic_istream<_CharT, _Traits>& __is,
     basic_string<_CharT, _Traits, _Alloc>& __str)
    { return std::getline(__is, __str, __is.widen('\n')); }



  template<typename _CharT, typename _Traits, typename _Alloc>
    inline basic_istream<_CharT, _Traits>&
    getline(basic_istream<_CharT, _Traits>&& __is,
     basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
    { return std::getline(__is, __str, __delim); }


  template<typename _CharT, typename _Traits, typename _Alloc>
    inline basic_istream<_CharT, _Traits>&
    getline(basic_istream<_CharT, _Traits>&& __is,
     basic_string<_CharT, _Traits, _Alloc>& __str)
    { return std::getline(__is, __str); }


  template<>
    basic_istream<char>&
    getline(basic_istream<char>& __in, basic_string<char>& __str,
     char __delim);


  template<>
    basic_istream<wchar_t>&
    getline(basic_istream<wchar_t>& __in, basic_string<wchar_t>& __str,
     wchar_t __delim);



}



# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ext/string_conversions.h" 1 3
# 33 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ext/string_conversions.h" 3
# 43 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ext/string_conversions.h" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdlib" 1 3
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdlib" 3
# 44 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ext/string_conversions.h" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cwchar" 1 3
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cwchar" 3
# 45 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ext/string_conversions.h" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdio" 1 3
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdio" 3


# 1 "/usr/include/stdio.h" 1 3 4
# 28 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/bits/libc-header-start.h" 1 3 4
# 29 "/usr/include/stdio.h" 2 3 4

extern "C" {



# 1 "/usr/bin/../lib/clang/18/include/stddef.h" 1 3 4
# 77 "/usr/bin/../lib/clang/18/include/stddef.h" 3 4
# 1 "/usr/bin/../lib/clang/18/include/__stddef_size_t.h" 1 3 4
# 18 "/usr/bin/../lib/clang/18/include/__stddef_size_t.h" 3 4
typedef long unsigned int size_t;
# 78 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3 4
# 92 "/usr/bin/../lib/clang/18/include/stddef.h" 3 4
# 1 "/usr/bin/../lib/clang/18/include/__stddef_null.h" 1 3 4
# 93 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3 4
# 35 "/usr/include/stdio.h" 2 3 4


# 1 "/usr/bin/../lib/clang/18/include/stdarg.h" 1 3 4
# 38 "/usr/include/stdio.h" 2 3 4


# 1 "/usr/include/bits/types/__fpos_t.h" 1 3 4
# 10 "/usr/include/bits/types/__fpos_t.h" 3 4
typedef struct _G_fpos_t
{
  __off_t __pos;
  __mbstate_t __state;
} __fpos_t;
# 41 "/usr/include/stdio.h" 2 3 4
# 1 "/usr/include/bits/types/__fpos64_t.h" 1 3 4
# 10 "/usr/include/bits/types/__fpos64_t.h" 3 4
typedef struct _G_fpos64_t
{
  __off64_t __pos;
  __mbstate_t __state;
} __fpos64_t;
# 42 "/usr/include/stdio.h" 2 3 4


# 1 "/usr/include/bits/types/struct_FILE.h" 1 3 4
# 35 "/usr/include/bits/types/struct_FILE.h" 3 4
struct _IO_FILE;
struct _IO_marker;
struct _IO_codecvt;
struct _IO_wide_data;




typedef void _IO_lock_t;





struct _IO_FILE
{
  int _flags;


  char *_IO_read_ptr;
  char *_IO_read_end;
  char *_IO_read_base;
  char *_IO_write_base;
  char *_IO_write_ptr;
  char *_IO_write_end;
  char *_IO_buf_base;
  char *_IO_buf_end;


  char *_IO_save_base;
  char *_IO_backup_base;
  char *_IO_save_end;

  struct _IO_marker *_markers;

  struct _IO_FILE *_chain;

  int _fileno;
  int _flags2;
  __off_t _old_offset;


  unsigned short _cur_column;
  signed char _vtable_offset;
  char _shortbuf[1];

  _IO_lock_t *_lock;







  __off64_t _offset;

  struct _IO_codecvt *_codecvt;
  struct _IO_wide_data *_wide_data;
  struct _IO_FILE *_freeres_list;
  void *_freeres_buf;
  size_t __pad5;
  int _mode;

  char _unused2[15 * sizeof (int) - 4 * sizeof (void *) - sizeof (size_t)];
};
# 45 "/usr/include/stdio.h" 2 3 4


# 1 "/usr/include/bits/types/cookie_io_functions_t.h" 1 3 4
# 27 "/usr/include/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;
# 48 "/usr/include/stdio.h" 2 3 4
# 85 "/usr/include/stdio.h" 3 4
typedef __fpos_t fpos_t;




typedef __fpos64_t fpos64_t;
# 129 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/bits/stdio_lim.h" 1 3 4
# 130 "/usr/include/stdio.h" 2 3 4
# 149 "/usr/include/stdio.h" 3 4
extern FILE *stdin;
extern FILE *stdout;
extern FILE *stderr;






extern int remove (const char *__filename) noexcept (true);

extern int rename (const char *__old, const char *__new) noexcept (true);



extern int renameat (int __oldfd, const char *__old, int __newfd,
       const char *__new) noexcept (true);
# 176 "/usr/include/stdio.h" 3 4
extern int renameat2 (int __oldfd, const char *__old, int __newfd,
        const char *__new, unsigned int __flags) noexcept (true);






extern int fclose (FILE *__stream) __attribute__ ((__nonnull__ (1)));
# 194 "/usr/include/stdio.h" 3 4
extern FILE *tmpfile (void)
  __attribute__ ((__malloc__)) ;
# 206 "/usr/include/stdio.h" 3 4
extern FILE *tmpfile64 (void)
   __attribute__ ((__malloc__)) ;



extern char *tmpnam (char[20]) noexcept (true) ;




extern char *tmpnam_r (char __s[20]) noexcept (true) ;
# 228 "/usr/include/stdio.h" 3 4
extern char *tempnam (const char *__dir, const char *__pfx)
   noexcept (true) __attribute__ ((__malloc__)) ;






extern int fflush (FILE *__stream);
# 245 "/usr/include/stdio.h" 3 4
extern int fflush_unlocked (FILE *__stream);
# 255 "/usr/include/stdio.h" 3 4
extern int fcloseall (void);
# 264 "/usr/include/stdio.h" 3 4
extern FILE *fopen (const char *__restrict __filename,
      const char *__restrict __modes)
  __attribute__ ((__malloc__)) ;




extern FILE *freopen (const char *__restrict __filename,
        const char *__restrict __modes,
        FILE *__restrict __stream) __attribute__ ((__nonnull__ (3)));
# 289 "/usr/include/stdio.h" 3 4
extern FILE *fopen64 (const char *__restrict __filename,
        const char *__restrict __modes)
  __attribute__ ((__malloc__)) ;
extern FILE *freopen64 (const char *__restrict __filename,
   const char *__restrict __modes,
   FILE *__restrict __stream) __attribute__ ((__nonnull__ (3)));




extern FILE *fdopen (int __fd, const char *__modes) noexcept (true)
  __attribute__ ((__malloc__)) ;





extern FILE *fopencookie (void *__restrict __magic_cookie,
     const char *__restrict __modes,
     cookie_io_functions_t __io_funcs) noexcept (true)
  __attribute__ ((__malloc__)) ;




extern FILE *fmemopen (void *__s, size_t __len, const char *__modes)
  noexcept (true) __attribute__ ((__malloc__)) ;




extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) noexcept (true)
  __attribute__ ((__malloc__)) ;





extern __FILE *open_wmemstream (wchar_t **__bufloc, size_t *__sizeloc) noexcept (true)
  __attribute__ ((__malloc__)) ;





extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) noexcept (true)
  __attribute__ ((__nonnull__ (1)));



extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
      int __modes, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1)));




extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,
         size_t __size) noexcept (true) __attribute__ ((__nonnull__ (1)));


extern void setlinebuf (FILE *__stream) noexcept (true) __attribute__ ((__nonnull__ (1)));







extern int fprintf (FILE *__restrict __stream,
      const char *__restrict __format, ...) __attribute__ ((__nonnull__ (1)));




extern int printf (const char *__restrict __format, ...);

extern int sprintf (char *__restrict __s,
      const char *__restrict __format, ...) noexcept (true);





extern int vfprintf (FILE *__restrict __s, const char *__restrict __format,
       __gnuc_va_list __arg) __attribute__ ((__nonnull__ (1)));




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) noexcept (true);



extern int snprintf (char *__restrict __s, size_t __maxlen,
       const char *__restrict __format, ...)
     noexcept (true) __attribute__ ((__format__ (__printf__, 3, 4)));

extern int vsnprintf (char *__restrict __s, size_t __maxlen,
        const char *__restrict __format, __gnuc_va_list __arg)
     noexcept (true) __attribute__ ((__format__ (__printf__, 3, 0)));





extern int vasprintf (char **__restrict __ptr, const char *__restrict __f,
        __gnuc_va_list __arg)
     noexcept (true) __attribute__ ((__format__ (__printf__, 2, 0))) ;
extern int __asprintf (char **__restrict __ptr,
         const char *__restrict __fmt, ...)
     noexcept (true) __attribute__ ((__format__ (__printf__, 2, 3))) ;
extern int asprintf (char **__restrict __ptr,
       const char *__restrict __fmt, ...)
     noexcept (true) __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, ...) __attribute__ ((__nonnull__ (1)));




extern int scanf (const char *__restrict __format, ...) ;

extern int sscanf (const char *__restrict __s,
     const char *__restrict __format, ...) noexcept (true);
# 442 "/usr/include/stdio.h" 3 4
extern int fscanf (FILE *__restrict __stream, const char *__restrict __format, ...) __asm__ ("" "__isoc23_fscanf") __attribute__ ((__nonnull__ (1)));


extern int scanf (const char *__restrict __format, ...) __asm__ ("" "__isoc23_scanf") ;

extern int sscanf (const char *__restrict __s, const char *__restrict __format, ...) noexcept (true) __asm__ ("" "__isoc23_sscanf");
# 490 "/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))) __attribute__ ((__nonnull__ (1)));





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)
     noexcept (true) __attribute__ ((__format__ (__scanf__, 2, 0)));






extern int vfscanf (FILE *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc23_vfscanf")



     __attribute__ ((__format__ (__scanf__, 2, 0))) __attribute__ ((__nonnull__ (1)));
extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc23_vscanf")

     __attribute__ ((__format__ (__scanf__, 1, 0))) ;
extern int vsscanf (const char *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) noexcept (true) __asm__ ("" "__isoc23_vsscanf")



     __attribute__ ((__format__ (__scanf__, 2, 0)));
# 575 "/usr/include/stdio.h" 3 4
extern int fgetc (FILE *__stream) __attribute__ ((__nonnull__ (1)));
extern int getc (FILE *__stream) __attribute__ ((__nonnull__ (1)));





extern int getchar (void);






extern int getc_unlocked (FILE *__stream) __attribute__ ((__nonnull__ (1)));
extern int getchar_unlocked (void);
# 600 "/usr/include/stdio.h" 3 4
extern int fgetc_unlocked (FILE *__stream) __attribute__ ((__nonnull__ (1)));
# 611 "/usr/include/stdio.h" 3 4
extern int fputc (int __c, FILE *__stream) __attribute__ ((__nonnull__ (2)));
extern int putc (int __c, FILE *__stream) __attribute__ ((__nonnull__ (2)));





extern int putchar (int __c);
# 627 "/usr/include/stdio.h" 3 4
extern int fputc_unlocked (int __c, FILE *__stream) __attribute__ ((__nonnull__ (2)));







extern int putc_unlocked (int __c, FILE *__stream) __attribute__ ((__nonnull__ (2)));
extern int putchar_unlocked (int __c);






extern int getw (FILE *__stream) __attribute__ ((__nonnull__ (1)));


extern int putw (int __w, FILE *__stream) __attribute__ ((__nonnull__ (2)));







extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
                                                          __attribute__ ((__nonnull__ (3)));
# 677 "/usr/include/stdio.h" 3 4
extern char *fgets_unlocked (char *__restrict __s, int __n,
        FILE *__restrict __stream)
                                                   __attribute__ ((__nonnull__ (3)));
# 694 "/usr/include/stdio.h" 3 4
extern __ssize_t __getdelim (char **__restrict __lineptr,
                             size_t *__restrict __n, int __delimiter,
                             FILE *__restrict __stream) __attribute__ ((__nonnull__ (4)));
extern __ssize_t getdelim (char **__restrict __lineptr,
                           size_t *__restrict __n, int __delimiter,
                           FILE *__restrict __stream) __attribute__ ((__nonnull__ (4)));







extern __ssize_t getline (char **__restrict __lineptr,
                          size_t *__restrict __n,
                          FILE *__restrict __stream) __attribute__ ((__nonnull__ (3)));







extern int fputs (const char *__restrict __s, FILE *__restrict __stream)
  __attribute__ ((__nonnull__ (2)));





extern int puts (const char *__s);






extern int ungetc (int __c, FILE *__stream) __attribute__ ((__nonnull__ (2)));






extern size_t fread (void *__restrict __ptr, size_t __size,
       size_t __n, FILE *__restrict __stream)
  __attribute__ ((__nonnull__ (4)));




extern size_t fwrite (const void *__restrict __ptr, size_t __size,
        size_t __n, FILE *__restrict __s) __attribute__ ((__nonnull__ (4)));
# 755 "/usr/include/stdio.h" 3 4
extern int fputs_unlocked (const char *__restrict __s,
      FILE *__restrict __stream) __attribute__ ((__nonnull__ (2)));
# 766 "/usr/include/stdio.h" 3 4
extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
         size_t __n, FILE *__restrict __stream)
  __attribute__ ((__nonnull__ (4)));
extern size_t fwrite_unlocked (const void *__restrict __ptr, size_t __size,
          size_t __n, FILE *__restrict __stream)
  __attribute__ ((__nonnull__ (4)));







extern int fseek (FILE *__stream, long int __off, int __whence)
  __attribute__ ((__nonnull__ (1)));




extern long int ftell (FILE *__stream) __attribute__ ((__nonnull__ (1)));




extern void rewind (FILE *__stream) __attribute__ ((__nonnull__ (1)));
# 803 "/usr/include/stdio.h" 3 4
extern int fseeko (FILE *__stream, __off_t __off, int __whence)
  __attribute__ ((__nonnull__ (1)));




extern __off_t ftello (FILE *__stream) __attribute__ ((__nonnull__ (1)));
# 829 "/usr/include/stdio.h" 3 4
extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos)
  __attribute__ ((__nonnull__ (1)));




extern int fsetpos (FILE *__stream, const fpos_t *__pos) __attribute__ ((__nonnull__ (1)));
# 851 "/usr/include/stdio.h" 3 4
extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence)
  __attribute__ ((__nonnull__ (1)));
extern __off64_t ftello64 (FILE *__stream) __attribute__ ((__nonnull__ (1)));
extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos)
  __attribute__ ((__nonnull__ (1)));
extern int fsetpos64 (FILE *__stream, const fpos64_t *__pos) __attribute__ ((__nonnull__ (1)));



extern void clearerr (FILE *__stream) noexcept (true) __attribute__ ((__nonnull__ (1)));

extern int feof (FILE *__stream) noexcept (true) __attribute__ ((__nonnull__ (1)));

extern int ferror (FILE *__stream) noexcept (true) __attribute__ ((__nonnull__ (1)));



extern void clearerr_unlocked (FILE *__stream) noexcept (true) __attribute__ ((__nonnull__ (1)));
extern int feof_unlocked (FILE *__stream) noexcept (true) __attribute__ ((__nonnull__ (1)));
extern int ferror_unlocked (FILE *__stream) noexcept (true) __attribute__ ((__nonnull__ (1)));







extern void perror (const char *__s) __attribute__ ((__cold__));




extern int fileno (FILE *__stream) noexcept (true) __attribute__ ((__nonnull__ (1)));




extern int fileno_unlocked (FILE *__stream) noexcept (true) __attribute__ ((__nonnull__ (1)));
# 897 "/usr/include/stdio.h" 3 4
extern int pclose (FILE *__stream) __attribute__ ((__nonnull__ (1)));





extern FILE *popen (const char *__command, const char *__modes)
  __attribute__ ((__malloc__)) ;






extern char *ctermid (char *__s) noexcept (true)
                                     ;





extern char *cuserid (char *__s)
                                     ;




struct obstack;


extern int obstack_printf (struct obstack *__restrict __obstack,
      const char *__restrict __format, ...)
     noexcept (true) __attribute__ ((__format__ (__printf__, 2, 3)));
extern int obstack_vprintf (struct obstack *__restrict __obstack,
       const char *__restrict __format,
       __gnuc_va_list __args)
     noexcept (true) __attribute__ ((__format__ (__printf__, 2, 0)));







extern void flockfile (FILE *__stream) noexcept (true) __attribute__ ((__nonnull__ (1)));



extern int ftrylockfile (FILE *__stream) noexcept (true) __attribute__ ((__nonnull__ (1)));


extern void funlockfile (FILE *__stream) noexcept (true) __attribute__ ((__nonnull__ (1)));
# 959 "/usr/include/stdio.h" 3 4
extern int __uflow (FILE *);
extern int __overflow (FILE *, int);
# 976 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/bits/stdio.h" 1 3 4
# 38 "/usr/include/bits/stdio.h" 3 4
extern __inline __attribute__ ((__gnu_inline__)) int
vprintf (const char *__restrict __fmt, __gnuc_va_list __arg)
{
  return vfprintf (stdout, __fmt, __arg);
}



extern __inline __attribute__ ((__gnu_inline__)) int
getchar (void)
{
  return getc (stdin);
}




extern __inline __attribute__ ((__gnu_inline__)) int
fgetc_unlocked (FILE *__fp)
{
  return (__builtin_expect (((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end), 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++);
}





extern __inline __attribute__ ((__gnu_inline__)) int
getc_unlocked (FILE *__fp)
{
  return (__builtin_expect (((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end), 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++);
}


extern __inline __attribute__ ((__gnu_inline__)) int
getchar_unlocked (void)
{
  return (__builtin_expect (((stdin)->_IO_read_ptr >= (stdin)->_IO_read_end), 0) ? __uflow (stdin) : *(unsigned char *) (stdin)->_IO_read_ptr++);
}




extern __inline __attribute__ ((__gnu_inline__)) int
putchar (int __c)
{
  return putc (__c, stdout);
}




extern __inline __attribute__ ((__gnu_inline__)) int
fputc_unlocked (int __c, FILE *__stream)
{
  return (__builtin_expect (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
}





extern __inline __attribute__ ((__gnu_inline__)) int
putc_unlocked (int __c, FILE *__stream)
{
  return (__builtin_expect (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
}


extern __inline __attribute__ ((__gnu_inline__)) int
putchar_unlocked (int __c)
{
  return (__builtin_expect (((stdout)->_IO_write_ptr >= (stdout)->_IO_write_end), 0) ? __overflow (stdout, (unsigned char) (__c)) : (unsigned char) (*(stdout)->_IO_write_ptr++ = (__c)));
}





extern __inline __attribute__ ((__gnu_inline__)) __ssize_t
getline (char **__lineptr, size_t *__n, FILE *__stream)
{
  return __getdelim (__lineptr, __n, '\n', __stream);
}





extern __inline __attribute__ ((__gnu_inline__)) int
 feof_unlocked (FILE *__stream) noexcept (true)
{
  return (((__stream)->_flags & 0x0010) != 0);
}


extern __inline __attribute__ ((__gnu_inline__)) int
 ferror_unlocked (FILE *__stream) noexcept (true)
{
  return (((__stream)->_flags & 0x0020) != 0);
}
# 977 "/usr/include/stdio.h" 2 3 4






}
# 43 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdio" 2 3
# 96 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdio" 3
namespace __gnu_cxx
{
# 175 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdio" 3
  using ::snprintf;
  using ::vfscanf;
  using ::vscanf;
  using ::vsnprintf;
  using ::vsscanf;

}

namespace std
{
  using ::__gnu_cxx::snprintf;
  using ::__gnu_cxx::vfscanf;
  using ::__gnu_cxx::vscanf;
  using ::__gnu_cxx::vsnprintf;
  using ::__gnu_cxx::vsscanf;
}
# 46 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ext/string_conversions.h" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cerrno" 1 3
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cerrno" 3


# 1 "/usr/include/errno.h" 1 3 4
# 28 "/usr/include/errno.h" 3 4
# 1 "/usr/include/bits/errno.h" 1 3 4
# 26 "/usr/include/bits/errno.h" 3 4
# 1 "/usr/include/linux/errno.h" 1 3 4
# 1 "/usr/include/asm/errno.h" 1 3 4
# 1 "/usr/include/asm-generic/errno.h" 1 3 4




# 1 "/usr/include/asm-generic/errno-base.h" 1 3 4
# 6 "/usr/include/asm-generic/errno.h" 2 3 4
# 2 "/usr/include/asm/errno.h" 2 3 4
# 2 "/usr/include/linux/errno.h" 2 3 4
# 27 "/usr/include/bits/errno.h" 2 3 4
# 29 "/usr/include/errno.h" 2 3 4





extern "C" {


extern int *__errno_location (void) noexcept (true) __attribute__ ((__const__));







extern char *program_invocation_name;
extern char *program_invocation_short_name;

# 1 "/usr/include/bits/types/error_t.h" 1 3 4
# 22 "/usr/include/bits/types/error_t.h" 3 4
typedef int error_t;
# 49 "/usr/include/errno.h" 2 3 4



}
# 43 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cerrno" 2 3
# 47 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ext/string_conversions.h" 2 3

namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{



  template<typename _TRet, typename _Ret = _TRet, typename _CharT,
    typename... _Base>
    _Ret
    __stoa(_TRet (*__convf) (const _CharT*, _CharT**, _Base...),
    const char* __name, const _CharT* __str, std::size_t* __idx,
    _Base... __base)
    {
      _Ret __ret;

      _CharT* __endptr;

      struct _Save_errno {
 _Save_errno() : _M_errno((*__errno_location ())) { (*__errno_location ()) = 0; }
 ~_Save_errno() { if ((*__errno_location ()) == 0) (*__errno_location ()) = _M_errno; }
 int _M_errno;
      } const __save_errno;

      struct _Range_chk {
   static bool
   _S_chk(_TRet, std::false_type) { return false; }

   static bool
   _S_chk(_TRet __val, std::true_type)
   {
     return __val < _TRet(__numeric_traits<int>::__min)
       || __val > _TRet(__numeric_traits<int>::__max);
   }
      };

      const _TRet __tmp = __convf(__str, &__endptr, __base...);

      if (__endptr == __str)
 std::__throw_invalid_argument(__name);
      else if ((*__errno_location ()) == 34
   || _Range_chk::_S_chk(__tmp, std::is_same<_Ret, int>{}))
 std::__throw_out_of_range(__name);
      else
 __ret = __tmp;

      if (__idx)
 *__idx = __endptr - __str;

      return __ret;
    }


  template<typename _String, typename _CharT = typename _String::value_type>
    _String
    __to_xstring(int (*__convf) (_CharT*, std::size_t, const _CharT*,
     __builtin_va_list), std::size_t __n,
   const _CharT* __fmt, ...)
    {


      _CharT* __s = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
         * __n));

      __builtin_va_list __args;
      __builtin_va_start(__args, __fmt);

      const int __len = __convf(__s, __n, __fmt, __args);

      __builtin_va_end(__args);

      return _String(__s, __s + __len);
    }


}
# 4155 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/charconv.h" 1 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/charconv.h" 3






namespace std __attribute__ ((__visibility__ ("default")))
{

namespace __detail
{


  template<typename _Tp>
    constexpr bool __integer_to_chars_is_unsigned
      = ! __gnu_cxx::__int_traits<_Tp>::__is_signed;



  template<typename _Tp>
    constexpr unsigned
    __to_chars_len(_Tp __value, int __base = 10) noexcept
    {

      static_assert(__integer_to_chars_is_unsigned<_Tp>, "implementation bug");


      unsigned __n = 1;
      const unsigned __b2 = __base * __base;
      const unsigned __b3 = __b2 * __base;
      const unsigned long __b4 = __b3 * __base;
      for (;;)
 {
   if (__value < (unsigned)__base) return __n;
   if (__value < __b2) return __n + 1;
   if (__value < __b3) return __n + 2;
   if (__value < __b4) return __n + 3;
   __value /= __b4;
   __n += 4;
 }
    }




  template<typename _Tp>
    constexpr void
    __to_chars_10_impl(char* __first, unsigned __len, _Tp __val) noexcept
    {

      static_assert(__integer_to_chars_is_unsigned<_Tp>, "implementation bug");


      constexpr char __digits[201] =
 "0001020304050607080910111213141516171819"
 "2021222324252627282930313233343536373839"
 "4041424344454647484950515253545556575859"
 "6061626364656667686970717273747576777879"
 "8081828384858687888990919293949596979899";
      unsigned __pos = __len - 1;
      while (__val >= 100)
 {
   auto const __num = (__val % 100) * 2;
   __val /= 100;
   __first[__pos] = __digits[__num + 1];
   __first[__pos - 1] = __digits[__num];
   __pos -= 2;
 }
      if (__val >= 10)
 {
   auto const __num = __val * 2;
   __first[1] = __digits[__num + 1];
   __first[0] = __digits[__num];
 }
      else
 __first[0] = '0' + __val;
    }

}

}
# 4156 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{

namespace __cxx11 {


  inline int
  stoi(const string& __str, size_t* __idx = 0, int __base = 10)
  { return __gnu_cxx::__stoa<long, int>(&std::strtol, "stoi", __str.c_str(),
     __idx, __base); }

  inline long
  stol(const string& __str, size_t* __idx = 0, int __base = 10)
  { return __gnu_cxx::__stoa(&std::strtol, "stol", __str.c_str(),
        __idx, __base); }

  inline unsigned long
  stoul(const string& __str, size_t* __idx = 0, int __base = 10)
  { return __gnu_cxx::__stoa(&std::strtoul, "stoul", __str.c_str(),
        __idx, __base); }


  inline long long
  stoll(const string& __str, size_t* __idx = 0, int __base = 10)
  { return __gnu_cxx::__stoa(&std::strtoll, "stoll", __str.c_str(),
        __idx, __base); }

  inline unsigned long long
  stoull(const string& __str, size_t* __idx = 0, int __base = 10)
  { return __gnu_cxx::__stoa(&std::strtoull, "stoull", __str.c_str(),
        __idx, __base); }
# 4198 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
  inline double
  stod(const string& __str, size_t* __idx = 0)
  { return __gnu_cxx::__stoa(&std::strtod, "stod", __str.c_str(), __idx); }



  inline float
  stof(const string& __str, size_t* __idx = 0)
  { return __gnu_cxx::__stoa(&std::strtof, "stof", __str.c_str(), __idx); }
# 4226 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
  inline long double
  stold(const string& __str, size_t* __idx = 0)
  { return __gnu_cxx::__stoa(&std::strtold, "stold", __str.c_str(), __idx); }
# 4238 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
  [[__nodiscard__]]
  inline string
  to_string(int __val)

  noexcept

  {
    const bool __neg = __val < 0;
    const unsigned __uval = __neg ? (unsigned)~__val + 1u : __val;
    const auto __len = __detail::__to_chars_len(__uval);
    string __str;
    __str.__resize_and_overwrite(__neg + __len, [=](char* __p, size_t __n) {
      __p[0] = '-';
      __detail::__to_chars_10_impl(__p + (int)__neg, __len, __uval);
      return __n;
    });
    return __str;
  }

  [[__nodiscard__]]
  inline string
  to_string(unsigned __val)

  noexcept

  {
    const auto __len = __detail::__to_chars_len(__val);
    string __str;
    __str.__resize_and_overwrite(__len, [__val](char* __p, size_t __n) {
      __detail::__to_chars_10_impl(__p, __n, __val);
      return __n;
    });
    return __str;
  }

  [[__nodiscard__]]
  inline string
  to_string(long __val)



  {
    const bool __neg = __val < 0;
    const unsigned long __uval = __neg ? (unsigned long)~__val + 1ul : __val;
    const auto __len = __detail::__to_chars_len(__uval);
    string __str;
    __str.__resize_and_overwrite(__neg + __len, [=](char* __p, size_t __n) {
      __p[0] = '-';
      __detail::__to_chars_10_impl(__p + (int)__neg, __len, __uval);
      return __n;
    });
    return __str;
  }

  [[__nodiscard__]]
  inline string
  to_string(unsigned long __val)



  {
    const auto __len = __detail::__to_chars_len(__val);
    string __str;
    __str.__resize_and_overwrite(__len, [__val](char* __p, size_t __n) {
      __detail::__to_chars_10_impl(__p, __n, __val);
      return __n;
    });
    return __str;
  }

  [[__nodiscard__]]
  inline string
  to_string(long long __val)
  {
    const bool __neg = __val < 0;
    const unsigned long long __uval
      = __neg ? (unsigned long long)~__val + 1ull : __val;
    const auto __len = __detail::__to_chars_len(__uval);
    string __str;
    __str.__resize_and_overwrite(__neg + __len, [=](char* __p, size_t __n) {
      __p[0] = '-';
      __detail::__to_chars_10_impl(__p + (int)__neg, __len, __uval);
      return __n;
    });
    return __str;
  }

  [[__nodiscard__]]
  inline string
  to_string(unsigned long long __val)
  {
    const auto __len = __detail::__to_chars_len(__val);
    string __str;
    __str.__resize_and_overwrite(__len, [__val](char* __p, size_t __n) {
      __detail::__to_chars_10_impl(__p, __n, __val);
      return __n;
    });
    return __str;
  }
# 4399 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
  [[__nodiscard__]]
  inline string
  to_string(float __val)
  {
    const int __n =
      __gnu_cxx::__numeric_traits<float>::__max_exponent10 + 20;
    return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
        "%f", __val);
  }

  [[__nodiscard__]]
  inline string
  to_string(double __val)
  {
    const int __n =
      __gnu_cxx::__numeric_traits<double>::__max_exponent10 + 20;
    return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
        "%f", __val);
  }

  [[__nodiscard__]]
  inline string
  to_string(long double __val)
  {
    const int __n =
      __gnu_cxx::__numeric_traits<long double>::__max_exponent10 + 20;
    return __gnu_cxx::__to_xstring<string>(&std::vsnprintf, __n,
        "%Lf", __val);
  }



  inline int
  stoi(const wstring& __str, size_t* __idx = 0, int __base = 10)
  { return __gnu_cxx::__stoa<long, int>(&std::wcstol, "stoi", __str.c_str(),
     __idx, __base); }

  inline long
  stol(const wstring& __str, size_t* __idx = 0, int __base = 10)
  { return __gnu_cxx::__stoa(&std::wcstol, "stol", __str.c_str(),
        __idx, __base); }

  inline unsigned long
  stoul(const wstring& __str, size_t* __idx = 0, int __base = 10)
  { return __gnu_cxx::__stoa(&std::wcstoul, "stoul", __str.c_str(),
        __idx, __base); }

  inline long long
  stoll(const wstring& __str, size_t* __idx = 0, int __base = 10)
  { return __gnu_cxx::__stoa(&std::wcstoll, "stoll", __str.c_str(),
        __idx, __base); }

  inline unsigned long long
  stoull(const wstring& __str, size_t* __idx = 0, int __base = 10)
  { return __gnu_cxx::__stoa(&std::wcstoull, "stoull", __str.c_str(),
        __idx, __base); }


  inline float
  stof(const wstring& __str, size_t* __idx = 0)
  { return __gnu_cxx::__stoa(&std::wcstof, "stof", __str.c_str(), __idx); }

  inline double
  stod(const wstring& __str, size_t* __idx = 0)
  { return __gnu_cxx::__stoa(&std::wcstod, "stod", __str.c_str(), __idx); }

  inline long double
  stold(const wstring& __str, size_t* __idx = 0)
  { return __gnu_cxx::__stoa(&std::wcstold, "stold", __str.c_str(), __idx); }



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++17-extensions"
  constexpr
  inline void
  __to_wstring_numeric(const char* __s, int __len, wchar_t* __wout)
  {


    if constexpr (wchar_t('0') == L'0' && wchar_t('-') == L'-'
      && wchar_t('.') == L'.' && wchar_t('e') == L'e')
      {
 for (int __i = 0; __i < __len; ++__i)
   __wout[__i] = (wchar_t) __s[__i];
      }
    else
      {
 wchar_t __wc[256];
 for (int __i = '0'; __i <= '9'; ++__i)
   __wc[__i] = L'0' + __i;
 __wc['.'] = L'.';
 __wc['+'] = L'+';
 __wc['-'] = L'-';
 __wc['a'] = L'a';
 __wc['b'] = L'b';
 __wc['c'] = L'c';
 __wc['d'] = L'd';
 __wc['e'] = L'e';
 __wc['f'] = L'f';
 __wc['n'] = L'n';
 __wc['p'] = L'p';
 __wc['x'] = L'x';
 __wc['A'] = L'A';
 __wc['B'] = L'B';
 __wc['C'] = L'C';
 __wc['D'] = L'D';
 __wc['E'] = L'E';
 __wc['F'] = L'F';
 __wc['N'] = L'N';
 __wc['P'] = L'P';
 __wc['X'] = L'X';

 for (int __i = 0; __i < __len; ++__i)
   __wout[__i] = __wc[(int)__s[__i]];
      }
  }


  constexpr

  inline wstring

  __to_wstring_numeric(string_view __s)



  {
    if constexpr (wchar_t('0') == L'0' && wchar_t('-') == L'-'
      && wchar_t('.') == L'.' && wchar_t('e') == L'e')
      return wstring(__s.data(), __s.data() + __s.size());
    else
      {
 wstring __ws;
 auto __f = __s.data();
 __ws.__resize_and_overwrite(__s.size(),
        [__f] (wchar_t* __to, int __n) {
          std::__to_wstring_numeric(__f, __n, __to);
          return __n;
        });
 return __ws;
      }
  }
#pragma GCC diagnostic pop

  [[__nodiscard__]]
  inline wstring
  to_wstring(int __val)
  { return std::__to_wstring_numeric(std::to_string(__val)); }

  [[__nodiscard__]]
  inline wstring
  to_wstring(unsigned __val)
  { return std::__to_wstring_numeric(std::to_string(__val)); }

  [[__nodiscard__]]
  inline wstring
  to_wstring(long __val)
  { return std::__to_wstring_numeric(std::to_string(__val)); }

  [[__nodiscard__]]
  inline wstring
  to_wstring(unsigned long __val)
  { return std::__to_wstring_numeric(std::to_string(__val)); }

  [[__nodiscard__]]
  inline wstring
  to_wstring(long long __val)
  { return std::__to_wstring_numeric(std::to_string(__val)); }

  [[__nodiscard__]]
  inline wstring
  to_wstring(unsigned long long __val)
  { return std::__to_wstring_numeric(std::to_string(__val)); }


  [[__nodiscard__]]
  inline wstring
  to_wstring(float __val)
  { return std::__to_wstring_numeric(std::to_string(__val)); }

  [[__nodiscard__]]
  inline wstring
  to_wstring(double __val)
  { return std::__to_wstring_numeric(std::to_string(__val)); }

  [[__nodiscard__]]
  inline wstring
  to_wstring(long double __val)
  { return std::__to_wstring_numeric(std::to_string(__val)); }



}

}







namespace std __attribute__ ((__visibility__ ("default")))
{





  template<typename _CharT, typename _Alloc,
    typename _StrT = basic_string<_CharT, char_traits<_CharT>, _Alloc>>
    struct __str_hash_base
    : public __hash_base<size_t, _StrT>
    {
      [[__nodiscard__]]
      size_t
      operator()(const _StrT& __s) const noexcept
      { return _Hash_impl::hash(__s.data(), __s.length() * sizeof(_CharT)); }
    };



  template<typename _Alloc>
    struct hash<basic_string<char, char_traits<char>, _Alloc>>
    : public __str_hash_base<char, _Alloc>
    { };


  template<typename _Alloc>
    struct hash<basic_string<wchar_t, char_traits<wchar_t>, _Alloc>>
    : public __str_hash_base<wchar_t, _Alloc>
    { };

  template<typename _Alloc>
    struct __is_fast_hash<hash<basic_string<wchar_t, char_traits<wchar_t>,
         _Alloc>>>
    : std::false_type
    { };




  template<typename _Alloc>
    struct hash<basic_string<char8_t, char_traits<char8_t>, _Alloc>>
    : public __str_hash_base<char8_t, _Alloc>
    { };



  template<typename _Alloc>
    struct hash<basic_string<char16_t, char_traits<char16_t>, _Alloc>>
    : public __str_hash_base<char16_t, _Alloc>
    { };


  template<typename _Alloc>
    struct hash<basic_string<char32_t, char_traits<char32_t>, _Alloc>>
    : public __str_hash_base<char32_t, _Alloc>
    { };



  template<> struct __is_fast_hash<hash<string>> : std::false_type { };
  template<> struct __is_fast_hash<hash<wstring>> : std::false_type { };
  template<> struct __is_fast_hash<hash<u16string>> : std::false_type { };
  template<> struct __is_fast_hash<hash<u32string>> : std::false_type { };

  template<> struct __is_fast_hash<hash<u8string>> : std::false_type { };
# 4678 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.h" 3
  inline namespace literals
  {
  inline namespace string_literals
  {
#pragma GCC diagnostic push








    __attribute ((__abi_tag__ ("cxx11"))) constexpr
    inline basic_string<char>
    operator""s(const char* __str, size_t __len)
    { return basic_string<char>{__str, __len}; }

    __attribute ((__abi_tag__ ("cxx11"))) constexpr
    inline basic_string<wchar_t>
    operator""s(const wchar_t* __str, size_t __len)
    { return basic_string<wchar_t>{__str, __len}; }


    __attribute ((__abi_tag__ ("cxx11"))) constexpr
    inline basic_string<char8_t>
    operator""s(const char8_t* __str, size_t __len)
    { return basic_string<char8_t>{__str, __len}; }


    __attribute ((__abi_tag__ ("cxx11"))) constexpr
    inline basic_string<char16_t>
    operator""s(const char16_t* __str, size_t __len)
    { return basic_string<char16_t>{__str, __len}; }

    __attribute ((__abi_tag__ ("cxx11"))) constexpr
    inline basic_string<char32_t>
    operator""s(const char32_t* __str, size_t __len)
    { return basic_string<char32_t>{__str, __len}; }


#pragma GCC diagnostic pop
  }
  }



  namespace __detail::__variant
  {
    template<typename> struct _Never_valueless_alt;



    template<typename _Tp, typename _Traits, typename _Alloc>
      struct _Never_valueless_alt<std::basic_string<_Tp, _Traits, _Alloc>>
      : __and_<
 is_nothrow_move_constructible<std::basic_string<_Tp, _Traits, _Alloc>>,
 is_nothrow_move_assignable<std::basic_string<_Tp, _Traits, _Alloc>>
 >::type
      { };
  }



}
# 55 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/string" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.tcc" 1 3
# 43 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.tcc" 3



namespace std __attribute__ ((__visibility__ ("default")))
{




  template<typename _CharT, typename _Traits, typename _Alloc>
    const typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::npos;

  template<typename _CharT, typename _Traits, typename _Alloc>
    constexpr
    void
    basic_string<_CharT, _Traits, _Alloc>::
    swap(basic_string& __s) noexcept
    {
      if (this == std::__addressof(__s))
 return;

      _Alloc_traits::_S_on_swap(_M_get_allocator(), __s._M_get_allocator());

      if (_M_is_local())
 if (__s._M_is_local())
   {
     if (length() && __s.length())
       {
  _CharT __tmp_data[_S_local_capacity + 1];
  traits_type::copy(__tmp_data, __s._M_local_buf,
      __s.length() + 1);
  traits_type::copy(__s._M_local_buf, _M_local_buf,
      length() + 1);
  traits_type::copy(_M_local_buf, __tmp_data,
      __s.length() + 1);
       }
     else if (__s.length())
       {
  _M_init_local_buf();
  traits_type::copy(_M_local_buf, __s._M_local_buf,
      __s.length() + 1);
  _M_length(__s.length());
  __s._M_set_length(0);
  return;
       }
     else if (length())
       {
  __s._M_init_local_buf();
  traits_type::copy(__s._M_local_buf, _M_local_buf,
      length() + 1);
  __s._M_length(length());
  _M_set_length(0);
  return;
       }
   }
 else
   {
     const size_type __tmp_capacity = __s._M_allocated_capacity;
     __s._M_init_local_buf();
     traits_type::copy(__s._M_local_buf, _M_local_buf,
         length() + 1);
     _M_data(__s._M_data());
     __s._M_data(__s._M_local_buf);
     _M_capacity(__tmp_capacity);
   }
      else
 {
   const size_type __tmp_capacity = _M_allocated_capacity;
   if (__s._M_is_local())
     {
       _M_init_local_buf();
       traits_type::copy(_M_local_buf, __s._M_local_buf,
    __s.length() + 1);
       __s._M_data(_M_data());
       _M_data(_M_local_buf);
     }
   else
     {
       pointer __tmp_ptr = _M_data();
       _M_data(__s._M_data());
       __s._M_data(__tmp_ptr);
       _M_capacity(__s._M_allocated_capacity);
     }
   __s._M_capacity(__tmp_capacity);
 }

      const size_type __tmp_length = length();
      _M_length(__s.length());
      __s._M_length(__tmp_length);
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    constexpr
    typename basic_string<_CharT, _Traits, _Alloc>::pointer
    basic_string<_CharT, _Traits, _Alloc>::
    _M_create(size_type& __capacity, size_type __old_capacity)
    {


      if (__capacity > max_size())
 std::__throw_length_error(("basic_string::_M_create"));




      if (__capacity > __old_capacity && __capacity < 2 * __old_capacity)
 {
   __capacity = 2 * __old_capacity;

   if (__capacity > max_size())
     __capacity = max_size();
 }



      return _S_allocate(_M_get_allocator(), __capacity + 1);
    }





  template<typename _CharT, typename _Traits, typename _Alloc>
    template<typename _InIterator>
      constexpr
      void
      basic_string<_CharT, _Traits, _Alloc>::
      _M_construct(_InIterator __beg, _InIterator __end,
     std::input_iterator_tag)
      {
 size_type __len = 0;
 size_type __capacity = size_type(_S_local_capacity);

 _M_init_local_buf();

 while (__beg != __end && __len < __capacity)
   {
     _M_local_buf[__len++] = *__beg;
     ++__beg;
   }

 struct _Guard
 {
   constexpr
   explicit _Guard(basic_string* __s) : _M_guarded(__s) { }

   constexpr
   ~_Guard() { if (_M_guarded) _M_guarded->_M_dispose(); }

   basic_string* _M_guarded;
 } __guard(this);

 while (__beg != __end)
   {
     if (__len == __capacity)
       {

  __capacity = __len + 1;
  pointer __another = _M_create(__capacity, __len);
  this->_S_copy(__another, _M_data(), __len);
  _M_dispose();
  _M_data(__another);
  _M_capacity(__capacity);
       }
     traits_type::assign(_M_data()[__len++], *__beg);
     ++__beg;
   }

 __guard._M_guarded = 0;

 _M_set_length(__len);
      }

  template<typename _CharT, typename _Traits, typename _Alloc>
    template<typename _InIterator>
      constexpr
      void
      basic_string<_CharT, _Traits, _Alloc>::
      _M_construct(_InIterator __beg, _InIterator __end,
     std::forward_iterator_tag)
      {
 size_type __dnew = static_cast<size_type>(std::distance(__beg, __end));

 if (__dnew > size_type(_S_local_capacity))
   {
     _M_data(_M_create(__dnew, size_type(0)));
     _M_capacity(__dnew);
   }
 else
   _M_init_local_buf();


 struct _Guard
 {
   constexpr
   explicit _Guard(basic_string* __s) : _M_guarded(__s) { }

   constexpr
   ~_Guard() { if (_M_guarded) _M_guarded->_M_dispose(); }

   basic_string* _M_guarded;
 } __guard(this);

 this->_S_copy_chars(_M_data(), __beg, __end);

 __guard._M_guarded = 0;

 _M_set_length(__dnew);
      }

  template<typename _CharT, typename _Traits, typename _Alloc>
    constexpr
    void
    basic_string<_CharT, _Traits, _Alloc>::
    _M_construct(size_type __n, _CharT __c)
    {
      if (__n > size_type(_S_local_capacity))
 {
   _M_data(_M_create(__n, size_type(0)));
   _M_capacity(__n);
 }
      else
 _M_init_local_buf();

      if (__n)
 this->_S_assign(_M_data(), __n, __c);

      _M_set_length(__n);
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    constexpr
    void
    basic_string<_CharT, _Traits, _Alloc>::
    _M_assign(const basic_string& __str)
    {
      if (this != std::__addressof(__str))
 {
   const size_type __rsize = __str.length();
   const size_type __capacity = capacity();

   if (__rsize > __capacity)
     {
       size_type __new_capacity = __rsize;
       pointer __tmp = _M_create(__new_capacity, __capacity);
       _M_dispose();
       _M_data(__tmp);
       _M_capacity(__new_capacity);
     }

   if (__rsize)
     this->_S_copy(_M_data(), __str._M_data(), __rsize);

   _M_set_length(__rsize);
 }
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    constexpr
    void
    basic_string<_CharT, _Traits, _Alloc>::
    reserve(size_type __res)
    {
      const size_type __capacity = capacity();




      if (__res <= __capacity)
 return;

      pointer __tmp = _M_create(__res, __capacity);
      this->_S_copy(__tmp, _M_data(), length() + 1);
      _M_dispose();
      _M_data(__tmp);
      _M_capacity(__res);
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    constexpr
    void
    basic_string<_CharT, _Traits, _Alloc>::
    _M_mutate(size_type __pos, size_type __len1, const _CharT* __s,
       size_type __len2)
    {
      const size_type __how_much = length() - __pos - __len1;

      size_type __new_capacity = length() + __len2 - __len1;
      pointer __r = _M_create(__new_capacity, capacity());

      if (__pos)
 this->_S_copy(__r, _M_data(), __pos);
      if (__s && __len2)
 this->_S_copy(__r + __pos, __s, __len2);
      if (__how_much)
 this->_S_copy(__r + __pos + __len2,
        _M_data() + __pos + __len1, __how_much);

      _M_dispose();
      _M_data(__r);
      _M_capacity(__new_capacity);
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    constexpr
    void
    basic_string<_CharT, _Traits, _Alloc>::
    _M_erase(size_type __pos, size_type __n)
    {
      const size_type __how_much = length() - __pos - __n;

      if (__how_much && __n)
 this->_S_move(_M_data() + __pos, _M_data() + __pos + __n, __how_much);

      _M_set_length(length() - __n);
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    constexpr
    void
    basic_string<_CharT, _Traits, _Alloc>::
    reserve()
    {
      if (_M_is_local())
 return;

      const size_type __length = length();
      const size_type __capacity = _M_allocated_capacity;

      if (__length <= size_type(_S_local_capacity))
 {
   _M_init_local_buf();
   this->_S_copy(_M_local_buf, _M_data(), __length + 1);
   _M_destroy(__capacity);
   _M_data(_M_local_data());
 }

      else if (__length < __capacity)
 try
   {
     pointer __tmp = _S_allocate(_M_get_allocator(), __length + 1);
     this->_S_copy(__tmp, _M_data(), __length + 1);
     _M_dispose();
     _M_data(__tmp);
     _M_capacity(__length);
   }
 catch (const __cxxabiv1::__forced_unwind&)
   { throw; }
 catch (...)
   { }

    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    constexpr
    void
    basic_string<_CharT, _Traits, _Alloc>::
    resize(size_type __n, _CharT __c)
    {
      const size_type __size = this->size();
      if (__size < __n)
 this->append(__n - __size, __c);
      else if (__n < __size)
 this->_M_set_length(__n);
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    constexpr
    basic_string<_CharT, _Traits, _Alloc>&
    basic_string<_CharT, _Traits, _Alloc>::
    _M_append(const _CharT* __s, size_type __n)
    {
      const size_type __len = __n + this->size();

      if (__len <= this->capacity())
 {
   if (__n)
     this->_S_copy(this->_M_data() + this->size(), __s, __n);
 }
      else
 this->_M_mutate(this->size(), size_type(0), __s, __n);

      this->_M_set_length(__len);
      return *this;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    template<typename _InputIterator>
      constexpr
      basic_string<_CharT, _Traits, _Alloc>&
      basic_string<_CharT, _Traits, _Alloc>::
      _M_replace_dispatch(const_iterator __i1, const_iterator __i2,
     _InputIterator __k1, _InputIterator __k2,
     std::__false_type)
      {


 const basic_string __s(__k1, __k2, this->get_allocator());
 const size_type __n1 = __i2 - __i1;
 return _M_replace(__i1 - begin(), __n1, __s._M_data(),
     __s.size());
      }

  template<typename _CharT, typename _Traits, typename _Alloc>
    constexpr
    basic_string<_CharT, _Traits, _Alloc>&
    basic_string<_CharT, _Traits, _Alloc>::
    _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2,
     _CharT __c)
    {
      _M_check_length(__n1, __n2, "basic_string::_M_replace_aux");

      const size_type __old_size = this->size();
      const size_type __new_size = __old_size + __n2 - __n1;

      if (__new_size <= this->capacity())
 {
   pointer __p = this->_M_data() + __pos1;

   const size_type __how_much = __old_size - __pos1 - __n1;
   if (__how_much && __n1 != __n2)
     this->_S_move(__p + __n2, __p + __n1, __how_much);
 }
      else
 this->_M_mutate(__pos1, __n1, 0, __n2);

      if (__n2)
 this->_S_assign(this->_M_data() + __pos1, __n2, __c);

      this->_M_set_length(__new_size);
      return *this;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    __attribute__((__noinline__, __noclone__, __cold__)) void
    basic_string<_CharT, _Traits, _Alloc>::
    _M_replace_cold(pointer __p, size_type __len1, const _CharT* __s,
      const size_type __len2, const size_type __how_much)
    {

      if (__len2 && __len2 <= __len1)
 this->_S_move(__p, __s, __len2);
      if (__how_much && __len1 != __len2)
 this->_S_move(__p + __len2, __p + __len1, __how_much);
      if (__len2 > __len1)
 {
   if (__s + __len2 <= __p + __len1)
     this->_S_move(__p, __s, __len2);
   else if (__s >= __p + __len1)
     {


       const size_type __poff = (__s - __p) + (__len2 - __len1);
       this->_S_copy(__p, __p + __poff, __len2);
     }
   else
     {
       const size_type __nleft = (__p + __len1) - __s;
       this->_S_move(__p, __s, __nleft);
       this->_S_copy(__p + __nleft, __p + __len2, __len2 - __nleft);
     }
 }
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    constexpr
    basic_string<_CharT, _Traits, _Alloc>&
    basic_string<_CharT, _Traits, _Alloc>::
    _M_replace(size_type __pos, size_type __len1, const _CharT* __s,
        const size_type __len2)
    {
      _M_check_length(__len1, __len2, "basic_string::_M_replace");

      const size_type __old_size = this->size();
      const size_type __new_size = __old_size + __len2 - __len1;

      if (__new_size <= this->capacity())
 {
   pointer __p = this->_M_data() + __pos;

   const size_type __how_much = __old_size - __pos - __len1;

   if (std::is_constant_evaluated())
     {
       auto __newp = _S_allocate(_M_get_allocator(), __new_size);
       _S_copy(__newp, this->_M_data(), __pos);
       _S_copy(__newp + __pos, __s, __len2);
       _S_copy(__newp + __pos + __len2, __p + __len1, __how_much);
       _S_copy(this->_M_data(), __newp, __new_size);
       this->_M_get_allocator().deallocate(__newp, __new_size);
     }
   else

   if (__builtin_expect(_M_disjunct(__s), true))
     {
       if (__how_much && __len1 != __len2)
  this->_S_move(__p + __len2, __p + __len1, __how_much);
       if (__len2)
  this->_S_copy(__p, __s, __len2);
     }
   else
     _M_replace_cold(__p, __len1, __s, __len2, __how_much);
 }
      else
 this->_M_mutate(__pos, __len1, __s, __len2);

      this->_M_set_length(__new_size);
      return *this;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    constexpr
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    copy(_CharT* __s, size_type __n, size_type __pos) const
    {
      _M_check(__pos, "basic_string::copy");
      __n = _M_limit(__pos, __n);
                                             ;
      if (__n)
 _S_copy(__s, _M_data() + __pos, __n);

      return __n;
    }


  template<typename _CharT, typename _Traits, typename _Alloc>
  template<typename _Operation>
    [[__gnu__::__always_inline__]]
    constexpr void
    basic_string<_CharT, _Traits, _Alloc>::
    __resize_and_overwrite(const size_type __n, _Operation __op)
    { resize_and_overwrite<_Operation&>(__n, __op); }



  template<typename _CharT, typename _Traits, typename _Alloc>
  template<typename _Operation>
    constexpr void
    basic_string<_CharT, _Traits, _Alloc>::

    resize_and_overwrite(const size_type __n, _Operation __op)



    {
      reserve(__n);
      _CharT* const __p = _M_data();

      if (std::__is_constant_evaluated() && __n > size())
 traits_type::assign(__p + size(), __n - size(), _CharT());

      struct _Terminator {
 constexpr ~_Terminator() { _M_this->_M_set_length(_M_r); }
 basic_string* _M_this;
 size_type _M_r;
      };
      _Terminator __term{this, 0};
      auto __r = std::move(__op)(__p + 0, __n + 0);

      static_assert(ranges::__detail::__is_integer_like<decltype(__r)>);




                                                   ;
      __term._M_r = size_type(__r);
      if (__term._M_r > __n)
 __builtin_unreachable();
    }
# 623 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.tcc" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    constexpr
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find(const _CharT* __s, size_type __pos, size_type __n) const
    noexcept
    {
                                             ;
      const size_type __size = this->size();

      if (__n == 0)
 return __pos <= __size ? __pos : npos;
      if (__pos >= __size)
 return npos;

      const _CharT __elem0 = __s[0];
      const _CharT* const __data = data();
      const _CharT* __first = __data + __pos;
      const _CharT* const __last = __data + __size;
      size_type __len = __size - __pos;

      while (__len >= __n)
 {

   __first = traits_type::find(__first, __len - __n + 1, __elem0);
   if (!__first)
     return npos;



   if (traits_type::compare(__first, __s, __n) == 0)
     return __first - __data;
   __len = __last - ++__first;
 }
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    constexpr
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find(_CharT __c, size_type __pos) const noexcept
    {
      size_type __ret = npos;
      const size_type __size = this->size();
      if (__pos < __size)
 {
   const _CharT* __data = _M_data();
   const size_type __n = __size - __pos;
   const _CharT* __p = traits_type::find(__data + __pos, __n, __c);
   if (__p)
     __ret = __p - __data;
 }
      return __ret;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    constexpr
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    rfind(const _CharT* __s, size_type __pos, size_type __n) const
    noexcept
    {
                                             ;
      const size_type __size = this->size();
      if (__n <= __size)
 {
   __pos = std::min(size_type(__size - __n), __pos);
   const _CharT* __data = _M_data();
   do
     {
       if (traits_type::compare(__data + __pos, __s, __n) == 0)
  return __pos;
     }
   while (__pos-- > 0);
 }
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    constexpr
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    rfind(_CharT __c, size_type __pos) const noexcept
    {
      size_type __size = this->size();
      if (__size)
 {
   if (--__size > __pos)
     __size = __pos;
   for (++__size; __size-- > 0; )
     if (traits_type::eq(_M_data()[__size], __c))
       return __size;
 }
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    constexpr
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find_first_of(const _CharT* __s, size_type __pos, size_type __n) const
    noexcept
    {
                                             ;
      for (; __n && __pos < this->size(); ++__pos)
 {
   const _CharT* __p = traits_type::find(__s, __n, _M_data()[__pos]);
   if (__p)
     return __pos;
 }
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    constexpr
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find_last_of(const _CharT* __s, size_type __pos, size_type __n) const
    noexcept
    {
                                             ;
      size_type __size = this->size();
      if (__size && __n)
 {
   if (--__size > __pos)
     __size = __pos;
   do
     {
       if (traits_type::find(__s, __n, _M_data()[__size]))
  return __size;
     }
   while (__size-- != 0);
 }
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    constexpr
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const
    noexcept
    {
                                             ;
      for (; __pos < this->size(); ++__pos)
 if (!traits_type::find(__s, __n, _M_data()[__pos]))
   return __pos;
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    constexpr
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find_first_not_of(_CharT __c, size_type __pos) const noexcept
    {
      for (; __pos < this->size(); ++__pos)
 if (!traits_type::eq(_M_data()[__pos], __c))
   return __pos;
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    constexpr
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const
    noexcept
    {
                                             ;
      size_type __size = this->size();
      if (__size)
 {
   if (--__size > __pos)
     __size = __pos;
   do
     {
       if (!traits_type::find(__s, __n, _M_data()[__size]))
  return __size;
     }
   while (__size--);
 }
      return npos;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    constexpr
    typename basic_string<_CharT, _Traits, _Alloc>::size_type
    basic_string<_CharT, _Traits, _Alloc>::
    find_last_not_of(_CharT __c, size_type __pos) const noexcept
    {
      size_type __size = this->size();
      if (__size)
 {
   if (--__size > __pos)
     __size = __pos;
   do
     {
       if (!traits_type::eq(_M_data()[__size], __c))
  return __size;
     }
   while (__size--);
 }
      return npos;
    }




  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __in,
        basic_string<_CharT, _Traits, _Alloc>& __str)
    {
      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
      typedef typename __istream_type::ios_base __ios_base;
      typedef typename __istream_type::int_type __int_type;
      typedef typename __string_type::size_type __size_type;
      typedef ctype<_CharT> __ctype_type;
      typedef typename __ctype_type::ctype_base __ctype_base;

      __size_type __extracted = 0;
      typename __ios_base::iostate __err = __ios_base::goodbit;
      typename __istream_type::sentry __cerb(__in, false);
      if (__cerb)
 {
   try
     {

       __str.erase();
       _CharT __buf[128];
       __size_type __len = 0;
       const streamsize __w = __in.width();
       const __size_type __n = __w > 0 ? static_cast<__size_type>(__w)
                                : __str.max_size();
       const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
       const __int_type __eof = _Traits::eof();
       __int_type __c = __in.rdbuf()->sgetc();

       while (__extracted < __n
       && !_Traits::eq_int_type(__c, __eof)
       && !__ct.is(__ctype_base::space,
     _Traits::to_char_type(__c)))
  {
    if (__len == sizeof(__buf) / sizeof(_CharT))
      {
        __str.append(__buf, sizeof(__buf) / sizeof(_CharT));
        __len = 0;
      }
    __buf[__len++] = _Traits::to_char_type(__c);
    ++__extracted;
    __c = __in.rdbuf()->snextc();
  }
       __str.append(__buf, __len);

       if (__extracted < __n && _Traits::eq_int_type(__c, __eof))
  __err |= __ios_base::eofbit;
       __in.width(0);
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       __in._M_setstate(__ios_base::badbit);
       throw;
     }
   catch(...)
     {



       __in._M_setstate(__ios_base::badbit);
     }
 }

      if (!__extracted)
 __err |= __ios_base::failbit;
      if (__err)
 __in.setstate(__err);
      return __in;
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_istream<_CharT, _Traits>&
    getline(basic_istream<_CharT, _Traits>& __in,
     basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
    {
      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
      typedef typename __istream_type::ios_base __ios_base;
      typedef typename __istream_type::int_type __int_type;
      typedef typename __string_type::size_type __size_type;

      __size_type __extracted = 0;
      const __size_type __n = __str.max_size();
      typename __ios_base::iostate __err = __ios_base::goodbit;
      typename __istream_type::sentry __cerb(__in, true);
      if (__cerb)
 {
   try
     {
       __str.erase();
       const __int_type __idelim = _Traits::to_int_type(__delim);
       const __int_type __eof = _Traits::eof();
       __int_type __c = __in.rdbuf()->sgetc();

       while (__extracted < __n
       && !_Traits::eq_int_type(__c, __eof)
       && !_Traits::eq_int_type(__c, __idelim))
  {
    __str += _Traits::to_char_type(__c);
    ++__extracted;
    __c = __in.rdbuf()->snextc();
  }

       if (_Traits::eq_int_type(__c, __eof))
  __err |= __ios_base::eofbit;
       else if (_Traits::eq_int_type(__c, __idelim))
  {
    ++__extracted;
    __in.rdbuf()->sbumpc();
  }
       else
  __err |= __ios_base::failbit;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       __in._M_setstate(__ios_base::badbit);
       throw;
     }
   catch(...)
     {



       __in._M_setstate(__ios_base::badbit);
     }
 }
      if (!__extracted)
 __err |= __ios_base::failbit;
      if (__err)
 __in.setstate(__err);
      return __in;
    }
# 985 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.tcc" 3
  extern template void
    basic_string<char>::_M_replace_cold(char *, size_type, const char*,
     const size_type, const size_type);


  extern template
    basic_istream<char>&
    operator>>(basic_istream<char>&, string&);
  extern template
    basic_ostream<char>&
    operator<<(basic_ostream<char>&, const string&);
  extern template
    basic_istream<char>&
    getline(basic_istream<char>&, string&, char);
  extern template
    basic_istream<char>&
    getline(basic_istream<char>&, string&);
# 1011 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_string.tcc" 3
  extern template void
    basic_string<wchar_t>::_M_replace_cold(wchar_t*, size_type, const wchar_t*,
        const size_type, const size_type);


  extern template
    basic_istream<wchar_t>&
    operator>>(basic_istream<wchar_t>&, wstring&);
  extern template
    basic_ostream<wchar_t>&
    operator<<(basic_ostream<wchar_t>&, const wstring&);
  extern template
    basic_istream<wchar_t>&
    getline(basic_istream<wchar_t>&, wstring&, wchar_t);
  extern template
    basic_istream<wchar_t>&
    getline(basic_istream<wchar_t>&, wstring&);




}
# 56 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/string" 2 3








# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 65 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/string" 2 3



namespace std __attribute__ ((__visibility__ ("default")))
{

  namespace pmr {
    template<typename _CharT, typename _Traits = char_traits<_CharT>>
      using basic_string = std::basic_string<_CharT, _Traits,
          polymorphic_allocator<_CharT>>;
    using string = basic_string<char>;

    using u8string = basic_string<char8_t>;

    using u16string = basic_string<char16_t>;
    using u32string = basic_string<char32_t>;
    using wstring = basic_string<wchar_t>;
  }

}



namespace std __attribute__ ((__visibility__ ("default")))
{


  template<typename _CharT, typename _Traits, typename _Alloc,
    typename _Predicate>
    constexpr
    inline typename basic_string<_CharT, _Traits, _Alloc>::size_type
    erase_if(basic_string<_CharT, _Traits, _Alloc>& __cont, _Predicate __pred)
    {
      using namespace __gnu_cxx;
      const auto __osz = __cont.size();
      const auto __end = __cont.end();
      auto __removed = std::__remove_if(__cont.begin(), __end,
     __ops::__pred_iter(std::ref(__pred)));
      __cont.erase(__removed, __end);
      return __osz - __cont.size();
    }

  template<typename _CharT, typename _Traits, typename _Alloc, typename _Up>
    constexpr
    inline typename basic_string<_CharT, _Traits, _Alloc>::size_type
    erase(basic_string<_CharT, _Traits, _Alloc>& __cont, const _Up& __value)
    {
      using namespace __gnu_cxx;
      const auto __osz = __cont.size();
      const auto __end = __cont.end();
      auto __removed = std::__remove_if(__cont.begin(), __end,
     __ops::__iter_equals_val(__value));
      __cont.erase(__removed, __end);
      return __osz - __cont.size();
    }

}
# 41 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_classes.h" 2 3






namespace std __attribute__ ((__visibility__ ("default")))
{
# 66 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_classes.h" 3
  class locale
  {
  public:


    typedef int category;


    class facet;
    class id;
    class _Impl;

    friend class facet;
    friend class _Impl;

    template<typename _Facet>
      friend bool
      has_facet(const locale&) throw();

    template<typename _Facet>
      friend const _Facet&
      use_facet(const locale&);

    template<typename _Facet>
      friend const _Facet*
      __try_use_facet(const locale&) noexcept;

    template<typename _Cache>
      friend struct __use_cache;
# 106 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_classes.h" 3
    static const category none = 0;
    static const category ctype = 1L << 0;
    static const category numeric = 1L << 1;
    static const category collate = 1L << 2;
    static const category time = 1L << 3;
    static const category monetary = 1L << 4;
    static const category messages = 1L << 5;
    static const category all = (ctype | numeric | collate |
        time | monetary | messages);
# 125 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_classes.h" 3
    locale() throw();
# 134 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_classes.h" 3
    locale(const locale& __other) throw();
# 144 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_classes.h" 3
    explicit
    locale(const char* __s);
# 159 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_classes.h" 3
    locale(const locale& __base, const char* __s, category __cat);
# 170 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_classes.h" 3
    explicit
    locale(const std::string& __s) : locale(__s.c_str()) { }
# 185 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_classes.h" 3
    locale(const locale& __base, const std::string& __s, category __cat)
    : locale(__base, __s.c_str(), __cat) { }
# 200 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_classes.h" 3
    locale(const locale& __base, const locale& __add, category __cat);
# 213 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_classes.h" 3
    template<typename _Facet>
      locale(const locale& __other, _Facet* __f);


    ~locale() throw();
# 227 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_classes.h" 3
    const locale&
    operator=(const locale& __other) throw();
# 242 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_classes.h" 3
    template<typename _Facet>
      locale
      combine(const locale& __other) const;






    __attribute ((__abi_tag__ ("cxx11")))
    string
    name() const;
# 272 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_classes.h" 3
    bool
    operator==(const locale& __other) const throw();
# 302 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_classes.h" 3
    template<typename _Char, typename _Traits, typename _Alloc>
      bool
      operator()(const basic_string<_Char, _Traits, _Alloc>& __s1,
   const basic_string<_Char, _Traits, _Alloc>& __s2) const;
# 318 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_classes.h" 3
    static locale
    global(const locale& __loc);




    static const locale&
    classic();

  private:

    _Impl* _M_impl;


    static _Impl* _S_classic;


    static _Impl* _S_global;





    static const char* const* const _S_categories;
# 353 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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[];

  };
# 391 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_classes.h" 3
  class locale::facet
  {
  private:
    friend class locale;
    friend class locale::_Impl;

    mutable _Atomic_word _M_refcount;


    static __c_locale _S_c_locale;


    static const char _S_c_name[2];


    static __gthread_once_t _S_once;


    static void
    _S_initialize_once();

  protected:
# 422 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_classes.h" 3
    explicit
    facet(size_t __refs = 0) throw() : _M_refcount(__refs ? 1 : 0)
    { }


    virtual
    ~facet();

    static void
    _S_create_c_locale(__c_locale& __cloc, const char* __s,
         __c_locale __old = 0);

    static __c_locale
    _S_clone_c_locale(__c_locale& __cloc) throw();

    static void
    _S_destroy_c_locale(__c_locale& __cloc);

    static __c_locale
    _S_lc_ctype_c_locale(__c_locale __cloc, const char* __s);



    static __c_locale
    _S_get_c_locale();

    __attribute__ ((__const__)) static const char*
    _S_get_c_name() throw();
# 458 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_classes.h" 3
    facet(const facet&) = delete;

    facet&
    operator=(const facet&) = delete;


  private:
    void
    _M_add_reference() const throw()
    { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }

    void
    _M_remove_reference() const throw()
    {

                                                           ;
      if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1)
 {
                                                              ;
   try
     { delete this; }
   catch(...)
     { }
 }
    }

    const facet* _M_sso_shim(const id*) const;
    const facet* _M_cow_shim(const id*) const;

  protected:
    class __shim;
  };
# 503 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_classes.h" 3
  class locale::id
  {
  private:
    friend class locale;
    friend class locale::_Impl;

    template<typename _Facet>
      friend const _Facet&
      use_facet(const locale&);

    template<typename _Facet>
      friend bool
      has_facet(const locale&) throw();

    template<typename _Facet>
      friend const _Facet*
      __try_use_facet(const locale&) noexcept;




    mutable size_t _M_index;


    static _Atomic_word _S_refcount;

    void
    operator=(const id&);

    id(const id&);

  public:



    id() { }

    size_t
    _M_id() const throw();
  };



  class locale::_Impl
  {
  public:

    friend class locale;
    friend class locale::facet;

    template<typename _Facet>
      friend bool
      has_facet(const locale&) throw();

    template<typename _Facet>
      friend const _Facet&
      use_facet(const locale&);

    template<typename _Facet>
      friend const _Facet*
      __try_use_facet(const locale&) noexcept;

    template<typename _Cache>
      friend struct __use_cache;

  private:

    _Atomic_word _M_refcount;
    const facet** _M_facets;
    size_t _M_facets_size;
    const facet** _M_caches;
    char** _M_names;
    static const locale::id* const _S_id_ctype[];
    static const locale::id* const _S_id_numeric[];
    static const locale::id* const _S_id_collate[];
    static const locale::id* const _S_id_time[];
    static const locale::id* const _S_id_monetary[];
    static const locale::id* const _S_id_messages[];
    static const locale::id* const* const _S_facet_categories[];

    void
    _M_add_reference() throw()
    { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }

    void
    _M_remove_reference() throw()
    {

                                                           ;
      if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1)
 {
                                                              ;
   try
     { delete this; }
   catch(...)
     { }
 }
    }

    _Impl(const _Impl&, size_t);
    _Impl(const char*, size_t);
    _Impl(size_t) throw();

   ~_Impl() throw();

    _Impl(const _Impl&);

    void
    operator=(const _Impl&);

    bool
    _M_check_same_name()
    {
      bool __ret = true;
      if (_M_names[1])

 for (size_t __i = 0; __ret && __i < _S_categories_size - 1; ++__i)
   __ret = __builtin_strcmp(_M_names[__i], _M_names[__i + 1]) == 0;
      return __ret;
    }

    void
    _M_replace_categories(const _Impl*, category);

    void
    _M_replace_category(const _Impl*, const locale::id* const*);

    void
    _M_replace_facet(const _Impl*, const locale::id*);

    void
    _M_install_facet(const locale::id*, const facet*);

    template<typename _Facet>
      void
      _M_init_facet(_Facet* __facet)
      { _M_install_facet(&_Facet::id, __facet); }

    template<typename _Facet>
      void
      _M_init_facet_unchecked(_Facet* __facet)
      {
 __facet->_M_add_reference();
 _M_facets[_Facet::id._M_id()] = __facet;
      }

    void
    _M_install_cache(const facet*, size_t);

    void _M_init_extra(facet**);
    void _M_init_extra(void*, void*, const char*, const char*);




  };
# 673 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_classes.h" 3
  template<typename _CharT>
    class __cxx11:: collate : public locale::facet
    {
    public:



      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;


    protected:


      __c_locale _M_c_locale_collate;

    public:

      static locale::id id;
# 700 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_classes.h" 3
      explicit
      collate(size_t __refs = 0)
      : facet(__refs), _M_c_locale_collate(_S_get_c_locale())
      { }
# 714 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_classes.h" 3
      explicit
      collate(__c_locale __cloc, size_t __refs = 0)
      : facet(__refs), _M_c_locale_collate(_S_clone_c_locale(__cloc))
      { }
# 731 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_classes.h" 3
      int
      compare(const _CharT* __lo1, const _CharT* __hi1,
       const _CharT* __lo2, const _CharT* __hi2) const
      { return this->do_compare(__lo1, __hi1, __lo2, __hi2); }
# 750 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_classes.h" 3
      string_type
      transform(const _CharT* __lo, const _CharT* __hi) const
      { return this->do_transform(__lo, __hi); }
# 764 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_classes.h" 3
      long
      hash(const _CharT* __lo, const _CharT* __hi) const
      { return this->do_hash(__lo, __hi); }


      int
      _M_compare(const _CharT*, const _CharT*) const throw();

      size_t
      _M_transform(_CharT*, const _CharT*, size_t) const throw();

  protected:

      virtual
      ~collate()
      { _S_destroy_c_locale(_M_c_locale_collate); }
# 793 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_classes.h" 3
      virtual int
      do_compare(const _CharT* __lo1, const _CharT* __hi1,
   const _CharT* __lo2, const _CharT* __hi2) const;
# 807 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_classes.h" 3
      virtual string_type
      do_transform(const _CharT* __lo, const _CharT* __hi) const;
# 820 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_classes.h" 3
      virtual long
      do_hash(const _CharT* __lo, const _CharT* __hi) const;
    };

  template<typename _CharT>
    locale::id collate<_CharT>::id;


  template<>
    int
    collate<char>::_M_compare(const char*, const char*) const throw();

  template<>
    size_t
    collate<char>::_M_transform(char*, const char*, size_t) const throw();


  template<>
    int
    collate<wchar_t>::_M_compare(const wchar_t*, const wchar_t*) const throw();

  template<>
    size_t
    collate<wchar_t>::_M_transform(wchar_t*, const wchar_t*, size_t) const throw();



  template<typename _CharT>
    class __cxx11:: collate_byname : public collate<_CharT>
    {
    public:


      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;


      explicit
      collate_byname(const char* __s, size_t __refs = 0)
      : collate<_CharT>(__refs)
      {
 if (__builtin_strcmp(__s, "C") != 0
     && __builtin_strcmp(__s, "POSIX") != 0)
   {
     this->_S_destroy_c_locale(this->_M_c_locale_collate);
     this->_S_create_c_locale(this->_M_c_locale_collate, __s);
   }
      }


      explicit
      collate_byname(const string& __s, size_t __refs = 0)
      : collate_byname(__s.c_str(), __refs) { }


    protected:
      virtual
      ~collate_byname() { }
    };


}

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_classes.tcc" 1 3
# 38 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_classes.tcc" 3

namespace std __attribute__ ((__visibility__ ("default")))
{


  template<typename _Facet>
    locale::
    locale(const locale& __other, _Facet* __f)
    {
      _M_impl = new _Impl(*__other._M_impl, 1);

      try
 { _M_impl->_M_install_facet(&_Facet::id, __f); }
      catch(...)
 {
   _M_impl->_M_remove_reference();
   throw;
 }
      delete [] _M_impl->_M_names[0];
      _M_impl->_M_names[0] = 0;
    }

  template<typename _Facet>
    locale
    locale::
    combine(const locale& __other) const
    {
      _Impl* __tmp = new _Impl(*_M_impl, 1);
      try
 {
   __tmp->_M_replace_facet(__other._M_impl, &_Facet::id);
 }
      catch(...)
 {
   __tmp->_M_remove_reference();
   throw;
 }
      return locale(__tmp);
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    bool
    locale::
    operator()(const basic_string<_CharT, _Traits, _Alloc>& __s1,
        const basic_string<_CharT, _Traits, _Alloc>& __s2) const
    {
      typedef std::collate<_CharT> __collate_type;
      const __collate_type& __collate = use_facet<__collate_type>(*this);
      return (__collate.compare(__s1.data(), __s1.data() + __s1.length(),
    __s2.data(), __s2.data() + __s2.length()) < 0);
    }

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++17-extensions"
  template<typename _Facet>
    inline const _Facet*
    __try_use_facet(const locale& __loc) noexcept
    {
      const size_t __i = _Facet::id._M_id();
      const locale::facet** __facets = __loc._M_impl->_M_facets;







      if constexpr (__is_same(_Facet, ctype<char>)) return static_cast<const _Facet*>(__facets[__i]);
      if constexpr (__is_same(_Facet, num_get<char>)) return static_cast<const _Facet*>(__facets[__i]);
      if constexpr (__is_same(_Facet, num_put<char>)) return static_cast<const _Facet*>(__facets[__i]);
      if constexpr (__is_same(_Facet, codecvt<char, char, mbstate_t>)) return static_cast<const _Facet*>(__facets[__i]);
      if constexpr (__is_same(_Facet, collate<char>)) return static_cast<const _Facet*>(__facets[__i]);
      if constexpr (__is_same(_Facet, moneypunct<char>)) return static_cast<const _Facet*>(__facets[__i]);
      if constexpr (__is_same(_Facet, moneypunct<char, true>)) return static_cast<const _Facet*>(__facets[__i]);
      if constexpr (__is_same(_Facet, money_get<char>)) return static_cast<const _Facet*>(__facets[__i]);
      if constexpr (__is_same(_Facet, money_put<char>)) return static_cast<const _Facet*>(__facets[__i]);
      if constexpr (__is_same(_Facet, numpunct<char>)) return static_cast<const _Facet*>(__facets[__i]);
      if constexpr (__is_same(_Facet, time_get<char>)) return static_cast<const _Facet*>(__facets[__i]);
      if constexpr (__is_same(_Facet, time_put<char>)) return static_cast<const _Facet*>(__facets[__i]);
      if constexpr (__is_same(_Facet, messages<char>)) return static_cast<const _Facet*>(__facets[__i]);


      if constexpr (__is_same(_Facet, ctype<wchar_t>)) return static_cast<const _Facet*>(__facets[__i]);
      if constexpr (__is_same(_Facet, num_get<wchar_t>)) return static_cast<const _Facet*>(__facets[__i]);
      if constexpr (__is_same(_Facet, num_put<wchar_t>)) return static_cast<const _Facet*>(__facets[__i]);
      if constexpr (__is_same(_Facet, codecvt<wchar_t, char, mbstate_t>)) return static_cast<const _Facet*>(__facets[__i]);
      if constexpr (__is_same(_Facet, collate<wchar_t>)) return static_cast<const _Facet*>(__facets[__i]);
      if constexpr (__is_same(_Facet, moneypunct<wchar_t>)) return static_cast<const _Facet*>(__facets[__i]);
      if constexpr (__is_same(_Facet, moneypunct<wchar_t, true>)) return static_cast<const _Facet*>(__facets[__i]);
      if constexpr (__is_same(_Facet, money_get<wchar_t>)) return static_cast<const _Facet*>(__facets[__i]);
      if constexpr (__is_same(_Facet, money_put<wchar_t>)) return static_cast<const _Facet*>(__facets[__i]);
      if constexpr (__is_same(_Facet, numpunct<wchar_t>)) return static_cast<const _Facet*>(__facets[__i]);
      if constexpr (__is_same(_Facet, time_get<wchar_t>)) return static_cast<const _Facet*>(__facets[__i]);
      if constexpr (__is_same(_Facet, time_put<wchar_t>)) return static_cast<const _Facet*>(__facets[__i]);
      if constexpr (__is_same(_Facet, messages<wchar_t>)) return static_cast<const _Facet*>(__facets[__i]);


      if constexpr (__is_same(_Facet, codecvt<char16_t, char, mbstate_t>)) return static_cast<const _Facet*>(__facets[__i]);
      if constexpr (__is_same(_Facet, codecvt<char32_t, char, mbstate_t>)) return static_cast<const _Facet*>(__facets[__i]);




      if (__i >= __loc._M_impl->_M_facets_size || !__facets[__i])
 return 0;


      return dynamic_cast<const _Facet*>(__facets[__i]);



    }
#pragma GCC diagnostic pop
# 164 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_classes.tcc" 3
  template<typename _Facet>
    inline bool
    has_facet(const locale& __loc) throw()
    {

      static_assert(__is_base_of(locale::facet, _Facet),
      "template argument must be derived from locale::facet");



      return std::__try_use_facet<_Facet>(__loc) != 0;
    }
# 191 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_classes.tcc" 3
#pragma GCC diagnostic push

  template<typename _Facet>
    inline const _Facet&
    use_facet(const locale& __loc)
    {

      static_assert(__is_base_of(locale::facet, _Facet),
      "template argument must be derived from locale::facet");



      if (const _Facet* __f = std::__try_use_facet<_Facet>(__loc))
 return *__f;
      __throw_bad_cast();
    }
#pragma GCC diagnostic pop



  template<typename _CharT>
    int
    collate<_CharT>::_M_compare(const _CharT*, const _CharT*) const throw ()
    { return 0; }


  template<typename _CharT>
    size_t
    collate<_CharT>::_M_transform(_CharT*, const _CharT*, size_t) const throw ()
    { return 0; }

  template<typename _CharT>
    int
    collate<_CharT>::
    do_compare(const _CharT* __lo1, const _CharT* __hi1,
        const _CharT* __lo2, const _CharT* __hi2) const
    {


      const string_type __one(__lo1, __hi1);
      const string_type __two(__lo2, __hi2);

      const _CharT* __p = __one.c_str();
      const _CharT* __pend = __one.data() + __one.length();
      const _CharT* __q = __two.c_str();
      const _CharT* __qend = __two.data() + __two.length();




      for (;;)
 {
   const int __res = _M_compare(__p, __q);
   if (__res)
     return __res;

   __p += char_traits<_CharT>::length(__p);
   __q += char_traits<_CharT>::length(__q);
   if (__p == __pend && __q == __qend)
     return 0;
   else if (__p == __pend)
     return -1;
   else if (__q == __qend)
     return 1;

   __p++;
   __q++;
 }
    }

  template<typename _CharT>
    typename collate<_CharT>::string_type
    collate<_CharT>::
    do_transform(const _CharT* __lo, const _CharT* __hi) const
    {
      string_type __ret;


      const string_type __str(__lo, __hi);

      const _CharT* __p = __str.c_str();
      const _CharT* __pend = __str.data() + __str.length();

      size_t __len = (__hi - __lo) * 2;

      _CharT* __c = new _CharT[__len];

      try
 {



   for (;;)
     {

       size_t __res = _M_transform(__c, __p, __len);


       if (__res >= __len)
  {
    __len = __res + 1;
    delete [] __c, __c = 0;
    __c = new _CharT[__len];
    __res = _M_transform(__c, __p, __len);
  }

       __ret.append(__c, __res);
       __p += char_traits<_CharT>::length(__p);
       if (__p == __pend)
  break;

       __p++;
       __ret.push_back(_CharT());
     }
 }
      catch(...)
 {
   delete [] __c;
   throw;
 }

      delete [] __c;

      return __ret;
    }

  template<typename _CharT>
    long
    collate<_CharT>::
    do_hash(const _CharT* __lo, const _CharT* __hi) const
    {
      unsigned long __val = 0;
      for (; __lo < __hi; ++__lo)
 __val =
   *__lo + ((__val << 7)
     | (__val >> (__gnu_cxx::__numeric_traits<unsigned long>::
    __digits - 7)));
      return static_cast<long>(__val);
    }




  extern template class collate<char>;
  extern template class collate_byname<char>;

  extern template
    const collate<char>*
    __try_use_facet<collate<char> >(const locale&) noexcept;

  extern template
    const collate<char>&
    use_facet<collate<char> >(const locale&);

  extern template
    bool
    has_facet<collate<char> >(const locale&);


  extern template class collate<wchar_t>;
  extern template class collate_byname<wchar_t>;

  extern template
    const collate<wchar_t>*
    __try_use_facet<collate<wchar_t> >(const locale&) noexcept;

  extern template
    const collate<wchar_t>&
    use_facet<collate<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<collate<wchar_t> >(const locale&);




}
# 884 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_classes.h" 2 3
# 42 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ios_base.h" 2 3




# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/system_error" 1 3
# 33 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/system_error" 3








# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/error_constants.h" 1 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/error_constants.h" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cerrno" 1 3
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cerrno" 3
# 35 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/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
    };


}
# 42 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/system_error" 2 3

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/stdexcept" 1 3
# 37 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/stdexcept" 3

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/exception" 1 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/exception" 3





# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/exception" 2 3

extern "C++" {

namespace std __attribute__ ((__visibility__ ("default")))
{
# 54 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/exception" 3
  class bad_exception : public exception
  {
  public:
    bad_exception() noexcept { }



    virtual ~bad_exception() noexcept;


    virtual const char*
    what() const noexcept;
  };


  typedef void (*terminate_handler) ();


  terminate_handler set_terminate(terminate_handler) noexcept;



  terminate_handler get_terminate() noexcept;




  void terminate() noexcept __attribute__ ((__noreturn__,__cold__));
# 124 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/exception" 3
  __attribute__ ((__deprecated__ ("use '" "std::uncaught_exceptions()" "' instead")))
  bool uncaught_exception() noexcept __attribute__ ((__pure__));






  int uncaught_exceptions() noexcept __attribute__ ((__pure__));



}

namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
# 158 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/exception" 3
  void __verbose_terminate_handler();


}

}


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/exception_ptr.h" 1 3
# 36 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/exception_ptr.h" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/cxxabi_init_exception.h" 1 3
# 35 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/cxxabi_init_exception.h" 3

#pragma GCC visibility push(default)

# 1 "/usr/bin/../lib/clang/18/include/stddef.h" 1 3
# 72 "/usr/bin/../lib/clang/18/include/stddef.h" 3
# 1 "/usr/bin/../lib/clang/18/include/__stddef_ptrdiff_t.h" 1 3
# 18 "/usr/bin/../lib/clang/18/include/__stddef_ptrdiff_t.h" 3
typedef long int ptrdiff_t;
# 73 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3




# 1 "/usr/bin/../lib/clang/18/include/__stddef_size_t.h" 1 3
# 18 "/usr/bin/../lib/clang/18/include/__stddef_size_t.h" 3
typedef long unsigned int size_t;
# 78 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3
# 87 "/usr/bin/../lib/clang/18/include/stddef.h" 3
# 1 "/usr/bin/../lib/clang/18/include/__stddef_wchar_t.h" 1 3
# 88 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3




# 1 "/usr/bin/../lib/clang/18/include/__stddef_null.h" 1 3
# 93 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3




# 1 "/usr/bin/../lib/clang/18/include/__stddef_nullptr_t.h" 1 3
# 98 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3
# 112 "/usr/bin/../lib/clang/18/include/stddef.h" 3
# 1 "/usr/bin/../lib/clang/18/include/__stddef_offsetof.h" 1 3
# 113 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3
# 39 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/cxxabi_init_exception.h" 2 3
# 50 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/cxxabi_init_exception.h" 3
namespace std
{
  class type_info;
}

namespace __cxxabiv1
{
  struct __cxa_refcounted_exception;

  extern "C"
    {

      void*
      __cxa_allocate_exception(size_t) noexcept;

      void
      __cxa_free_exception(void*) noexcept;


      __cxa_refcounted_exception*
      __cxa_init_primary_exception(void *__object, std::type_info *__tinfo,
                void ( *__dest) (void *))
 noexcept;

    }
}



#pragma GCC visibility pop
# 37 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/exception_ptr.h" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/typeinfo" 1 3
# 33 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/typeinfo" 3







# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 41 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/typeinfo" 2 3

#pragma GCC visibility push(default)

extern "C++" {

namespace __cxxabiv1
{
  class __class_type_info;
}
# 83 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/typeinfo" 3
namespace std
{






  class type_info
  {
  public:




    virtual ~type_info();



    const char* name() const noexcept
    { return __name[0] == '*' ? __name + 1 : __name; }



    bool before(const type_info& __arg) const noexcept;

    constexpr
    bool operator==(const type_info& __arg) const noexcept;







    size_t hash_code() const noexcept
    {

      return _Hash_bytes(name(), __builtin_strlen(name()),
    static_cast<size_t>(0xc70f6907UL));



    }



    virtual bool __is_pointer_p() const;


    virtual bool __is_function_p() const;







    virtual bool __do_catch(const type_info *__thr_type, void **__thr_obj,
       unsigned __outer) const;


    virtual bool __do_upcast(const __cxxabiv1::__class_type_info *__target,
        void **__obj_ptr) const;

  protected:
    const char *__name;

    explicit type_info(const char *__n): __name(__n) { }

  private:


    type_info& operator=(const type_info&) = delete;
    type_info(const type_info&) = delete;
# 166 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/typeinfo" 3
  };


  inline bool
  type_info::before(const type_info& __arg) const noexcept
  {




    if (__name[0] != '*' || __arg.__name[0] != '*')
      return __builtin_strcmp (__name, __arg.__name) < 0;
# 186 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/typeinfo" 3
    return __name < __arg.__name;
  }



  constexpr inline bool
  type_info::operator==(const type_info& __arg) const noexcept
  {
    if (std::__is_constant_evaluated())
      return this == &__arg;

    if (__name == __arg.__name)
      return true;






    return __name[0] != '*' && __builtin_strcmp (__name, __arg.name()) == 0;



  }
# 219 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/typeinfo" 3
  class bad_cast : public exception
  {
  public:
    bad_cast() noexcept { }



    virtual ~bad_cast() noexcept;


    virtual const char* what() const noexcept;
  };





  class bad_typeid : public exception
  {
  public:
    bad_typeid () noexcept { }



    virtual ~bad_typeid() noexcept;


    virtual const char* what() const noexcept;
  };
}

}

#pragma GCC visibility pop
# 38 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/exception_ptr.h" 2 3
# 50 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/exception_ptr.h" 3
extern "C++" {

namespace std __attribute__ ((__visibility__ ("default")))
{
  class type_info;






  namespace __exception_ptr
  {
    class exception_ptr;
  }

  using __exception_ptr::exception_ptr;
# 75 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/exception_ptr.h" 3
  exception_ptr current_exception() noexcept;

  template<typename _Ex>
  exception_ptr make_exception_ptr(_Ex) noexcept;


  void rethrow_exception(exception_ptr) __attribute__ ((__noreturn__));

  namespace __exception_ptr
  {
    using std::rethrow_exception;
# 97 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/exception_ptr.h" 3
    class exception_ptr
    {
      void* _M_exception_object;

      explicit exception_ptr(void* __e) noexcept;

      void _M_addref() noexcept;
      void _M_release() noexcept;

      void *_M_get() const noexcept __attribute__ ((__pure__));

      friend exception_ptr std::current_exception() noexcept;
      friend void std::rethrow_exception(exception_ptr);
      template<typename _Ex>
      friend exception_ptr std::make_exception_ptr(_Ex) noexcept;

    public:
      exception_ptr() noexcept;

      exception_ptr(const exception_ptr&) noexcept;


      exception_ptr(nullptr_t) noexcept
      : _M_exception_object(nullptr)
      { }

      exception_ptr(exception_ptr&& __o) noexcept
      : _M_exception_object(__o._M_exception_object)
      { __o._M_exception_object = nullptr; }
# 135 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/exception_ptr.h" 3
      exception_ptr&
      operator=(const exception_ptr&) noexcept;


      exception_ptr&
      operator=(exception_ptr&& __o) noexcept
      {
        exception_ptr(static_cast<exception_ptr&&>(__o)).swap(*this);
        return *this;
      }


      ~exception_ptr() noexcept;

      void
      swap(exception_ptr&) noexcept;
# 162 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/exception_ptr.h" 3
      explicit operator bool() const noexcept
      { return _M_exception_object; }




      friend bool
      operator==(const exception_ptr&, const exception_ptr&) noexcept = default;
# 182 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/exception_ptr.h" 3
      const class std::type_info*
      __cxa_exception_type() const noexcept
 __attribute__ ((__pure__));
    };


    inline
    exception_ptr::exception_ptr() noexcept
    : _M_exception_object(0)
    { }


    inline
    exception_ptr::exception_ptr(const exception_ptr& __other)
    noexcept
    : _M_exception_object(__other._M_exception_object)
    {
      if (_M_exception_object)
 _M_addref();
    }


    inline
    exception_ptr::~exception_ptr() noexcept
    {
      if (_M_exception_object)
 _M_release();
    }


    inline exception_ptr&
    exception_ptr::operator=(const exception_ptr& __other) noexcept
    {
      exception_ptr(__other).swap(*this);
      return *this;
    }


    inline void
    exception_ptr::swap(exception_ptr &__other) noexcept
    {
      void *__tmp = _M_exception_object;
      _M_exception_object = __other._M_exception_object;
      __other._M_exception_object = __tmp;
    }


    inline void
    swap(exception_ptr& __lhs, exception_ptr& __rhs)
    { __lhs.swap(__rhs); }


    template<typename _Ex>

      inline void
      __dest_thunk(void* __x)
      { static_cast<_Ex*>(__x)->~_Ex(); }


  }

  using __exception_ptr::swap;



  template<typename _Ex>
    exception_ptr
    make_exception_ptr(_Ex __ex) noexcept
    {

      using _Ex2 = typename decay<_Ex>::type;
      void* __e = __cxxabiv1::__cxa_allocate_exception(sizeof(_Ex));
      (void) __cxxabiv1::__cxa_init_primary_exception(
   __e, const_cast<std::type_info*>(&typeid(_Ex)),
   __exception_ptr::__dest_thunk<_Ex2>);
      try
 {
   ::new (__e) _Ex2(__ex);
   return exception_ptr(__e);
 }
      catch(...)
 {
   __cxxabiv1::__cxa_free_exception(__e);
   return current_exception();
 }
# 277 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/exception_ptr.h" 3
    }
# 291 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/exception_ptr.h" 3
}

}
# 167 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/exception" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/nested_exception.h" 1 3
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/nested_exception.h" 3
extern "C++" {

namespace std __attribute__ ((__visibility__ ("default")))
{
# 59 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/nested_exception.h" 3
  class nested_exception
  {
    exception_ptr _M_ptr;

  public:

    nested_exception() noexcept : _M_ptr(current_exception()) { }

    nested_exception(const nested_exception&) noexcept = default;

    nested_exception& operator=(const nested_exception&) noexcept = default;

    virtual ~nested_exception() noexcept;


    [[noreturn]]
    void
    rethrow_nested() const
    {
      if (_M_ptr)
 rethrow_exception(_M_ptr);
      std::terminate();
    }


    exception_ptr
    nested_ptr() const noexcept
    { return _M_ptr; }
  };



  template<typename _Except>
    struct _Nested_exception : public _Except, public nested_exception
    {
      explicit _Nested_exception(const _Except& __ex)
      : _Except(__ex)
      { }

      explicit _Nested_exception(_Except&& __ex)
      : _Except(static_cast<_Except&&>(__ex))
      { }
    };
# 145 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/nested_exception.h" 3
  template<typename _Tp>
    [[noreturn]]
    inline void
    throw_with_nested(_Tp&& __t)
    {
      using _Up = typename decay<_Tp>::type;
      using _CopyConstructible
 = __and_<is_copy_constructible<_Up>, is_move_constructible<_Up>>;
      static_assert(_CopyConstructible::value,
   "throw_with_nested argument must be CopyConstructible");


      if constexpr (is_class_v<_Up>)
 if constexpr (!is_final_v<_Up>)
   if constexpr (!is_base_of_v<nested_exception, _Up>)
     throw _Nested_exception<_Up>{std::forward<_Tp>(__t)};
      throw std::forward<_Tp>(__t);





    }
# 203 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/nested_exception.h" 3
  template<typename _Ex>



    inline void
    rethrow_if_nested(const _Ex& __ex)
    {
      const _Ex* __ptr = __builtin_addressof(__ex);
# 223 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/nested_exception.h" 3
      if constexpr (!is_polymorphic_v<_Ex>)
 return;
      else if constexpr (is_base_of_v<nested_exception, _Ex>
    && !is_convertible_v<_Ex*, nested_exception*>)
 return;




      else if (auto __ne_ptr = dynamic_cast<const nested_exception*>(__ptr))
 __ne_ptr->rethrow_nested();

    }


}

}
# 168 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/exception" 2 3
# 39 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/stdexcept" 2 3


namespace std __attribute__ ((__visibility__ ("default")))
{





  struct __cow_string
  {
    union {
      const char* _M_p;
      char _M_bytes[sizeof(const char*)];
    };

    __cow_string();
    __cow_string(const std::string&);
    __cow_string(const char*, size_t);
    __cow_string(const __cow_string&) noexcept;
    __cow_string& operator=(const __cow_string&) noexcept;
    ~__cow_string();

    __cow_string(__cow_string&&) noexcept;
    __cow_string& operator=(__cow_string&&) noexcept;

  };

  typedef basic_string<char> __sso_string;
# 113 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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;
  };




}
# 44 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/system_error" 2 3




namespace std __attribute__ ((__visibility__ ("default")))
{






  class error_code;
  class error_condition;
  class system_error;


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


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

  template<>
    struct is_error_condition_enum<errc>
    : public true_type { };


  template <typename _Tp>
    inline constexpr bool is_error_code_enum_v =
      is_error_code_enum<_Tp>::value;
  template <typename _Tp>
    inline constexpr bool is_error_condition_enum_v =
      is_error_condition_enum<_Tp>::value;



inline namespace _V2 {
# 106 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/system_error" 3
  class error_category
  {
  public:
    constexpr error_category() noexcept = default;

    virtual ~error_category();

    error_category(const error_category&) = delete;
    error_category& operator=(const error_category&) = delete;


    virtual const char*
    name() const noexcept = 0;






  private:
    __attribute ((__abi_tag__ ("cxx11")))
    virtual __cow_string
    _M_message(int) const;

  public:

    __attribute ((__abi_tag__ ("cxx11")))
    virtual string
    message(int) const = 0;
# 144 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/system_error" 3
  public:

    virtual error_condition
    default_error_condition(int __i) const noexcept;


    virtual bool
    equivalent(int __i, const error_condition& __cond) const noexcept;


    virtual bool
    equivalent(const error_code& __code, int __i) const noexcept;


    [[__nodiscard__]]
    bool
    operator==(const error_category& __other) const noexcept
    { return this == &__other; }



    [[nodiscard]]
    strong_ordering
    operator<=>(const error_category& __rhs) const noexcept
    { return std::compare_three_way()(this, &__rhs); }
# 178 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/system_error" 3
  };




  [[__nodiscard__, __gnu__::__const__]]
  const error_category&
  generic_category() noexcept;


  [[__nodiscard__, __gnu__::__const__]]
  const error_category&
  system_category() noexcept;



}





namespace __adl_only
{
  void make_error_code() = delete;
  void make_error_condition() = delete;
}
# 223 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/system_error" 3
  class error_code
  {
    template<typename _ErrorCodeEnum>
      using _Check
 = __enable_if_t<is_error_code_enum<_ErrorCodeEnum>::value>;

  public:
    error_code() noexcept
    : _M_value(0), _M_cat(&system_category()) { }

    error_code(int __v, const error_category& __cat) noexcept
    : _M_value(__v), _M_cat(&__cat) { }


    template<typename _ErrorCodeEnum,
      typename = _Check<_ErrorCodeEnum>>
      error_code(_ErrorCodeEnum __e) noexcept
      {
 using __adl_only::make_error_code;
 *this = make_error_code(__e);
      }

    error_code(const error_code&) = default;
    error_code& operator=(const error_code&) = default;

    void
    assign(int __v, const error_category& __cat) noexcept
    {
      _M_value = __v;
      _M_cat = &__cat;
    }

    void
    clear() noexcept
    { assign(0, system_category()); }


    [[__nodiscard__]]
    int
    value() const noexcept { return _M_value; }


    [[__nodiscard__]]
    const error_category&
    category() const noexcept { return *_M_cat; }


    error_condition
    default_error_condition() const noexcept;


    __attribute ((__abi_tag__ ("cxx11")))
    string
    message() const
    { return category().message(value()); }


    [[__nodiscard__]]
    explicit operator bool() const noexcept
    { return _M_value != 0; }


  private:
    int _M_value;
    const error_category* _M_cat;
  };
# 300 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/system_error" 3
  [[__nodiscard__]]
  inline error_code
  make_error_code(errc __e) noexcept
  { return error_code(static_cast<int>(__e), generic_category()); }
# 314 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/system_error" 3
  [[nodiscard]]
  inline strong_ordering
  operator<=>(const error_code& __lhs, const error_code& __rhs) noexcept
  {
    if (auto __c = __lhs.category() <=> __rhs.category(); __c != 0)
      return __c;
    return __lhs.value() <=> __rhs.value();
  }
# 337 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/system_error" 3
  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, const error_code& __e)
    { return (__os << __e.category().name() << ':' << __e.value()); }
# 354 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/system_error" 3
  class error_condition
  {
    template<typename _ErrorConditionEnum>
      using _Check
 = __enable_if_t<is_error_condition_enum<_ErrorConditionEnum>::value>;

  public:

    error_condition() noexcept
    : _M_value(0), _M_cat(&generic_category()) { }


    error_condition(int __v, const error_category& __cat) noexcept
    : _M_value(__v), _M_cat(&__cat) { }


    template<typename _ErrorConditionEnum,
      typename = _Check<_ErrorConditionEnum>>
      error_condition(_ErrorConditionEnum __e) noexcept
      {
 using __adl_only::make_error_condition;
 *this = make_error_condition(__e);
      }

    error_condition(const error_condition&) = default;
    error_condition& operator=(const error_condition&) = default;


    void
    assign(int __v, const error_category& __cat) noexcept
    {
      _M_value = __v;
      _M_cat = &__cat;
    }


    void
    clear() noexcept
    { assign(0, generic_category()); }




    [[__nodiscard__]]
    int
    value() const noexcept { return _M_value; }


    [[__nodiscard__]]
    const error_category&
    category() const noexcept { return *_M_cat; }


    __attribute ((__abi_tag__ ("cxx11")))
    string
    message() const
    { return category().message(value()); }


    [[__nodiscard__]]
    explicit operator bool() const noexcept
    { return _M_value != 0; }


  private:
    int _M_value;
    const error_category* _M_cat;
  };
# 433 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/system_error" 3
  [[__nodiscard__]]
  inline error_condition
  make_error_condition(errc __e) noexcept
  { return error_condition(static_cast<int>(__e), generic_category()); }
# 447 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/system_error" 3
  [[__nodiscard__]]
  inline bool
  operator==(const error_code& __lhs, const error_code& __rhs) noexcept
  {
    return __lhs.category() == __rhs.category()
      && __lhs.value() == __rhs.value();
  }
# 463 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/system_error" 3
  [[__nodiscard__]]
  inline bool
  operator==(const error_code& __lhs, const error_condition& __rhs) noexcept
  {
    return __lhs.category().equivalent(__lhs.value(), __rhs)
      || __rhs.category().equivalent(__lhs, __rhs.value());
  }
# 478 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/system_error" 3
  [[__nodiscard__]]
  inline bool
  operator==(const error_condition& __lhs,
      const error_condition& __rhs) noexcept
  {
    return __lhs.category() == __rhs.category()
      && __lhs.value() == __rhs.value();
  }
# 496 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/system_error" 3
  [[nodiscard]]
  inline strong_ordering
  operator<=>(const error_condition& __lhs,
       const error_condition& __rhs) noexcept
  {
    if (auto __c = __lhs.category() <=> __rhs.category(); __c != 0)
      return __c;
    return __lhs.value() <=> __rhs.value();
  }
# 556 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/system_error" 3
  class system_error : public std::runtime_error
  {
  private:
    error_code _M_code;

  public:
    system_error(error_code __ec = error_code())
    : runtime_error(__ec.message()), _M_code(__ec) { }

    system_error(error_code __ec, const string& __what)
    : runtime_error(__what + (": " + __ec.message())), _M_code(__ec) { }

    system_error(error_code __ec, const char* __what)
    : runtime_error(__what + (": " + __ec.message())), _M_code(__ec) { }

    system_error(int __v, const error_category& __ecat, const char* __what)
    : system_error(error_code(__v, __ecat), __what) { }

    system_error(int __v, const error_category& __ecat)
    : runtime_error(error_code(__v, __ecat).message()),
      _M_code(__v, __ecat) { }

    system_error(int __v, const error_category& __ecat, const string& __what)
    : runtime_error(__what + (": " + error_code(__v, __ecat).message())),
      _M_code(__v, __ecat) { }


    system_error (const system_error &) = default;
    system_error &operator= (const system_error &) = default;


    virtual ~system_error() noexcept;

    const error_code&
    code() const noexcept { return _M_code; }
  };


}



namespace std __attribute__ ((__visibility__ ("default")))
{






  template<>
    struct hash<error_code>
    : public __hash_base<size_t, error_code>
    {
      size_t
      operator()(const error_code& __e) const noexcept
      {
 const size_t __tmp = std::_Hash_impl::hash(__e.value());
 return std::_Hash_impl::__hash_combine(&__e.category(), __tmp);
      }
    };






  template<>
    struct hash<error_condition>
    : public __hash_base<size_t, error_condition>
    {
      size_t
      operator()(const error_condition& __e) const noexcept
      {
 const size_t __tmp = std::_Hash_impl::hash(__e.value());
 return std::_Hash_impl::__hash_combine(&__e.category(), __tmp);
      }
    };



}
# 47 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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 = 2147483647,
      _S_ios_fmtflags_min = ~2147483647
    };

  [[__nodiscard__]] constexpr
  inline _Ios_Fmtflags
  operator&(_Ios_Fmtflags __a, _Ios_Fmtflags __b) noexcept
  { return _Ios_Fmtflags(static_cast<int>(__a) & static_cast<int>(__b)); }

  [[__nodiscard__]] constexpr
  inline _Ios_Fmtflags
  operator|(_Ios_Fmtflags __a, _Ios_Fmtflags __b) noexcept
  { return _Ios_Fmtflags(static_cast<int>(__a) | static_cast<int>(__b)); }

  [[__nodiscard__]] constexpr
  inline _Ios_Fmtflags
  operator^(_Ios_Fmtflags __a, _Ios_Fmtflags __b) noexcept
  { return _Ios_Fmtflags(static_cast<int>(__a) ^ static_cast<int>(__b)); }

  [[__nodiscard__]] constexpr
  inline _Ios_Fmtflags
  operator~(_Ios_Fmtflags __a) noexcept
  { return _Ios_Fmtflags(~static_cast<int>(__a)); }

  constexpr
  inline const _Ios_Fmtflags&
  operator|=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b) noexcept
  { return __a = __a | __b; }

  constexpr
  inline const _Ios_Fmtflags&
  operator&=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b) noexcept
  { return __a = __a & __b; }

  constexpr
  inline const _Ios_Fmtflags&
  operator^=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b) noexcept
  { return __a = __a ^ __b; }


  enum _Ios_Openmode
    {
      _S_app = 1L << 0,
      _S_ate = 1L << 1,
      _S_bin = 1L << 2,
      _S_in = 1L << 3,
      _S_out = 1L << 4,
      _S_trunc = 1L << 5,
      _S_noreplace = 1L << 6,
      _S_ios_openmode_end = 1L << 16,
      _S_ios_openmode_max = 2147483647,
      _S_ios_openmode_min = ~2147483647
    };

  [[__nodiscard__]] constexpr
  inline _Ios_Openmode
  operator&(_Ios_Openmode __a, _Ios_Openmode __b) noexcept
  { return _Ios_Openmode(static_cast<int>(__a) & static_cast<int>(__b)); }

  [[__nodiscard__]] constexpr
  inline _Ios_Openmode
  operator|(_Ios_Openmode __a, _Ios_Openmode __b) noexcept
  { return _Ios_Openmode(static_cast<int>(__a) | static_cast<int>(__b)); }

  [[__nodiscard__]] constexpr
  inline _Ios_Openmode
  operator^(_Ios_Openmode __a, _Ios_Openmode __b) noexcept
  { return _Ios_Openmode(static_cast<int>(__a) ^ static_cast<int>(__b)); }

  [[__nodiscard__]] constexpr
  inline _Ios_Openmode
  operator~(_Ios_Openmode __a) noexcept
  { return _Ios_Openmode(~static_cast<int>(__a)); }

  constexpr
  inline const _Ios_Openmode&
  operator|=(_Ios_Openmode& __a, _Ios_Openmode __b) noexcept
  { return __a = __a | __b; }

  constexpr
  inline const _Ios_Openmode&
  operator&=(_Ios_Openmode& __a, _Ios_Openmode __b) noexcept
  { return __a = __a & __b; }

  constexpr
  inline const _Ios_Openmode&
  operator^=(_Ios_Openmode& __a, _Ios_Openmode __b) noexcept
  { return __a = __a ^ __b; }


  enum _Ios_Iostate
    {
      _S_goodbit = 0,
      _S_badbit = 1L << 0,
      _S_eofbit = 1L << 1,
      _S_failbit = 1L << 2,
      _S_ios_iostate_end = 1L << 16,
      _S_ios_iostate_max = 2147483647,
      _S_ios_iostate_min = ~2147483647
    };

  [[__nodiscard__]] constexpr
  inline _Ios_Iostate
  operator&(_Ios_Iostate __a, _Ios_Iostate __b) noexcept
  { return _Ios_Iostate(static_cast<int>(__a) & static_cast<int>(__b)); }

  [[__nodiscard__]] constexpr
  inline _Ios_Iostate
  operator|(_Ios_Iostate __a, _Ios_Iostate __b) noexcept
  { return _Ios_Iostate(static_cast<int>(__a) | static_cast<int>(__b)); }

  [[__nodiscard__]] constexpr
  inline _Ios_Iostate
  operator^(_Ios_Iostate __a, _Ios_Iostate __b) noexcept
  { return _Ios_Iostate(static_cast<int>(__a) ^ static_cast<int>(__b)); }

  [[__nodiscard__]] constexpr
  inline _Ios_Iostate
  operator~(_Ios_Iostate __a) noexcept
  { return _Ios_Iostate(~static_cast<int>(__a)); }

  constexpr
  inline const _Ios_Iostate&
  operator|=(_Ios_Iostate& __a, _Ios_Iostate __b) noexcept
  { return __a = __a | __b; }

  constexpr
  inline const _Ios_Iostate&
  operator&=(_Ios_Iostate& __a, _Ios_Iostate __b) noexcept
  { return __a = __a & __b; }

  constexpr
  inline const _Ios_Iostate&
  operator^=(_Ios_Iostate& __a, _Ios_Iostate __b) noexcept
  { return __a = __a ^ __b; }


  enum _Ios_Seekdir
    {
      _S_beg = 0,
      _S_cur = 1,
      _S_end = 2,
      _S_ios_seekdir_end = 1L << 16
    };



  enum class io_errc { stream = 1 };

  template <> struct is_error_code_enum<io_errc> : public true_type { };

  [[__nodiscard__, __gnu__::__const__]]
  const error_category&
  iostream_category() noexcept;

  [[__nodiscard__]]
  inline error_code
  make_error_code(io_errc __e) noexcept
  { return error_code(static_cast<int>(__e), iostream_category()); }

  [[__nodiscard__]]
  inline error_condition
  make_error_condition(io_errc __e) noexcept
  { return error_condition(static_cast<int>(__e), iostream_category()); }
# 254 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ios_base.h" 3
  class ios_base
  {
# 272 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ios_base.h" 3
  public:
# 281 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ios_base.h" 3
    class __attribute ((__abi_tag__ ("cxx11"))) failure : public system_error
    {
    public:
      explicit
      failure(const string& __str);


      explicit
      failure(const string&, const error_code&);

      explicit
      failure(const char*, const error_code& = io_errc::stream);


      virtual
      ~failure() throw();

      virtual const char*
      what() const throw();
    };
# 367 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ios_base.h" 3
    typedef _Ios_Fmtflags fmtflags;


    static const fmtflags boolalpha = _S_boolalpha;


    static const fmtflags dec = _S_dec;


    static const fmtflags fixed = _S_fixed;


    static const fmtflags hex = _S_hex;




    static const fmtflags internal = _S_internal;



    static const fmtflags left = _S_left;


    static const fmtflags oct = _S_oct;



    static const fmtflags right = _S_right;


    static const fmtflags scientific = _S_scientific;



    static const fmtflags showbase = _S_showbase;



    static const fmtflags showpoint = _S_showpoint;


    static const fmtflags showpos = _S_showpos;


    static const fmtflags skipws = _S_skipws;


    static const fmtflags unitbuf = _S_unitbuf;



    static const fmtflags uppercase = _S_uppercase;


    static const fmtflags adjustfield = _S_adjustfield;


    static const fmtflags basefield = _S_basefield;


    static const fmtflags floatfield = _S_floatfield;
# 442 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ios_base.h" 3
    typedef _Ios_Iostate iostate;



    static const iostate badbit = _S_badbit;


    static const iostate eofbit = _S_eofbit;




    static const iostate failbit = _S_failbit;


    static const iostate goodbit = _S_goodbit;
# 473 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ios_base.h" 3
    typedef _Ios_Openmode openmode;


    static const openmode app = _S_app;


    static const openmode ate = _S_ate;




    static const openmode binary = _S_bin;


    static const openmode in = _S_in;


    static const openmode out = _S_out;


    static const openmode trunc = _S_trunc;

    static const openmode __noreplace = _S_noreplace;



    static const openmode noreplace = _S_noreplace;
# 512 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ios_base.h" 3
    typedef _Ios_Seekdir seekdir;


    static const seekdir beg = _S_beg;


    static const seekdir cur = _S_cur;


    static const seekdir end = _S_end;
# 545 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ios_base.h" 3
    enum event
    {
      erase_event,
      imbue_event,
      copyfmt_event
    };
# 562 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ios_base.h" 3
    typedef void (*event_callback) (event __e, ios_base& __b, int __i);
# 574 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ios_base.h" 3
    void
    register_callback(event_callback __fn, int __index);

  protected:
    streamsize _M_precision;
    streamsize _M_width;
    fmtflags _M_flags;
    iostate _M_exception;
    iostate _M_streambuf_state;



    struct _Callback_list
    {

      _Callback_list* _M_next;
      ios_base::event_callback _M_fn;
      int _M_index;
      _Atomic_word _M_refcount;

      _Callback_list(ios_base::event_callback __fn, int __index,
       _Callback_list* __cb)
      : _M_next(__cb), _M_fn(__fn), _M_index(__index), _M_refcount(0) { }

      void
      _M_add_reference() { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); }


      int
      _M_remove_reference()
      {

                                                             ;
        int __res = __gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1);
        if (__res == 0)
          {
                                                                ;
          }
        return __res;
      }
    };

     _Callback_list* _M_callbacks;

    void
    _M_call_callbacks(event __ev) throw();

    void
    _M_dispose_callbacks(void) throw();


    struct _Words
    {
      void* _M_pword;
      long _M_iword;
      _Words() : _M_pword(0), _M_iword(0) { }
    };


    _Words _M_word_zero;



    enum { _S_local_word_size = 8 };
    _Words _M_local_word[_S_local_word_size];


    int _M_word_size;
    _Words* _M_word;

    _Words&
    _M_grow_words(int __index, bool __iword);


    locale _M_ios_locale;

    void
    _M_init() throw();

  public:





    class Init
    {
      friend class ios_base;
    public:
      Init();
      ~Init();


      Init(const Init&) = default;
      Init& operator=(const Init&) = default;


    private:
      static _Atomic_word _S_refcount;
      static bool _S_synced_with_stdio;
    };






    fmtflags
    flags() const
    { return _M_flags; }
# 692 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ios_base.h" 3
    fmtflags
    flags(fmtflags __fmtfl)
    {
      fmtflags __old = _M_flags;
      _M_flags = __fmtfl;
      return __old;
    }
# 708 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ios_base.h" 3
    fmtflags
    setf(fmtflags __fmtfl)
    {
      fmtflags __old = _M_flags;
      _M_flags |= __fmtfl;
      return __old;
    }
# 725 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ios_base.h" 3
    fmtflags
    setf(fmtflags __fmtfl, fmtflags __mask)
    {
      fmtflags __old = _M_flags;
      _M_flags &= ~__mask;
      _M_flags |= (__fmtfl & __mask);
      return __old;
    }







    void
    unsetf(fmtflags __mask)
    { _M_flags &= ~__mask; }
# 751 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ios_base.h" 3
    streamsize
    precision() const
    { return _M_precision; }






    streamsize
    precision(streamsize __prec)
    {
      streamsize __old = _M_precision;
      _M_precision = __prec;
      return __old;
    }







    streamsize
    width() const
    { return _M_width; }






    streamsize
    width(streamsize __wide)
    {
      streamsize __old = _M_width;
      _M_width = __wide;
      return __old;
    }
# 802 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ios_base.h" 3
    static bool
    sync_with_stdio(bool __sync = true);
# 814 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ios_base.h" 3
    locale
    imbue(const locale& __loc) throw();
# 825 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ios_base.h" 3
    locale
    getloc() const
    { return _M_ios_locale; }
# 836 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ios_base.h" 3
    const locale&
    _M_getloc() const
    { return _M_ios_locale; }
# 855 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ios_base.h" 3
    static int
    xalloc() throw();
# 871 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ios_base.h" 3
    long&
    iword(int __ix)
    {
      _Words& __word = ((unsigned)__ix < (unsigned)_M_word_size)
   ? _M_word[__ix] : _M_grow_words(__ix, true);
      return __word._M_iword;
    }
# 892 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ios_base.h" 3
    void*&
    pword(int __ix)
    {
      _Words& __word = ((unsigned)__ix < (unsigned)_M_word_size)
   ? _M_word[__ix] : _M_grow_words(__ix, false);
      return __word._M_pword;
    }
# 909 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ios_base.h" 3
    virtual ~ios_base();

  protected:
    ios_base() throw ();
# 923 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ios_base.h" 3
  public:
    ios_base(const ios_base&) = delete;

    ios_base&
    operator=(const ios_base&) = delete;

  protected:
    void
    _M_move(ios_base&) noexcept;

    void
    _M_swap(ios_base& __rhs) noexcept;

  };



  inline ios_base&
  boolalpha(ios_base& __base)
  {
    __base.setf(ios_base::boolalpha);
    return __base;
  }


  inline ios_base&
  noboolalpha(ios_base& __base)
  {
    __base.unsetf(ios_base::boolalpha);
    return __base;
  }


  inline ios_base&
  showbase(ios_base& __base)
  {
    __base.setf(ios_base::showbase);
    return __base;
  }


  inline ios_base&
  noshowbase(ios_base& __base)
  {
    __base.unsetf(ios_base::showbase);
    return __base;
  }


  inline ios_base&
  showpoint(ios_base& __base)
  {
    __base.setf(ios_base::showpoint);
    return __base;
  }


  inline ios_base&
  noshowpoint(ios_base& __base)
  {
    __base.unsetf(ios_base::showpoint);
    return __base;
  }


  inline ios_base&
  showpos(ios_base& __base)
  {
    __base.setf(ios_base::showpos);
    return __base;
  }


  inline ios_base&
  noshowpos(ios_base& __base)
  {
    __base.unsetf(ios_base::showpos);
    return __base;
  }


  inline ios_base&
  skipws(ios_base& __base)
  {
    __base.setf(ios_base::skipws);
    return __base;
  }


  inline ios_base&
  noskipws(ios_base& __base)
  {
    __base.unsetf(ios_base::skipws);
    return __base;
  }


  inline ios_base&
  uppercase(ios_base& __base)
  {
    __base.setf(ios_base::uppercase);
    return __base;
  }


  inline ios_base&
  nouppercase(ios_base& __base)
  {
    __base.unsetf(ios_base::uppercase);
    return __base;
  }


  inline ios_base&
  unitbuf(ios_base& __base)
  {
     __base.setf(ios_base::unitbuf);
     return __base;
  }


  inline ios_base&
  nounitbuf(ios_base& __base)
  {
     __base.unsetf(ios_base::unitbuf);
     return __base;
  }



  inline ios_base&
  internal(ios_base& __base)
  {
     __base.setf(ios_base::internal, ios_base::adjustfield);
     return __base;
  }


  inline ios_base&
  left(ios_base& __base)
  {
    __base.setf(ios_base::left, ios_base::adjustfield);
    return __base;
  }


  inline ios_base&
  right(ios_base& __base)
  {
    __base.setf(ios_base::right, ios_base::adjustfield);
    return __base;
  }



  inline ios_base&
  dec(ios_base& __base)
  {
    __base.setf(ios_base::dec, ios_base::basefield);
    return __base;
  }


  inline ios_base&
  hex(ios_base& __base)
  {
    __base.setf(ios_base::hex, ios_base::basefield);
    return __base;
  }


  inline ios_base&
  oct(ios_base& __base)
  {
    __base.setf(ios_base::oct, ios_base::basefield);
    return __base;
  }



  inline ios_base&
  fixed(ios_base& __base)
  {
    __base.setf(ios_base::fixed, ios_base::floatfield);
    return __base;
  }


  inline ios_base&
  scientific(ios_base& __base)
  {
    __base.setf(ios_base::scientific, ios_base::floatfield);
    return __base;
  }






  inline ios_base&
  hexfloat(ios_base& __base)
  {
    __base.setf(ios_base::fixed | ios_base::scientific, ios_base::floatfield);
    return __base;
  }


  inline ios_base&
  defaultfloat(ios_base& __base)
  {
    __base.unsetf(ios_base::floatfield);
    return __base;
  }



}
# 44 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/streambuf" 2 3



namespace std __attribute__ ((__visibility__ ("default")))
{




  template<typename _CharT, typename _Traits>
    streamsize
    __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>*,
     basic_streambuf<_CharT, _Traits>*, bool&);
# 123 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/streambuf" 3
  template<typename _CharT, typename _Traits>
    class basic_streambuf
    {
    public:






      typedef _CharT char_type;
      typedef _Traits traits_type;
      typedef typename traits_type::int_type int_type;
      typedef typename traits_type::pos_type pos_type;
      typedef typename traits_type::off_type off_type;




      typedef basic_streambuf<char_type, traits_type> __streambuf_type;


      friend class basic_ios<char_type, traits_type>;
      friend class basic_istream<char_type, traits_type>;
      friend class basic_ostream<char_type, traits_type>;
      friend class istreambuf_iterator<char_type, traits_type>;
      friend class ostreambuf_iterator<char_type, traits_type>;

      friend streamsize
      __copy_streambufs_eof<>(basic_streambuf*, basic_streambuf*, bool&);

      template<bool _IsMove, typename _CharT2>
        friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
            _CharT2*>::__type
        __copy_move_a2(istreambuf_iterator<_CharT2>,
         istreambuf_iterator<_CharT2>, _CharT2*);

      template<typename _CharT2>
        friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
      istreambuf_iterator<_CharT2> >::__type
        find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
      const _CharT2&);

      template<typename _CharT2, typename _Distance>
        friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
            void>::__type
        advance(istreambuf_iterator<_CharT2>&, _Distance);

      friend void __istream_extract(istream&, char*, streamsize);

      template<typename _CharT2, typename _Traits2, typename _Alloc>
        friend basic_istream<_CharT2, _Traits2>&
        operator>>(basic_istream<_CharT2, _Traits2>&,
     basic_string<_CharT2, _Traits2, _Alloc>&);

      template<typename _CharT2, typename _Traits2, typename _Alloc>
        friend basic_istream<_CharT2, _Traits2>&
        getline(basic_istream<_CharT2, _Traits2>&,
  basic_string<_CharT2, _Traits2, _Alloc>&, _CharT2);

    protected:







      char_type* _M_in_beg;
      char_type* _M_in_cur;
      char_type* _M_in_end;
      char_type* _M_out_beg;
      char_type* _M_out_cur;
      char_type* _M_out_end;


      locale _M_buf_locale;

  public:

      virtual
      ~basic_streambuf()
      { }
# 215 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/streambuf" 3
      locale
      pubimbue(const locale& __loc)
      {
 locale __tmp(this->getloc());
 this->imbue(__loc);
 _M_buf_locale = __loc;
 return __tmp;
      }
# 232 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/streambuf" 3
      locale
      getloc() const
      { return _M_buf_locale; }
# 245 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/streambuf" 3
      basic_streambuf*
      pubsetbuf(char_type* __s, streamsize __n)
      { return this->setbuf(__s, __n); }
# 257 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/streambuf" 3
      streamsize
      in_avail()
      {
 const streamsize __ret = this->egptr() - this->gptr();
 return __ret ? __ret : this->showmanyc();
      }
# 304 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/streambuf" 3
      streamsize
      sgetn(char_type* __s, streamsize __n)
      { return this->xsgetn(__s, __n); }
# 378 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/streambuf" 3
      streamsize
      sputn(const char_type* __s, streamsize __n)
      { return this->xsputn(__s, __n); }

    protected:
# 470 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/streambuf" 3
      void
      gbump(int __n) { _M_in_cur += __n; }
# 515 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/streambuf" 3
      void
      pbump(int __n) { _M_out_cur += __n; }
# 561 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/streambuf" 3
      void
      setp(char_type* __pbeg, char_type* __pend)
      {
 _M_out_beg = _M_out_cur = __pbeg;
 _M_out_end = __pend;
      }
# 582 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/streambuf" 3
      virtual void
      imbue(const locale& __loc __attribute__ ((__unused__)))
      { }
# 597 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/streambuf" 3
      virtual basic_streambuf<char_type,_Traits>*
      setbuf(char_type*, streamsize)
      { return this; }
# 608 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/streambuf" 3
      virtual int
      sync() { return 0; }
# 655 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/streambuf" 3
      virtual streamsize
      showmanyc() { return 0; }
# 671 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/streambuf" 3
      virtual streamsize
      xsgetn(char_type* __s, streamsize __n);
# 693 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/streambuf" 3
      virtual int_type
      underflow()
      { return traits_type::eof(); }
# 706 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/streambuf" 3
      virtual int_type
      pbackfail(int_type __c __attribute__ ((__unused__)) = traits_type::eof())
      { return traits_type::eof(); }
# 748 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/streambuf" 3
      virtual streamsize
      xsputn(const char_type* __s, streamsize __n);
# 774 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/streambuf" 3
      virtual int_type
      overflow(int_type __c __attribute__ ((__unused__)) = traits_type::eof())
      { return traits_type::eof(); }
# 801 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/streambuf" 3
      void
      __safe_gbump(streamsize __n) { _M_in_cur += __n; }

      void
      __safe_pbump(streamsize __n) { _M_out_cur += __n; }




    protected:

      basic_streambuf(const basic_streambuf&);

      basic_streambuf&
      operator=(const basic_streambuf&);


      void
      swap(basic_streambuf& __sb)
      {
 std::swap(_M_in_beg, __sb._M_in_beg);
 std::swap(_M_in_cur, __sb._M_in_cur);
 std::swap(_M_in_end, __sb._M_in_end);
 std::swap(_M_out_beg, __sb._M_out_beg);
 std::swap(_M_out_cur, __sb._M_out_cur);
 std::swap(_M_out_end, __sb._M_out_end);
 std::swap(_M_buf_locale, __sb._M_buf_locale);
      }

    };


  template<typename _CharT, typename _Traits>
    std::basic_streambuf<_CharT, _Traits>::
    basic_streambuf(const basic_streambuf&) = default;

  template<typename _CharT, typename _Traits>
    std::basic_streambuf<_CharT, _Traits>&
    std::basic_streambuf<_CharT, _Traits>::
    operator=(const basic_streambuf&) = default;



  template<>
    streamsize
    __copy_streambufs_eof(basic_streambuf<char>* __sbin,
     basic_streambuf<char>* __sbout, bool& __ineof);

  template<>
    streamsize
    __copy_streambufs_eof(basic_streambuf<wchar_t>* __sbin,
     basic_streambuf<wchar_t>* __sbout, bool& __ineof);





}

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/streambuf.tcc" 1 3
# 38 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/streambuf.tcc" 3

namespace std __attribute__ ((__visibility__ ("default")))
{


  template<typename _CharT, typename _Traits>
    streamsize
    basic_streambuf<_CharT, _Traits>::
    xsgetn(char_type* __s, streamsize __n)
    {
      streamsize __ret = 0;
      while (__ret < __n)
 {
   const streamsize __buf_len = this->egptr() - this->gptr();
   if (__buf_len)
     {
       const streamsize __remaining = __n - __ret;
       const streamsize __len = std::min(__buf_len, __remaining);
       traits_type::copy(__s, this->gptr(), __len);
       __ret += __len;
       __s += __len;
       this->__safe_gbump(__len);
     }

   if (__ret < __n)
     {
       const int_type __c = this->uflow();
       if (!traits_type::eq_int_type(__c, traits_type::eof()))
  {
    traits_type::assign(*__s++, traits_type::to_char_type(__c));
    ++__ret;
  }
       else
  break;
     }
 }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    streamsize
    basic_streambuf<_CharT, _Traits>::
    xsputn(const char_type* __s, streamsize __n)
    {
      streamsize __ret = 0;
      while (__ret < __n)
 {
   const streamsize __buf_len = this->epptr() - this->pptr();
   if (__buf_len)
     {
       const streamsize __remaining = __n - __ret;
       const streamsize __len = std::min(__buf_len, __remaining);
       traits_type::copy(this->pptr(), __s, __len);
       __ret += __len;
       __s += __len;
       this->__safe_pbump(__len);
     }

   if (__ret < __n)
     {
       int_type __c = this->overflow(traits_type::to_int_type(*__s));
       if (!traits_type::eq_int_type(__c, traits_type::eof()))
  {
    ++__ret;
    ++__s;
  }
       else
  break;
     }
 }
      return __ret;
    }




  template<typename _CharT, typename _Traits>
    streamsize
    __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>* __sbin,
     basic_streambuf<_CharT, _Traits>* __sbout,
     bool& __ineof)
    {
      streamsize __ret = 0;
      __ineof = true;
      typename _Traits::int_type __c = __sbin->sgetc();
      while (!_Traits::eq_int_type(__c, _Traits::eof()))
 {
   __c = __sbout->sputc(_Traits::to_char_type(__c));
   if (_Traits::eq_int_type(__c, _Traits::eof()))
     {
       __ineof = false;
       break;
     }
   ++__ret;
   __c = __sbin->snextc();
 }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    inline streamsize
    __copy_streambufs(basic_streambuf<_CharT, _Traits>* __sbin,
        basic_streambuf<_CharT, _Traits>* __sbout)
    {
      bool __ineof;
      return __copy_streambufs_eof(__sbin, __sbout, __ineof);
    }




  extern template class basic_streambuf<char>;

  extern template
    streamsize
    __copy_streambufs(basic_streambuf<char>*,
        basic_streambuf<char>*);


  extern template class basic_streambuf<wchar_t>;

  extern template
    streamsize
    __copy_streambufs(basic_streambuf<wchar_t>*,
        basic_streambuf<wchar_t>*);




}
# 861 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/streambuf" 2 3
# 36 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/streambuf_iterator.h" 2 3



namespace std __attribute__ ((__visibility__ ("default")))
{








#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"


  template<typename _CharT, typename _Traits>
    class istreambuf_iterator
    : public iterator<input_iterator_tag, _CharT, typename _Traits::off_type,
        _CharT*, _CharT>
    {
    public:
# 67 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/streambuf_iterator.h" 3
      using pointer = void;


      typedef _CharT char_type;
      typedef _Traits traits_type;
      typedef typename _Traits::int_type int_type;
      typedef basic_streambuf<_CharT, _Traits> streambuf_type;
      typedef basic_istream<_CharT, _Traits> istream_type;


      template<typename _CharT2>
 friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
        ostreambuf_iterator<_CharT2> >::__type
 copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
      ostreambuf_iterator<_CharT2>);

      template<bool _IsMove, typename _CharT2>
 friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
            _CharT2*>::__type
 __copy_move_a2(istreambuf_iterator<_CharT2>,
         istreambuf_iterator<_CharT2>, _CharT2*);

      template<typename _CharT2, typename _Size>
 friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
            _CharT2*>::__type
 __copy_n_a(istreambuf_iterator<_CharT2>, _Size, _CharT2*, bool);

      template<typename _CharT2>
 friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
        istreambuf_iterator<_CharT2> >::__type
 find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
      const _CharT2&);

      template<typename _CharT2, typename _Distance>
 friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
            void>::__type
 advance(istreambuf_iterator<_CharT2>&, _Distance);

    private:







      mutable streambuf_type* _M_sbuf;
      int_type _M_c;

    public:

      constexpr istreambuf_iterator() noexcept
      : _M_sbuf(0), _M_c(traits_type::eof()) { }


      constexpr istreambuf_iterator(default_sentinel_t) noexcept
      : istreambuf_iterator() { }



      istreambuf_iterator(const istreambuf_iterator&) noexcept = default;

      ~istreambuf_iterator() = default;



      istreambuf_iterator(istream_type& __s) noexcept
      : _M_sbuf(__s.rdbuf()), _M_c(traits_type::eof()) { }


      istreambuf_iterator(streambuf_type* __s) noexcept
      : _M_sbuf(__s), _M_c(traits_type::eof()) { }


      istreambuf_iterator&
      operator=(const istreambuf_iterator&) noexcept = default;





      [[__nodiscard__]]
      char_type
      operator*() const
      {
 int_type __c = _M_get();
# 161 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/streambuf_iterator.h" 3
 return traits_type::to_char_type(__c);
      }


      istreambuf_iterator&
      operator++()
      {



                        ;

 _M_sbuf->sbumpc();
 _M_c = traits_type::eof();
 return *this;
      }


      istreambuf_iterator
      operator++(int)
      {



                        ;

 istreambuf_iterator __old = *this;
 __old._M_c = _M_sbuf->sbumpc();
 _M_c = traits_type::eof();
 return __old;
      }





      [[__nodiscard__]]
      bool
      equal(const istreambuf_iterator& __b) const
      { return _M_at_eof() == __b._M_at_eof(); }

    private:
      int_type
      _M_get() const
      {
 int_type __ret = _M_c;
 if (_M_sbuf && _S_is_eof(__ret) && _S_is_eof(__ret = _M_sbuf->sgetc()))
   _M_sbuf = 0;
 return __ret;
      }

      bool
      _M_at_eof() const
      { return _S_is_eof(_M_get()); }

      static bool
      _S_is_eof(int_type __c)
      {
 const int_type __eof = traits_type::eof();
 return traits_type::eq_int_type(__c, __eof);
      }


      [[nodiscard]]
      friend bool
      operator==(const istreambuf_iterator& __i, default_sentinel_t)
      { return __i._M_at_eof(); }

    };

  template<typename _CharT, typename _Traits>
    [[__nodiscard__]]
    inline bool
    operator==(const istreambuf_iterator<_CharT, _Traits>& __a,
        const istreambuf_iterator<_CharT, _Traits>& __b)
    { return __a.equal(__b); }
# 248 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/streambuf_iterator.h" 3
  template<typename _CharT, typename _Traits>
    class ostreambuf_iterator
    : public iterator<output_iterator_tag, void, void, void, void>
    {
    public:




      using difference_type = ptrdiff_t;

      typedef _CharT char_type;
      typedef _Traits traits_type;
      typedef basic_streambuf<_CharT, _Traits> streambuf_type;
      typedef basic_ostream<_CharT, _Traits> ostream_type;


      template<typename _CharT2>
 friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value,
        ostreambuf_iterator<_CharT2> >::__type
 copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>,
      ostreambuf_iterator<_CharT2>);

    private:
      streambuf_type* _M_sbuf;
      bool _M_failed;

    public:


      constexpr
      ostreambuf_iterator() noexcept
      : _M_sbuf(nullptr), _M_failed(true) { }



      ostreambuf_iterator(ostream_type& __s) noexcept
      : _M_sbuf(__s.rdbuf()), _M_failed(!_M_sbuf) { }


      ostreambuf_iterator(streambuf_type* __s) noexcept
      : _M_sbuf(__s), _M_failed(!_M_sbuf) { }


      ostreambuf_iterator&
      operator=(_CharT __c)
      {
 if (!_M_failed &&
     _Traits::eq_int_type(_M_sbuf->sputc(__c), _Traits::eof()))
   _M_failed = true;
 return *this;
      }


      [[__nodiscard__]]
      ostreambuf_iterator&
      operator*()
      { return *this; }


      ostreambuf_iterator&
      operator++(int)
      { return *this; }


      ostreambuf_iterator&
      operator++()
      { return *this; }


      [[__nodiscard__]]
      bool
      failed() const noexcept
      { return _M_failed; }

      ostreambuf_iterator&
      _M_put(const _CharT* __ws, streamsize __len)
      {
 if (__builtin_expect(!_M_failed, true)
     && __builtin_expect(this->_M_sbuf->sputn(__ws, __len) != __len,
    false))
   _M_failed = true;
 return *this;
      }
    };
#pragma GCC diagnostic pop


  template<typename _CharT>
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
        ostreambuf_iterator<_CharT> >::__type
    copy(istreambuf_iterator<_CharT> __first,
  istreambuf_iterator<_CharT> __last,
  ostreambuf_iterator<_CharT> __result)
    {
      if (__first._M_sbuf && !__last._M_sbuf && !__result._M_failed)
 {
   bool __ineof;
   __copy_streambufs_eof(__first._M_sbuf, __result._M_sbuf, __ineof);
   if (!__ineof)
     __result._M_failed = true;
 }
      return __result;
    }

  template<bool _IsMove, typename _CharT>
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
        ostreambuf_iterator<_CharT> >::__type
    __copy_move_a2(_CharT* __first, _CharT* __last,
     ostreambuf_iterator<_CharT> __result)
    {
      const streamsize __num = __last - __first;
      if (__num > 0)
 __result._M_put(__first, __num);
      return __result;
    }

  template<bool _IsMove, typename _CharT>
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
        ostreambuf_iterator<_CharT> >::__type
    __copy_move_a2(const _CharT* __first, const _CharT* __last,
     ostreambuf_iterator<_CharT> __result)
    {
      const streamsize __num = __last - __first;
      if (__num > 0)
 __result._M_put(__first, __num);
      return __result;
    }

  template<bool _IsMove, typename _CharT>
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
        _CharT*>::__type
    __copy_move_a2(istreambuf_iterator<_CharT> __first,
     istreambuf_iterator<_CharT> __last, _CharT* __result)
    {
      typedef istreambuf_iterator<_CharT> __is_iterator_type;
      typedef typename __is_iterator_type::traits_type traits_type;
      typedef typename __is_iterator_type::streambuf_type streambuf_type;
      typedef typename traits_type::int_type int_type;

      if (__first._M_sbuf && !__last._M_sbuf)
 {
   streambuf_type* __sb = __first._M_sbuf;
   int_type __c = __sb->sgetc();
   while (!traits_type::eq_int_type(__c, traits_type::eof()))
     {
       const streamsize __n = __sb->egptr() - __sb->gptr();
       if (__n > 1)
  {
    traits_type::copy(__result, __sb->gptr(), __n);
    __sb->__safe_gbump(__n);
    __result += __n;
    __c = __sb->underflow();
  }
       else
  {
    *__result++ = traits_type::to_char_type(__c);
    __c = __sb->snextc();
  }
     }
 }
      return __result;
    }

  template<typename _CharT, typename _Size>
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
        _CharT*>::__type
    __copy_n_a(istreambuf_iterator<_CharT> __it, _Size __n, _CharT* __result,
        bool __strict __attribute__((__unused__)))
    {
      if (__n == 0)
 return __result;



                            ;
      _CharT* __beg = __result;
      __result += __it._M_sbuf->sgetn(__beg, __n);


                            ;
      return __result;
    }

  template<typename _CharT>
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
          istreambuf_iterator<_CharT> >::__type
    find(istreambuf_iterator<_CharT> __first,
  istreambuf_iterator<_CharT> __last, const _CharT& __val)
    {
      typedef istreambuf_iterator<_CharT> __is_iterator_type;
      typedef typename __is_iterator_type::traits_type traits_type;
      typedef typename __is_iterator_type::streambuf_type streambuf_type;
      typedef typename traits_type::int_type int_type;
      const int_type __eof = traits_type::eof();

      if (__first._M_sbuf && !__last._M_sbuf)
 {
   const int_type __ival = traits_type::to_int_type(__val);
   streambuf_type* __sb = __first._M_sbuf;
   int_type __c = __sb->sgetc();
   while (!traits_type::eq_int_type(__c, __eof)
   && !traits_type::eq_int_type(__c, __ival))
     {
       streamsize __n = __sb->egptr() - __sb->gptr();
       if (__n > 1)
  {
    const _CharT* __p = traits_type::find(__sb->gptr(),
       __n, __val);
    if (__p)
      __n = __p - __sb->gptr();
    __sb->__safe_gbump(__n);
    __c = __sb->sgetc();
  }
       else
  __c = __sb->snextc();
     }

   __first._M_c = __eof;
 }

      return __first;
    }

  template<typename _CharT, typename _Distance>
    typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value,
        void>::__type
    advance(istreambuf_iterator<_CharT>& __i, _Distance __n)
    {
      if (__n == 0)
 return;

      do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__n > 0), false)) std::__glibcxx_assert_fail(); } while (false);


                           ;

      typedef istreambuf_iterator<_CharT> __is_iterator_type;
      typedef typename __is_iterator_type::traits_type traits_type;
      typedef typename __is_iterator_type::streambuf_type streambuf_type;
      typedef typename traits_type::int_type int_type;
      const int_type __eof = traits_type::eof();

      streambuf_type* __sb = __i._M_sbuf;
      while (__n > 0)
 {
   streamsize __size = __sb->egptr() - __sb->gptr();
   if (__size > __n)
     {
       __sb->__safe_gbump(__n);
       break;
     }

   __sb->__safe_gbump(__size);
   __n -= __size;
   if (traits_type::eq_int_type(__sb->underflow(), __eof))
     {


                      ;
       break;
     }
 }

      __i._M_c = __eof;
    }




}
# 67 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/iterator" 2 3
# 78 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/iterator" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 79 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/iterator" 2 3
# 28 "/usr/include/boost/move/detail/iterator_traits.hpp" 2 3 4



namespace boost {
namespace movelib {

   using std::iterator_traits;

   template<class T>
   struct iter_difference
   {
      typedef typename std::iterator_traits<T>::difference_type type;
   };

   template<class T>
   struct iter_value
   {
      typedef typename std::iterator_traits<T>::value_type type;
   };

   template<class T>
   struct iter_category
   {
      typedef typename std::iterator_traits<T>::iterator_category type;
   };

}}
# 166 "/usr/include/boost/move/detail/iterator_traits.hpp" 3 4
namespace boost {
namespace movelib {

template<class T>
struct iter_size
   : boost::move_detail::
      make_unsigned<typename iter_difference<T>::type >
{};

}}
# 26 "/usr/include/boost/move/detail/reverse_iterator.hpp" 2 3 4


namespace boost {
namespace movelib {

template<class I>
inline __attribute__ ((__always_inline__)) typename iterator_traits<I>::pointer iterator_arrow_result(const I &i)
{ return i.operator->(); }

template<class T>
inline __attribute__ ((__always_inline__)) T * iterator_arrow_result(T *p)
{ return p; }

template<class It>
class reverse_iterator
{
   public:
   typedef typename boost::movelib::iterator_traits<It>::pointer pointer;
   typedef typename boost::movelib::iterator_traits<It>::reference reference;
   typedef typename boost::movelib::iterator_traits<It>::difference_type difference_type;
   typedef typename boost::movelib::iterator_traits<It>::iterator_category iterator_category;
   typedef typename boost::movelib::iterator_traits<It>::value_type value_type;


   typedef It iterator_type;

   inline __attribute__ ((__always_inline__)) reverse_iterator()
      : m_current()
   {}

   inline __attribute__ ((__always_inline__)) explicit reverse_iterator(It r)
      : m_current(r)
   {}

   inline __attribute__ ((__always_inline__)) reverse_iterator(const reverse_iterator& r)
      : m_current(r.base())
   {}

   template<class OtherIt>
   inline __attribute__ ((__always_inline__))
      reverse_iterator( const reverse_iterator<OtherIt>& r
                      , typename boost::move_detail::enable_if_convertible<OtherIt, It>::type* =0
                   )
      : m_current(r.base())
   {}

   inline __attribute__ ((__always_inline__)) reverse_iterator & operator=( const reverse_iterator& r)
   { m_current = r.base(); return *this; }

   template<class OtherIt>
   inline __attribute__ ((__always_inline__)) typename boost::move_detail::enable_if_convertible<OtherIt, It, reverse_iterator &>::type
         operator=( const reverse_iterator<OtherIt>& r)
   { m_current = r.base(); return *this; }

   inline __attribute__ ((__always_inline__)) It base() const
   { return m_current; }

   inline __attribute__ ((__always_inline__)) reference operator*() const
   {
      It temp(m_current);
      --temp;
      reference r = *temp;
      return r;
   }

   inline __attribute__ ((__always_inline__)) pointer operator->() const
   {
      It temp(m_current);
      --temp;
      return (iterator_arrow_result)(temp);
   }

   inline __attribute__ ((__always_inline__)) reference operator[](difference_type off) const
   {
      return this->m_current[difference_type(-off - 1)];
   }

   inline __attribute__ ((__always_inline__)) reverse_iterator& operator++()
   {
      --m_current;
      return *this;
   }

   inline __attribute__ ((__always_inline__)) reverse_iterator operator++(int)
   {
      reverse_iterator temp((*this));
      --m_current;
      return temp;
   }

   inline __attribute__ ((__always_inline__)) reverse_iterator& operator--()
   {
      ++m_current;
      return *this;
   }

   inline __attribute__ ((__always_inline__)) reverse_iterator operator--(int)
   {
      reverse_iterator temp((*this));
      ++m_current;
      return temp;
   }

   inline __attribute__ ((__always_inline__)) friend bool operator==(const reverse_iterator& l, const reverse_iterator& r)
   { return l.m_current == r.m_current; }

   inline __attribute__ ((__always_inline__)) friend bool operator!=(const reverse_iterator& l, const reverse_iterator& r)
   { return l.m_current != r.m_current; }

   inline __attribute__ ((__always_inline__)) friend bool operator<(const reverse_iterator& l, const reverse_iterator& r)
   { return l.m_current > r.m_current; }

   inline __attribute__ ((__always_inline__)) friend bool operator<=(const reverse_iterator& l, const reverse_iterator& r)
   { return l.m_current >= r.m_current; }

   inline __attribute__ ((__always_inline__)) friend bool operator>(const reverse_iterator& l, const reverse_iterator& r)
   { return l.m_current < r.m_current; }

   inline __attribute__ ((__always_inline__)) friend bool operator>=(const reverse_iterator& l, const reverse_iterator& r)
   { return l.m_current <= r.m_current; }

   inline __attribute__ ((__always_inline__)) reverse_iterator& operator+=(difference_type off)
   { m_current -= off; return *this; }

   inline __attribute__ ((__always_inline__)) reverse_iterator& operator-=(difference_type off)
   { m_current += off; return *this; }

   inline __attribute__ ((__always_inline__)) friend reverse_iterator operator+(reverse_iterator l, difference_type off)
   { return (l += off); }

   inline __attribute__ ((__always_inline__)) friend reverse_iterator operator+(difference_type off, reverse_iterator r)
   { return (r += off); }

   inline __attribute__ ((__always_inline__)) friend reverse_iterator operator-(reverse_iterator l, difference_type off)
   { return (l-= off); }

   inline __attribute__ ((__always_inline__)) friend difference_type operator-(const reverse_iterator& l, const reverse_iterator& r)
   { return r.m_current - l.m_current; }

   private:
   It m_current;
};

template< class Iterator >
inline __attribute__ ((__always_inline__)) reverse_iterator<Iterator> make_reverse_iterator( Iterator i )
{ return reverse_iterator<Iterator>(i); }

}
}

# 1 "/usr/include/boost/move/detail/config_end.hpp" 1 3 4
# 177 "/usr/include/boost/move/detail/reverse_iterator.hpp" 2 3 4
# 17 "/usr/include/boost/intrusive/detail/reverse_iterator.hpp" 2 3 4

namespace boost {
namespace intrusive {

using boost::movelib::reverse_iterator;
using boost::movelib::make_reverse_iterator;

}
}
# 29 "/usr/include/boost/intrusive/list.hpp" 2 3 4
# 1 "/usr/include/boost/intrusive/detail/uncast.hpp" 1 3 4
# 24 "/usr/include/boost/intrusive/detail/uncast.hpp" 3 4
# 1 "/usr/include/boost/intrusive/detail/config_begin.hpp" 1 3 4
# 25 "/usr/include/boost/intrusive/detail/uncast.hpp" 2 3 4



namespace boost {
namespace intrusive {
namespace detail {

template<class ConstNodePtr>
struct uncast_types
{
   typedef typename pointer_traits<ConstNodePtr>::element_type element_type;
   typedef typename remove_const<element_type>::type non_const_type;
   typedef typename pointer_traits<ConstNodePtr>::
      template rebind_pointer<non_const_type>::type non_const_pointer;
   typedef pointer_traits<non_const_pointer> non_const_traits;
};

template<class ConstNodePtr>
static typename uncast_types<ConstNodePtr>::non_const_pointer
   uncast(const ConstNodePtr & ptr)
{
   return uncast_types<ConstNodePtr>::non_const_traits::const_cast_from(ptr);
}

}
}
}

# 1 "/usr/include/boost/intrusive/detail/config_end.hpp" 1 3 4
# 54 "/usr/include/boost/intrusive/detail/uncast.hpp" 2 3 4
# 30 "/usr/include/boost/intrusive/list.hpp" 2 3 4
# 1 "/usr/include/boost/intrusive/detail/list_iterator.hpp" 1 3 4
# 26 "/usr/include/boost/intrusive/detail/list_iterator.hpp" 3 4
# 1 "/usr/include/boost/intrusive/detail/std_fwd.hpp" 1 3 4
# 26 "/usr/include/boost/intrusive/detail/std_fwd.hpp" 3 4
# 1 "/usr/include/boost/move/detail/std_ns_begin.hpp" 1 3 4
# 27 "/usr/include/boost/intrusive/detail/std_fwd.hpp" 2 3 4
namespace std __attribute__ ((__visibility__ ("default"))) {

template<class T>
struct less;

template<class T>
struct equal_to;

struct input_iterator_tag;
struct forward_iterator_tag;
struct bidirectional_iterator_tag;
struct random_access_iterator_tag;

 }
# 1 "/usr/include/boost/move/detail/std_ns_end.hpp" 1 3 4
# 42 "/usr/include/boost/intrusive/detail/std_fwd.hpp" 2 3 4
# 27 "/usr/include/boost/intrusive/detail/list_iterator.hpp" 2 3 4
# 1 "/usr/include/boost/intrusive/detail/iiterator.hpp" 1 3 4
# 25 "/usr/include/boost/intrusive/detail/iiterator.hpp" 3 4
# 1 "/usr/include/boost/intrusive/detail/iterator.hpp" 1 3 4
# 30 "/usr/include/boost/intrusive/detail/iterator.hpp" 3 4
namespace boost{
namespace iterators{

struct incrementable_traversal_tag;
struct single_pass_traversal_tag;
struct forward_traversal_tag;
struct bidirectional_traversal_tag;
struct random_access_traversal_tag;

namespace detail{

template <class Category, class Traversal>
struct iterator_category_with_traversal;

}
}
}

namespace boost {
namespace intrusive {

using boost::movelib::iterator_traits;
using boost::movelib::iter_difference;
using boost::movelib::iter_value;
using boost::movelib::iter_category;
using boost::movelib::iter_size;





template<class Category, class T, class Difference, class Pointer, class Reference>
struct iterator
{
   typedef Category iterator_category;
   typedef T value_type;
   typedef Difference difference_type;
   typedef Pointer pointer;
   typedef Reference reference;
};





template<class Tag>
struct get_std_category_from_tag
{
   typedef Tag type;
};

template <class Category>
struct get_std_category_from_tag
   <boost::iterators::detail::iterator_category_with_traversal
      <Category, boost::iterators::incrementable_traversal_tag> >
{
   typedef std::input_iterator_tag type;
};

template <class Category>
struct get_std_category_from_tag
   <boost::iterators::detail::iterator_category_with_traversal
      <Category, boost::iterators::single_pass_traversal_tag> >
{
   typedef std::input_iterator_tag type;
};

template <class Category>
struct get_std_category_from_tag
   <boost::iterators::detail::iterator_category_with_traversal
      <Category, boost::iterators::forward_traversal_tag> >
{
   typedef std::input_iterator_tag type;
};

template <class Category>
struct get_std_category_from_tag
   <boost::iterators::detail::iterator_category_with_traversal
      <Category, boost::iterators::bidirectional_traversal_tag> >
{
   typedef std::bidirectional_iterator_tag type;
};

template <class Category>
struct get_std_category_from_tag
   <boost::iterators::detail::iterator_category_with_traversal
      <Category, boost::iterators::random_access_traversal_tag> >
{
   typedef std::random_access_iterator_tag type;
};

template<class It>
struct get_std_category_from_it
   : get_std_category_from_tag< typename boost::intrusive::iter_category<It>::type >
{};




template<class I, class Tag, class R = void>
struct iterator_enable_if_tag
   : ::boost::move_detail::enable_if_c
      < ::boost::move_detail::is_same
         < typename get_std_category_from_it<I>::type
         , Tag
         >::value
         , R>
{};

template<class I, class Tag, class R = void>
struct iterator_disable_if_tag
   : ::boost::move_detail::enable_if_c
      < !::boost::move_detail::is_same
         < typename get_std_category_from_it<I>::type
         , Tag
         >::value
         , R>
{};




template<class I, class Tag, class Tag2, class R = void>
struct iterator_enable_if_convertible_tag
   : ::boost::move_detail::enable_if_c
      < ::boost::move_detail::is_same_or_convertible
         < typename get_std_category_from_it<I>::type
         , Tag
         >::value &&
        !::boost::move_detail::is_same_or_convertible
         < typename get_std_category_from_it<I>::type
         , Tag2
         >::value
         , R>
{};




template<class I, class Tag>
struct iterator_enable_if_tag_difference_type
   : iterator_enable_if_tag<I, Tag, typename boost::intrusive::iter_difference<I>::type>
{};

template<class I, class Tag>
struct iterator_disable_if_tag_difference_type
   : iterator_disable_if_tag<I, Tag, typename boost::intrusive::iter_difference<I>::type>
{};





template<class InputIt>
inline __attribute__ ((__always_inline__)) typename iterator_enable_if_tag<InputIt, std::input_iterator_tag>::type
   iterator_advance(InputIt& it, typename iter_difference<InputIt>::type n)
{
   while(n--)
      ++it;
}

template<class InputIt>
typename iterator_enable_if_tag<InputIt, std::forward_iterator_tag>::type
   iterator_advance(InputIt& it, typename iter_difference<InputIt>::type n)
{
   while(n--)
      ++it;
}

template<class InputIt>
inline __attribute__ ((__always_inline__)) typename iterator_enable_if_tag<InputIt, std::bidirectional_iterator_tag>::type
   iterator_advance(InputIt& it, typename iter_difference<InputIt>::type n)
{
   for (; 0 < n; --n)
      ++it;
   for (; n < 0; ++n)
      --it;
}

template<class InputIt, class Distance>
inline __attribute__ ((__always_inline__)) typename iterator_enable_if_tag<InputIt, std::random_access_iterator_tag>::type
   iterator_advance(InputIt& it, Distance n)
{
   it += n;
}

template<class InputIt, class Distance>
inline __attribute__ ((__always_inline__)) typename iterator_enable_if_tag<InputIt, std::random_access_iterator_tag, InputIt>::type
   make_iterator_advance(InputIt it, Distance n)
{
   (iterator_advance)(it, n);
   return it;
}

template<class It>
inline __attribute__ ((__always_inline__))
   void iterator_uadvance(It& it, typename iter_size<It>::type n)
{
   (iterator_advance)(it, (typename iterator_traits<It>::difference_type)n);
}

template<class It>
inline __attribute__ ((__always_inline__))
It make_iterator_uadvance(It it, typename iter_size<It>::type n)
{
   (iterator_uadvance)(it, n);
   return it;
}




template<class InputIt> inline
typename iterator_disable_if_tag_difference_type
   <InputIt, std::random_access_iterator_tag>::type
      iterator_distance(InputIt first, InputIt last)
{
   typename iter_difference<InputIt>::type off = 0;
   while(first != last){
      ++off;
      ++first;
   }
   return off;
}

template<class InputIt>
inline __attribute__ ((__always_inline__)) typename iterator_enable_if_tag_difference_type
   <InputIt, std::random_access_iterator_tag>::type
      iterator_distance(InputIt first, InputIt last)
{
   typename iter_difference<InputIt>::type off = last - first;
   return off;
}





template<class It>
inline __attribute__ ((__always_inline__)) typename iter_size<It>::type
   iterator_udistance(It first, It last)
{
   return (typename iter_size<It>::type)(iterator_distance)(first, last);
}





template<class InputIt>
inline __attribute__ ((__always_inline__)) InputIt iterator_next(InputIt it, typename iter_difference<InputIt>::type n)
{
   (iterator_advance)(it, n);
   return it;
}

template<class InputIt>
inline __attribute__ ((__always_inline__)) InputIt iterator_unext(InputIt it, typename iterator_traits<InputIt>::size_type n)
{
   (iterator_uadvance)(it, n);
   return it;
}





template<class I>
inline __attribute__ ((__always_inline__)) typename iterator_traits<I>::pointer iterator_arrow_result(const I &i)
{ return i.operator->(); }

template<class T>
inline __attribute__ ((__always_inline__)) T * iterator_arrow_result(T *p)
{ return p; }

}
}
# 26 "/usr/include/boost/intrusive/detail/iiterator.hpp" 2 3 4




namespace boost {
namespace intrusive {

template<class ValueTraits>
struct value_traits_pointers
{
   typedef typename boost::intrusive::detail:: boost_intrusive_default_type_value_traits_ptr< ValueTraits, typename boost::intrusive::pointer_traits<typename ValueTraits::node_traits::node_ptr>::template rebind_pointer<ValueTraits>::type >::type value_traits_ptr;





   typedef typename boost::intrusive::pointer_traits<value_traits_ptr>::template
      rebind_pointer<ValueTraits const>::type const_value_traits_ptr;
};

template<class ValueTraits, bool IsConst, class Category>
struct iiterator
{
   typedef ValueTraits value_traits;
   typedef typename value_traits::node_traits node_traits;
   typedef typename node_traits::node node;
   typedef typename node_traits::node_ptr node_ptr;
   typedef ::boost::intrusive::pointer_traits<node_ptr> nodepointer_traits_t;
   typedef typename nodepointer_traits_t::template
      rebind_pointer<void>::type void_pointer;
   typedef typename ValueTraits::value_type value_type;
   typedef typename ValueTraits::pointer nonconst_pointer;
   typedef typename ValueTraits::const_pointer yesconst_pointer;
   typedef typename ::boost::intrusive::pointer_traits
      <nonconst_pointer>::reference nonconst_reference;
   typedef typename ::boost::intrusive::pointer_traits
      <yesconst_pointer>::reference yesconst_reference;
   typedef typename nodepointer_traits_t::difference_type difference_type;
   typedef typename detail::if_c
      <IsConst, yesconst_pointer, nonconst_pointer>::type pointer;
   typedef typename detail::if_c
      <IsConst, yesconst_reference, nonconst_reference>::type reference;
   typedef iterator
         < Category
         , value_type
         , difference_type
         , pointer
         , reference
         > iterator_type;
   typedef typename value_traits_pointers
      <ValueTraits>::value_traits_ptr value_traits_ptr;
   typedef typename value_traits_pointers
      <ValueTraits>::const_value_traits_ptr const_value_traits_ptr;
   static const bool stateful_value_traits =
      detail::is_stateful_value_traits<value_traits>::value;
};

template<class NodePtr, class StoredPointer, bool StatefulValueTraits = true>
struct iiterator_members
{

   inline __attribute__ ((__always_inline__)) iiterator_members()
      : nodeptr_()
   {}

   inline __attribute__ ((__always_inline__)) iiterator_members(const NodePtr &n_ptr, const StoredPointer &data)
      : nodeptr_(n_ptr), ptr_(data)
   {}

   inline __attribute__ ((__always_inline__)) StoredPointer get_ptr() const
   { return ptr_; }

   NodePtr nodeptr_;
   StoredPointer ptr_;
};

template<class NodePtr, class StoredPointer>
struct iiterator_members<NodePtr, StoredPointer, false>
{
   inline __attribute__ ((__always_inline__)) iiterator_members()
      : nodeptr_()
   {}

   inline __attribute__ ((__always_inline__)) iiterator_members(const NodePtr &n_ptr, const StoredPointer &)
      : nodeptr_(n_ptr)
   {}

   inline __attribute__ ((__always_inline__)) StoredPointer get_ptr() const
   { return StoredPointer(); }

   NodePtr nodeptr_;
};

}
}
# 28 "/usr/include/boost/intrusive/detail/list_iterator.hpp" 2 3 4


namespace boost {
namespace intrusive {



template<class ValueTraits, bool IsConst>
class list_iterator
{
   private:
   typedef iiterator
      <ValueTraits, IsConst, std::bidirectional_iterator_tag> types_t;

   static const bool stateful_value_traits = types_t::stateful_value_traits;

   typedef ValueTraits value_traits;
   typedef typename types_t::node_traits node_traits;

   typedef typename types_t::node node;
   typedef typename types_t::node_ptr node_ptr;
   typedef typename types_t::const_value_traits_ptr const_value_traits_ptr;
   class nat;
   typedef typename
      detail::if_c< IsConst
                  , list_iterator<value_traits, false>
                  , nat>::type nonconst_iterator;

   public:
   typedef typename types_t::iterator_type::difference_type difference_type;
   typedef typename types_t::iterator_type::value_type value_type;
   typedef typename types_t::iterator_type::pointer pointer;
   typedef typename types_t::iterator_type::reference reference;
   typedef typename types_t::iterator_type::iterator_category iterator_category;

   inline __attribute__ ((__always_inline__)) list_iterator()
   {}

   inline __attribute__ ((__always_inline__)) explicit list_iterator(node_ptr nodeptr, const_value_traits_ptr traits_ptr)
      : members_(nodeptr, traits_ptr)
   {}

   inline __attribute__ ((__always_inline__)) list_iterator(const list_iterator &other)
      : members_(other.pointed_node(), other.get_value_traits())
   {}

   inline __attribute__ ((__always_inline__)) list_iterator(const nonconst_iterator &other)
      : members_(other.pointed_node(), other.get_value_traits())
   {}

   inline __attribute__ ((__always_inline__)) list_iterator &operator=(const list_iterator &other)
   { members_.nodeptr_ = other.members_.nodeptr_; return *this; }

   inline __attribute__ ((__always_inline__)) node_ptr pointed_node() const
   { return members_.nodeptr_; }

   inline __attribute__ ((__always_inline__)) list_iterator &operator=(node_ptr nodeptr)
   { members_.nodeptr_ = nodeptr; return *this; }

   inline __attribute__ ((__always_inline__)) const_value_traits_ptr get_value_traits() const
   { return members_.get_ptr(); }

   public:
   inline __attribute__ ((__always_inline__)) list_iterator& operator++()
   {
      node_ptr p = node_traits::get_next(members_.nodeptr_);
      members_.nodeptr_ = p;
      return static_cast<list_iterator&> (*this);
   }

   inline __attribute__ ((__always_inline__)) list_iterator operator++(int)
   {
      list_iterator result (*this);
      members_.nodeptr_ = node_traits::get_next(members_.nodeptr_);
      return result;
   }

   inline __attribute__ ((__always_inline__)) list_iterator& operator--()
   {
      members_.nodeptr_ = node_traits::get_previous(members_.nodeptr_);
      return static_cast<list_iterator&> (*this);
   }

   inline __attribute__ ((__always_inline__)) list_iterator operator--(int)
   {
      list_iterator result (*this);
      members_.nodeptr_ = node_traits::get_previous(members_.nodeptr_);
      return result;
   }

   inline __attribute__ ((__always_inline__)) friend bool operator== (const list_iterator& l, const list_iterator& r)
   { return l.pointed_node() == r.pointed_node(); }

   inline __attribute__ ((__always_inline__)) friend bool operator!= (const list_iterator& l, const list_iterator& r)
   { return !(l == r); }

   inline __attribute__ ((__always_inline__)) reference operator*() const
   { return *operator->(); }

   inline __attribute__ ((__always_inline__)) pointer operator->() const
   { return this->operator_arrow(detail::bool_<stateful_value_traits>()); }

   inline __attribute__ ((__always_inline__)) list_iterator<ValueTraits, false> unconst() const
   { return list_iterator<ValueTraits, false>(this->pointed_node(), this->get_value_traits()); }

   private:
   inline __attribute__ ((__always_inline__)) pointer operator_arrow(detail::false_) const
   { return ValueTraits::to_value_ptr(members_.nodeptr_); }

   inline __attribute__ ((__always_inline__)) pointer operator_arrow(detail::true_) const
   { return this->get_value_traits()->to_value_ptr(members_.nodeptr_); }

   iiterator_members<node_ptr, const_value_traits_ptr, stateful_value_traits> members_;
};

}
}
# 31 "/usr/include/boost/intrusive/list.hpp" 2 3 4
# 1 "/usr/include/boost/intrusive/detail/array_initializer.hpp" 1 3 4
# 26 "/usr/include/boost/intrusive/detail/array_initializer.hpp" 3 4
# 1 "/usr/include/boost/move/detail/placement_new.hpp" 1 3 4
# 21 "/usr/include/boost/move/detail/placement_new.hpp" 3 4
struct boost_move_new_t{};


inline void *operator new(std::size_t, void *p, boost_move_new_t)
{ return p; }

inline void operator delete(void *, void *, boost_move_new_t)
{}
# 27 "/usr/include/boost/intrusive/detail/array_initializer.hpp" 2 3 4
# 1 "/usr/include/boost/move/detail/force_ptr.hpp" 1 3 4
# 23 "/usr/include/boost/move/detail/force_ptr.hpp" 3 4
namespace boost {
namespace move_detail {


template <typename T>
inline __attribute__ ((__always_inline__)) T force_ptr(const volatile void *p)
{
   return static_cast<T>(const_cast<void*>(p));
}

}
}
# 28 "/usr/include/boost/intrusive/detail/array_initializer.hpp" 2 3 4

namespace boost {
namespace intrusive {
namespace detail {


union max_align
{
   char char_;
   short short_;
   int int_;
   long long_;

   ::boost::long_long_type long_long_;

   float float_;
   double double_;
   long double long_double_;
   void * void_ptr_;
};

template<class T, std::size_t N>
class array_initializer
{
   public:
   template<class CommonInitializer>
   array_initializer(const CommonInitializer &init)
   {
      char *init_buf = (char*)rawbuf;
      std::size_t i = 0;
      { try{
         for(; i != N; ++i){
            ::new(init_buf, boost_move_new_t()) T(init);
            init_buf += sizeof(T);
         }
      }
      catch(...){
         while(i--){
            init_buf -= sizeof(T);
            move_detail::force_ptr<T*>(init_buf)->~T();
         }
         throw;;
      }
      }
   }

   operator T* ()
   { return (T*)(rawbuf); }

   operator const T*() const
   { return (const T*)(rawbuf); }

   ~array_initializer()
   {
      char *init_buf = (char*)rawbuf + N*sizeof(T);
      for(std::size_t i = 0; i != N; ++i){
         init_buf -= sizeof(T);
         move_detail::force_ptr<T*>(init_buf)->~T();
      }
   }

   private:
   detail::max_align rawbuf[(N*sizeof(T)-1)/sizeof(detail::max_align)+1];
};

}
}
}
# 32 "/usr/include/boost/intrusive/list.hpp" 2 3 4
# 1 "/usr/include/boost/intrusive/detail/exception_disposer.hpp" 1 3 4
# 26 "/usr/include/boost/intrusive/detail/exception_disposer.hpp" 3 4
namespace boost {
namespace intrusive {
namespace detail {

template<class Container, class Disposer>
class exception_disposer
{
   Container *cont_;
   Disposer &disp_;

   exception_disposer(const exception_disposer&);
   exception_disposer &operator=(const exception_disposer&);

   public:
   exception_disposer(Container &cont, Disposer &disp)
      : cont_(&cont), disp_(disp)
   {}

   inline __attribute__ ((__always_inline__)) void release()
   { cont_ = 0; }

   ~exception_disposer()
   {
      if(cont_){
         cont_->clear_and_dispose(disp_);
      }
   }
};

}
}
}
# 33 "/usr/include/boost/intrusive/list.hpp" 2 3 4
# 1 "/usr/include/boost/intrusive/detail/equal_to_value.hpp" 1 3 4
# 26 "/usr/include/boost/intrusive/detail/equal_to_value.hpp" 3 4
namespace boost {
namespace intrusive {
namespace detail {



template<class ConstReference>
class equal_to_value
{
   ConstReference t_;

   public:
   equal_to_value(ConstReference t)
      : t_(t)
   {}

   inline __attribute__ ((__always_inline__)) bool operator()(ConstReference t)const
   { return t_ == t; }
};

}
}
}
# 34 "/usr/include/boost/intrusive/list.hpp" 2 3 4
# 1 "/usr/include/boost/intrusive/detail/key_nodeptr_comp.hpp" 1 3 4
# 25 "/usr/include/boost/intrusive/detail/key_nodeptr_comp.hpp" 3 4
# 1 "/usr/include/boost/intrusive/detail/ebo_functor_holder.hpp" 1 3 4
# 26 "/usr/include/boost/intrusive/detail/ebo_functor_holder.hpp" 3 4
# 1 "/usr/include/boost/move/utility_core.hpp" 1 3 4
# 28 "/usr/include/boost/move/utility_core.hpp" 3 4
# 1 "/usr/include/boost/move/detail/config_begin.hpp" 1 3 4
# 29 "/usr/include/boost/move/utility_core.hpp" 2 3 4

# 1 "/usr/include/boost/move/core.hpp" 1 3 4
# 27 "/usr/include/boost/move/core.hpp" 3 4
# 1 "/usr/include/boost/move/detail/config_begin.hpp" 1 3 4
# 28 "/usr/include/boost/move/core.hpp" 2 3 4
# 320 "/usr/include/boost/move/core.hpp" 3 4
   namespace boost {




   template<class T>
   struct has_move_emulation_enabled
   {
      static const bool value = false;
   };

   template<class T>
   struct has_move_emulation_disabled
   {
      static const bool value = true;
   };

   }
# 504 "/usr/include/boost/move/core.hpp" 3 4
   namespace boost {
   namespace move_detail {

   template< class T> struct forward_type { typedef T type; };

   }}



# 1 "/usr/include/boost/move/detail/config_end.hpp" 1 3 4
# 514 "/usr/include/boost/move/core.hpp" 2 3 4
# 31 "/usr/include/boost/move/utility_core.hpp" 2 3 4
# 173 "/usr/include/boost/move/utility_core.hpp" 3 4
      namespace boost {







      template<class T>
      struct enable_move_utility_emulation
      {
         static const bool value = false;
      };
# 210 "/usr/include/boost/move/utility_core.hpp" 3 4
         template <class T>
         inline __attribute__ ((__always_inline__))
         typename ::boost::move_detail::remove_reference<T>::type && move(T&& t) noexcept
         { return static_cast<typename ::boost::move_detail::remove_reference<T>::type &&>(t); }
# 247 "/usr/include/boost/move/utility_core.hpp" 3 4
         template <class T>
         inline __attribute__ ((__always_inline__))
         T&& forward(typename ::boost::move_detail::remove_reference<T>::type& t) noexcept
         { return static_cast<T&&>(t); }

         template <class T>
         inline __attribute__ ((__always_inline__))
         T&& forward(typename ::boost::move_detail::remove_reference<T>::type&& t) noexcept
         {

            static_assert(!boost::move_detail::is_lvalue_reference<T>::value, "!boost::move_detail::is_lvalue_reference<T>::value");
            return static_cast<T&&>(t);
         }



      }
# 273 "/usr/include/boost/move/utility_core.hpp" 3 4
   namespace boost {
# 289 "/usr/include/boost/move/utility_core.hpp" 3 4
      template <class T>
      inline __attribute__ ((__always_inline__)) T&& move_if_not_lvalue_reference(typename ::boost::move_detail::remove_reference<T>::type& t) noexcept
      { return static_cast<T&&>(t); }

      template <class T>
      inline __attribute__ ((__always_inline__)) T&& move_if_not_lvalue_reference(typename ::boost::move_detail::remove_reference<T>::type&& t) noexcept
      {

         static_assert(!boost::move_detail::is_lvalue_reference<T>::value, "!boost::move_detail::is_lvalue_reference<T>::value");
         return static_cast<T&&>(t);
      }



   }





namespace boost{
namespace move_detail{

template <typename T>
typename boost::move_detail::add_rvalue_reference<T>::type declval();

}
}




# 1 "/usr/include/boost/move/detail/config_end.hpp" 1 3 4
# 322 "/usr/include/boost/move/utility_core.hpp" 2 3 4
# 27 "/usr/include/boost/intrusive/detail/ebo_functor_holder.hpp" 2 3 4

namespace boost {
namespace intrusive {
namespace detail {
# 42 "/usr/include/boost/intrusive/detail/ebo_functor_holder.hpp" 3 4
template <typename T>
struct is_unary_or_binary_function_impl
{ static const bool value = false; };





template <typename R>
struct is_unary_or_binary_function_impl<R (*)()>
{ static const bool value = true; };

template <typename R>
struct is_unary_or_binary_function_impl<R (*)(...)>
{ static const bool value = true; };
# 86 "/usr/include/boost/intrusive/detail/ebo_functor_holder.hpp" 3 4
template <typename R, class T0>
struct is_unary_or_binary_function_impl<R (*)(T0)>
{ static const bool value = true; };

template <typename R, class T0>
struct is_unary_or_binary_function_impl<R (*)(T0...)>
{ static const bool value = true; };
# 122 "/usr/include/boost/intrusive/detail/ebo_functor_holder.hpp" 3 4
template <typename R, class T0, class T1>
struct is_unary_or_binary_function_impl<R (*)(T0, T1)>
{ static const bool value = true; };

template <typename R, class T0, class T1>
struct is_unary_or_binary_function_impl<R (*)(T0, T1...)>
{ static const bool value = true; };
# 153 "/usr/include/boost/intrusive/detail/ebo_functor_holder.hpp" 3 4
template <typename T>
struct is_unary_or_binary_function_impl<T&>
{ static const bool value = false; };

template<typename T>
struct is_unary_or_binary_function : is_unary_or_binary_function_impl<T>
{};

template<typename T, typename Tag = void, bool = is_unary_or_binary_function<T>::value>
class ebo_functor_holder
{


   public:
   typedef T functor_type;

   inline __attribute__ ((__always_inline__)) ebo_functor_holder()
      : t_()
   {}

   inline __attribute__ ((__always_inline__)) explicit ebo_functor_holder(const T &t)
      : t_(t)
   {}

   inline __attribute__ ((__always_inline__)) explicit ebo_functor_holder(T && t)
      : t_(::boost::move(t))
   {}

   template<class Arg1, class Arg2>
   inline __attribute__ ((__always_inline__)) ebo_functor_holder(Arg1 && arg1, Arg2 && arg2)
      : t_(::boost::forward<Arg1>(arg1), ::boost::forward<Arg2>(arg2))
   {}

   inline __attribute__ ((__always_inline__)) ebo_functor_holder(const ebo_functor_holder &x)
      : t_(x.t_)
   {}

   inline __attribute__ ((__always_inline__)) ebo_functor_holder(ebo_functor_holder && x)
      : t_(x.t_)
   {}

   inline __attribute__ ((__always_inline__)) ebo_functor_holder& operator=(const ebo_functor_holder & x)
   {
      this->get() = x.get();
      return *this;
   }

   inline __attribute__ ((__always_inline__)) ebo_functor_holder& operator=(ebo_functor_holder && x)
   {
      this->get() = ::boost::move(x.get());
      return *this;
   }

   inline __attribute__ ((__always_inline__)) ebo_functor_holder& operator=(const T &x)
   {
      this->get() = x;
      return *this;
   }

   inline __attribute__ ((__always_inline__)) ebo_functor_holder& operator=(T && x)
   {
      this->get() = ::boost::move(x);
      return *this;
   }

   inline __attribute__ ((__always_inline__)) T& get(){return t_;}
   inline __attribute__ ((__always_inline__)) const T& get()const{return t_;}

   private:
   T t_;
};

template<typename T, typename Tag>
class ebo_functor_holder<T, Tag, false>
   : public T
{


   public:
   typedef T functor_type;

   inline __attribute__ ((__always_inline__)) ebo_functor_holder()
      : T()
   {}

   inline __attribute__ ((__always_inline__)) explicit ebo_functor_holder(const T &t)
      : T(t)
   {}

   inline __attribute__ ((__always_inline__)) explicit ebo_functor_holder(T && t)
      : T(::boost::move(t))
   {}

   template<class Arg1, class Arg2>
   inline __attribute__ ((__always_inline__)) ebo_functor_holder(Arg1 && arg1, Arg2 && arg2)
      : T(::boost::forward<Arg1>(arg1), ::boost::forward<Arg2>(arg2))
   {}

   inline __attribute__ ((__always_inline__)) ebo_functor_holder(const ebo_functor_holder &x)
      : T(static_cast<const T&>(x))
   {}

   inline __attribute__ ((__always_inline__)) ebo_functor_holder(ebo_functor_holder && x)
      : T(::boost::move((T&)(x)))
   {}

   inline __attribute__ ((__always_inline__)) ebo_functor_holder& operator=(const ebo_functor_holder & x)
   {
      const ebo_functor_holder&r = x;
      this->get() = r;
      return *this;
   }

   inline __attribute__ ((__always_inline__)) ebo_functor_holder& operator=(ebo_functor_holder && x)
   {
      this->get() = ::boost::move(x.get());
      return *this;
   }

   inline __attribute__ ((__always_inline__)) ebo_functor_holder& operator=(const T &x)
   {
      this->get() = x;
      return *this;
   }

   inline __attribute__ ((__always_inline__)) ebo_functor_holder& operator=(T && x)
   {
      this->get() = ::boost::move(x);
      return *this;
   }

   inline __attribute__ ((__always_inline__)) T& get(){return *this;}
   inline __attribute__ ((__always_inline__)) const T& get()const{return *this;}
};

}
}
}
# 26 "/usr/include/boost/intrusive/detail/key_nodeptr_comp.hpp" 2 3 4
# 1 "/usr/include/boost/intrusive/detail/tree_value_compare.hpp" 1 3 4
# 26 "/usr/include/boost/intrusive/detail/tree_value_compare.hpp" 3 4
namespace boost{
namespace intrusive{


template <class From, class ValuePtr>
struct disable_if_smartref_to
   : detail::disable_if_c
      < detail::is_same
            <From, typename pointer_traits
               <ValuePtr>
                  ::reference>::value
      || detail::is_same
            <From, typename pointer_traits
                     < typename pointer_rebind
                           < ValuePtr
                           , const typename boost::movelib::pointer_element<ValuePtr>::type>::type>
                  ::reference>::value
      >
{};



template< class ValuePtr, class KeyCompare, class KeyOfValue, class Ret = bool
        , bool = boost::intrusive::detail::is_same
   <typename boost::movelib::pointer_element<ValuePtr>::type, typename KeyOfValue::type>::value >
struct tree_value_compare
   : public boost::intrusive::detail::ebo_functor_holder<KeyCompare>
{
   typedef typename
      boost::movelib::pointer_element<ValuePtr>::type value_type;
   typedef KeyCompare key_compare;
   typedef KeyOfValue key_of_value;
   typedef typename KeyOfValue::type key_type;

   typedef boost::intrusive::detail::ebo_functor_holder<KeyCompare> base_t;

   inline __attribute__ ((__always_inline__)) tree_value_compare()
      : base_t()
   {}

   inline __attribute__ ((__always_inline__)) explicit tree_value_compare(const key_compare &kcomp)
      : base_t(kcomp)
   {}

   inline __attribute__ ((__always_inline__)) tree_value_compare (const tree_value_compare &x)
      : base_t(x.base_t::get())
   {}

   inline __attribute__ ((__always_inline__)) tree_value_compare &operator=(const tree_value_compare &x)
   { this->base_t::get() = x.base_t::get(); return *this; }

   inline __attribute__ ((__always_inline__)) tree_value_compare &operator=(const key_compare &x)
   { this->base_t::get() = x; return *this; }

   inline __attribute__ ((__always_inline__)) const key_compare &key_comp() const
   { return static_cast<const key_compare &>(*this); }

   inline __attribute__ ((__always_inline__)) Ret operator()(const key_type &key) const
   { return this->key_comp()(key); }

   inline __attribute__ ((__always_inline__)) Ret operator()(const value_type &value) const
   { return this->key_comp()(KeyOfValue()(value)); }

   template<class U>
   inline __attribute__ ((__always_inline__)) Ret operator()( const U &nonkey
                                             , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const
   { return this->key_comp()(nonkey); }

   inline __attribute__ ((__always_inline__)) Ret operator()(const key_type &key1, const key_type &key2) const
   { return this->key_comp()(key1, key2); }

   inline __attribute__ ((__always_inline__)) Ret operator()(const value_type &value1, const value_type &value2) const
   { return this->key_comp()(KeyOfValue()(value1), KeyOfValue()(value2)); }

   inline __attribute__ ((__always_inline__)) Ret operator()(const key_type &key1, const value_type &value2) const
   { return this->key_comp()(key1, KeyOfValue()(value2)); }

   inline __attribute__ ((__always_inline__)) Ret operator()(const value_type &value1, const key_type &key2) const
   { return this->key_comp()(KeyOfValue()(value1), key2); }

   template<class U>
   inline __attribute__ ((__always_inline__)) Ret operator()( const key_type &key1, const U &nonkey2
                                              , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const
   { return this->key_comp()(key1, nonkey2); }

   template<class U>
   inline __attribute__ ((__always_inline__)) Ret operator()( const U &nonkey1, const key_type &key2
                                              , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const
   { return this->key_comp()(nonkey1, key2); }

   template<class U>
   inline __attribute__ ((__always_inline__)) Ret operator()( const value_type &value1, const U &nonvalue2
                                              , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const
   { return this->key_comp()(KeyOfValue()(value1), nonvalue2); }

   template<class U>
   inline __attribute__ ((__always_inline__)) Ret operator()( const U &nonvalue1, const value_type &value2
                                              , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const
   { return this->key_comp()(nonvalue1, KeyOfValue()(value2)); }
};

template<class ValuePtr, class KeyCompare, class KeyOfValue, class Ret>
struct tree_value_compare<ValuePtr, KeyCompare, KeyOfValue, Ret, true>
   : public boost::intrusive::detail::ebo_functor_holder<KeyCompare>
{
   typedef typename
      boost::movelib::pointer_element<ValuePtr>::type value_type;
   typedef KeyCompare key_compare;
   typedef KeyOfValue key_of_value;
   typedef typename KeyOfValue::type key_type;

   typedef boost::intrusive::detail::ebo_functor_holder<KeyCompare> base_t;


   inline __attribute__ ((__always_inline__)) tree_value_compare()
      : base_t()
   {}

   inline __attribute__ ((__always_inline__)) explicit tree_value_compare(const key_compare &kcomp)
      : base_t(kcomp)
   {}

   inline __attribute__ ((__always_inline__)) tree_value_compare (const tree_value_compare &x)
      : base_t(x.base_t::get())
   {}

   inline __attribute__ ((__always_inline__)) tree_value_compare &operator=(const tree_value_compare &x)
   { this->base_t::get() = x.base_t::get(); return *this; }

   inline __attribute__ ((__always_inline__)) tree_value_compare &operator=(const key_compare &x)
   { this->base_t::get() = x; return *this; }

   inline __attribute__ ((__always_inline__)) const key_compare &key_comp() const
   { return static_cast<const key_compare &>(*this); }

   inline __attribute__ ((__always_inline__)) Ret operator()(const key_type &key) const
   { return this->key_comp()(key); }

   template<class U>
   inline __attribute__ ((__always_inline__)) Ret operator()( const U &nonkey
                                             , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const
   { return this->key_comp()(nonkey); }

   inline __attribute__ ((__always_inline__)) Ret operator()(const key_type &key1, const key_type &key2) const
   { return this->key_comp()(key1, key2); }

   template<class U>
   inline __attribute__ ((__always_inline__)) Ret operator()( const key_type &key1, const U &nonkey2
                                              , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const
   { return this->key_comp()(key1, nonkey2); }

   template<class U>
   inline __attribute__ ((__always_inline__)) Ret operator()(const U &nonkey1, const key_type &key2
                                              , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const
   { return this->key_comp()(nonkey1, key2); }
};

}
}
# 27 "/usr/include/boost/intrusive/detail/key_nodeptr_comp.hpp" 2 3 4


namespace boost {
namespace intrusive {
namespace detail {

template < class KeyTypeKeyCompare
         , class ValueTraits
         , class KeyOfValue
         >
struct key_nodeptr_comp_types
{
   typedef ValueTraits value_traits;
   typedef typename value_traits::value_type value_type;
   typedef typename value_traits::node_ptr node_ptr;
   typedef typename value_traits::const_node_ptr const_node_ptr;
   typedef typename detail::if_c
            < detail::is_same<KeyOfValue, void>::value
            , detail::identity<value_type>
            , KeyOfValue
            >::type key_of_value;
   typedef tree_value_compare
      <typename ValueTraits::pointer, KeyTypeKeyCompare, key_of_value> base_t;
};



template < class KeyTypeKeyCompare
         , class ValueTraits
         , class KeyOfValue = void
         >
struct key_nodeptr_comp

   : public key_nodeptr_comp_types<KeyTypeKeyCompare, ValueTraits, KeyOfValue>::base_t
{
private:
   struct sfinae_type;

public:
   typedef key_nodeptr_comp_types<KeyTypeKeyCompare, ValueTraits, KeyOfValue> types_t;
   typedef typename types_t::value_traits value_traits;
   typedef typename types_t::value_type value_type;
   typedef typename types_t::node_ptr node_ptr;
   typedef typename types_t::const_node_ptr const_node_ptr;
   typedef typename types_t::base_t base_t;
   typedef typename types_t::key_of_value key_of_value;

   template <class P1>
   struct is_same_or_nodeptr_convertible
   {
      static const bool same_type = is_same<P1,const_node_ptr>::value || is_same<P1,node_ptr>::value;
      static const bool value = same_type || is_convertible<P1, const_node_ptr>::value;
   };

   inline __attribute__ ((__always_inline__)) base_t base() const
   { return static_cast<const base_t&>(*this); }

   inline __attribute__ ((__always_inline__)) key_nodeptr_comp(KeyTypeKeyCompare kcomp, const ValueTraits *traits)
      : base_t(kcomp), traits_(traits)
   {}


   template<class T1>
   inline __attribute__ ((__always_inline__)) bool operator()(const T1 &t1, typename enable_if_c< is_same_or_nodeptr_convertible<T1>::value, sfinae_type* >::type = 0) const
   { return base().get()(key_of_value()(*traits_->to_value_ptr(t1))); }



   template<class T1, class T2>
   inline __attribute__ ((__always_inline__)) bool operator()
      (const T1 &t1, const T2 &t2, typename enable_if_c< is_same_or_nodeptr_convertible<T1>::value && is_same_or_nodeptr_convertible<T2>::value, sfinae_type* >::type = 0) const
   { return base()(*traits_->to_value_ptr(t1), *traits_->to_value_ptr(t2)); }


   template<class T1, class T2>
   inline __attribute__ ((__always_inline__)) bool operator()
      (const T1 &t1, const T2 &t2, typename enable_if_c< is_same_or_nodeptr_convertible<T1>::value && !is_same_or_nodeptr_convertible<T2>::value, sfinae_type* >::type = 0) const
   { return base()(*traits_->to_value_ptr(t1), t2); }


   template<class T1, class T2>
   inline __attribute__ ((__always_inline__)) bool operator()
      (const T1 &t1, const T2 &t2, typename enable_if_c< !is_same_or_nodeptr_convertible<T1>::value && is_same_or_nodeptr_convertible<T2>::value, sfinae_type* >::type = 0) const
   { return base()(t1, *traits_->to_value_ptr(t2)); }


   template<class T1, class T2>
   inline __attribute__ ((__always_inline__)) bool operator()
      (const T1 &t1, const T2 &t2, typename enable_if_c< !is_same_or_nodeptr_convertible<T1>::value && !is_same_or_nodeptr_convertible<T2>::value, sfinae_type* >::type = 0) const
   { return base()(t1, t2); }

   const ValueTraits *const traits_;
};

}
}
}
# 35 "/usr/include/boost/intrusive/list.hpp" 2 3 4
# 1 "/usr/include/boost/intrusive/detail/simple_disposers.hpp" 1 3 4
# 26 "/usr/include/boost/intrusive/detail/simple_disposers.hpp" 3 4
namespace boost {
namespace intrusive {
namespace detail {

class null_disposer
{
   public:
   template <class Pointer>
   void operator()(Pointer)
   {}
};

template<class NodeAlgorithms>
class init_disposer
{
   typedef typename NodeAlgorithms::node_ptr node_ptr;

   public:
   inline __attribute__ ((__always_inline__)) void operator()(node_ptr p)
   { NodeAlgorithms::init(p); }
};

}
}
}
# 36 "/usr/include/boost/intrusive/list.hpp" 2 3 4
# 1 "/usr/include/boost/intrusive/detail/size_holder.hpp" 1 3 4
# 26 "/usr/include/boost/intrusive/detail/size_holder.hpp" 3 4
namespace boost {
namespace intrusive {
namespace detail {

template<bool ConstantSize, class SizeType, class Tag = void>
struct size_holder
{
   static const bool constant_time_size = ConstantSize;
   typedef SizeType size_type;

   inline __attribute__ ((__always_inline__)) SizeType get_size() const
   { return size_; }

   inline __attribute__ ((__always_inline__)) void set_size(SizeType size)
   { size_ = size; }

   inline __attribute__ ((__always_inline__)) void decrement()
   { --size_; }

   inline __attribute__ ((__always_inline__)) void increment()
   { ++size_; }

   inline __attribute__ ((__always_inline__)) void increase(SizeType n)
   { size_ += n; }

   inline __attribute__ ((__always_inline__)) void decrease(SizeType n)
   { size_ -= n; }

   inline __attribute__ ((__always_inline__)) void swap(size_holder &other)
   { SizeType tmp(size_); size_ = other.size_; other.size_ = tmp; }

   SizeType size_;
};

template<class SizeType, class Tag>
struct size_holder<false, SizeType, Tag>
{
   static const bool constant_time_size = false;
   typedef SizeType size_type;

   inline __attribute__ ((__always_inline__)) size_type get_size() const
   { return 0; }

   inline __attribute__ ((__always_inline__)) void set_size(size_type)
   {}

   inline __attribute__ ((__always_inline__)) void decrement()
   {}

   inline __attribute__ ((__always_inline__)) void increment()
   {}

   inline __attribute__ ((__always_inline__)) void increase(SizeType)
   {}

   inline __attribute__ ((__always_inline__)) void decrease(SizeType)
   {}

   inline __attribute__ ((__always_inline__)) void swap(size_holder){}
};

}
}
}
# 37 "/usr/include/boost/intrusive/list.hpp" 2 3 4
# 1 "/usr/include/boost/intrusive/detail/algorithm.hpp" 1 3 4
# 24 "/usr/include/boost/intrusive/detail/algorithm.hpp" 3 4
namespace boost {
namespace intrusive {

struct algo_pred_equal
{
   template<class T>
   bool operator()(const T &x, const T &y) const
   { return x == y; }
};

struct algo_pred_less
{
   template<class T>
   bool operator()(const T &x, const T &y) const
   { return x < y; }
};

template<class InputIt1, class InputIt2, class BinaryPredicate>
bool algo_equal(InputIt1 first1, InputIt1 last1, InputIt2 first2, BinaryPredicate p)
{
    for (; first1 != last1; ++first1, ++first2) {
        if (!p(*first1, *first2)) {
            return false;
        }
    }
    return true;
}

template<class InputIt1, class InputIt2>
bool algo_equal(InputIt1 first1, InputIt1 last1, InputIt2 first2)
{ return (algo_equal)(first1, last1, first2, algo_pred_equal()); }

template<class InputIt1, class InputIt2, class BinaryPredicate>
bool algo_equal(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, BinaryPredicate pred)
{
    for (; first1 != last1 && first2 != last2; ++first1, ++first2)
        if (!pred(*first1, *first2))
            return false;
    return first1 == last1 && first2 == last2;
}

template<class InputIt1, class InputIt2>
bool algo_equal(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2)
{ return (algo_equal)(first1, last1, first2, last2, algo_pred_equal()); }

template <class InputIterator1, class InputIterator2, class BinaryPredicate>
  bool algo_lexicographical_compare (InputIterator1 first1, InputIterator1 last1,
                                     InputIterator2 first2, InputIterator2 last2,
                                     BinaryPredicate pred)
{
   while (first1 != last1){
      if (first2 == last2 || *first2 < *first1) return false;
      else if (pred(*first1, *first2)) return true;
      ++first1; ++first2;
   }
   return (first2 != last2);
}

template <class InputIterator1, class InputIterator2>
  bool algo_lexicographical_compare (InputIterator1 first1, InputIterator1 last1,
                                     InputIterator2 first2, InputIterator2 last2)
{ return (algo_lexicographical_compare)(first1, last1, first2, last2, algo_pred_less()); }

}
}
# 38 "/usr/include/boost/intrusive/list.hpp" 2 3 4




# 1 "/usr/include/boost/intrusive/detail/value_functors.hpp" 1 3 4
# 23 "/usr/include/boost/intrusive/detail/value_functors.hpp" 3 4
namespace boost {
namespace intrusive {


template<class ValueType>
struct value_less
{
   bool operator()(const ValueType &a, const ValueType &b) const
      { return a < b; }
};


template<class T>
struct value_less<T*>
{
   bool operator()(const T *a, const T* b) const
      { return std::size_t(a) < std::size_t(b); }
};

template<class ValueType>
struct value_equal
{
   bool operator()(const ValueType &a, const ValueType &b) const
      { return a == b; }
};

}
}
# 43 "/usr/include/boost/intrusive/list.hpp" 2 3 4






namespace boost {
namespace intrusive {



struct default_list_hook_applier
{ template <class T> struct apply{ typedef typename T::default_list_hook type; }; };

template<>
struct is_default_hook_tag<default_list_hook_applier>
{ static const bool value = true; };

struct list_defaults
{
   typedef default_list_hook_applier proto_value_traits;
   static const bool constant_time_size = true;
   typedef std::size_t size_type;
   typedef void header_holder_type;
};
# 84 "/usr/include/boost/intrusive/list.hpp" 3 4
template <class ValueTraits, class SizeType, bool ConstantTimeSize, typename HeaderHolder>

class list_impl
{

   public:
   typedef ValueTraits value_traits;
   typedef typename value_traits::pointer pointer;
   typedef typename value_traits::const_pointer const_pointer;
   typedef typename pointer_traits<pointer>::element_type value_type;
   typedef typename pointer_traits<pointer>::reference reference;
   typedef typename pointer_traits<const_pointer>::reference const_reference;
   typedef typename pointer_traits<pointer>::difference_type difference_type;
   typedef SizeType size_type;
   typedef list_iterator<value_traits, false> iterator;
   typedef list_iterator<value_traits, true> const_iterator;
   typedef boost::intrusive::reverse_iterator<iterator> reverse_iterator;
   typedef boost::intrusive::reverse_iterator<const_iterator> const_reverse_iterator;
   typedef typename value_traits::node_traits node_traits;
   typedef typename node_traits::node node;
   typedef typename node_traits::node_ptr node_ptr;
   typedef typename node_traits::const_node_ptr const_node_ptr;
   typedef circular_list_algorithms<node_traits> node_algorithms;
   typedef typename detail::get_header_holder_type
      < value_traits, HeaderHolder >::type header_holder_type;

   static const bool constant_time_size = ConstantTimeSize;
   static const bool stateful_value_traits = detail::is_stateful_value_traits<value_traits>::value;
   static const bool has_container_from_iterator =
        detail::is_same< header_holder_type, detail::default_header_holder< node_traits > >::value;



   private:
   typedef detail::size_holder<constant_time_size, size_type> size_traits;


   public: list_impl(list_impl const &) = delete; list_impl& operator=(list_impl const &) = delete; public: typedef int boost_move_no_copy_constructor_or_assign; private: public: typedef int boost_move_emulation_t; private:

   static const bool safemode_or_autounlink = is_safe_autounlink<value_traits::link_mode>::value;


   static_assert(!(constant_time_size && ((int)value_traits::link_mode == (int)auto_unlink) ), "!(constant_time_size && ((int)value_traits::link_mode == (int)auto_unlink) )");



   inline __attribute__ ((__always_inline__)) node_ptr get_root_node()
   { return data_.root_plus_size_.m_header.get_node(); }

   inline __attribute__ ((__always_inline__)) const_node_ptr get_root_node() const
   { return data_.root_plus_size_.m_header.get_node(); }

   struct root_plus_size : public size_traits
   {
      header_holder_type m_header;
   };

   struct data_t : public value_traits
   {
      typedef typename list_impl::value_traits value_traits;
      inline __attribute__ ((__always_inline__)) explicit data_t(const value_traits &val_traits)
         : value_traits(val_traits)
      {}

      root_plus_size root_plus_size_;
   } data_;

   inline __attribute__ ((__always_inline__)) size_traits &priv_size_traits() noexcept
   { return data_.root_plus_size_; }

   inline __attribute__ ((__always_inline__)) const size_traits &priv_size_traits() const noexcept
   { return data_.root_plus_size_; }

   inline __attribute__ ((__always_inline__)) const value_traits &priv_value_traits() const noexcept
   { return data_; }

   inline __attribute__ ((__always_inline__)) value_traits &priv_value_traits() noexcept
   { return data_; }

   typedef typename boost::intrusive::value_traits_pointers
      <ValueTraits>::const_value_traits_ptr const_value_traits_ptr;

   inline __attribute__ ((__always_inline__)) const_value_traits_ptr priv_value_traits_ptr() const noexcept
   { return pointer_traits<const_value_traits_ptr>::pointer_to(this->priv_value_traits()); }



   public:







   list_impl()
      : data_(value_traits())
   {
      this->priv_size_traits().set_size(size_type(0));
      node_algorithms::init_header(this->get_root_node());
   }







   explicit list_impl(const value_traits &v_traits)
      : data_(v_traits)
   {
      this->priv_size_traits().set_size(size_type(0));
      node_algorithms::init_header(this->get_root_node());
   }
# 207 "/usr/include/boost/intrusive/list.hpp" 3 4
   template<class Iterator>
   list_impl(Iterator b, Iterator e, const value_traits &v_traits = value_traits())
      : data_(v_traits)
   {

      this->priv_size_traits().set_size(size_type(0));
      node_algorithms::init_header(this->get_root_node());

      this->insert(this->cend(), b, e);
   }
# 227 "/usr/include/boost/intrusive/list.hpp" 3 4
   list_impl(list_impl && x)
      : data_(::boost::move(x.priv_value_traits()))
   {
      this->priv_size_traits().set_size(size_type(0));
      node_algorithms::init_header(this->get_root_node());

      this->swap(x);
   }



   list_impl& operator=(list_impl && x)
   { this->swap(x); return *this; }
# 252 "/usr/include/boost/intrusive/list.hpp" 3 4
   ~list_impl()
   {
      if constexpr(is_safe_autounlink<ValueTraits::link_mode>::value){
         this->clear();
         node_algorithms::init(this->get_root_node());
      }
   }
# 270 "/usr/include/boost/intrusive/list.hpp" 3 4
   void push_back(reference value) noexcept
   {
      node_ptr to_insert = priv_value_traits().to_node_ptr(value);
      (static_cast <bool> (!safemode_or_autounlink || node_algorithms::inited(to_insert)) ? void (0) : __assert_fail ("!safemode_or_autounlink || node_algorithms::inited(to_insert)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      node_algorithms::link_before(this->get_root_node(), to_insert);
      this->priv_size_traits().increment();
   }
# 288 "/usr/include/boost/intrusive/list.hpp" 3 4
   void push_front(reference value) noexcept
   {
      node_ptr to_insert = priv_value_traits().to_node_ptr(value);
      (static_cast <bool> (!safemode_or_autounlink || node_algorithms::inited(to_insert)) ? void (0) : __assert_fail ("!safemode_or_autounlink || node_algorithms::inited(to_insert)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      node_algorithms::link_before(node_traits::get_next(this->get_root_node()), to_insert);
      this->priv_size_traits().increment();
   }
# 304 "/usr/include/boost/intrusive/list.hpp" 3 4
   void pop_back() noexcept
   { return this->pop_back_and_dispose(detail::null_disposer()); }
# 318 "/usr/include/boost/intrusive/list.hpp" 3 4
   template<class Disposer>
   void pop_back_and_dispose(Disposer disposer) noexcept
   {
      node_ptr to_erase = node_traits::get_previous(this->get_root_node());
      node_algorithms::unlink(to_erase);
      this->priv_size_traits().decrement();
      if constexpr(safemode_or_autounlink)
         node_algorithms::init(to_erase);
      disposer(priv_value_traits().to_value_ptr(to_erase));
   }
# 337 "/usr/include/boost/intrusive/list.hpp" 3 4
   void pop_front() noexcept
   { return this->pop_front_and_dispose(detail::null_disposer()); }
# 351 "/usr/include/boost/intrusive/list.hpp" 3 4
   template<class Disposer>
   void pop_front_and_dispose(Disposer disposer) noexcept
   {
      node_ptr to_erase = node_traits::get_next(this->get_root_node());
      node_algorithms::unlink(to_erase);
      this->priv_size_traits().decrement();
      if constexpr(safemode_or_autounlink)
         node_algorithms::init(to_erase);
      disposer(priv_value_traits().to_value_ptr(to_erase));
   }






   inline __attribute__ ((__always_inline__)) reference front() noexcept
   { return *priv_value_traits().to_value_ptr(node_traits::get_next(this->get_root_node())); }






   inline __attribute__ ((__always_inline__)) const_reference front() const noexcept
   { return *priv_value_traits().to_value_ptr(node_traits::get_next(this->get_root_node())); }






   inline __attribute__ ((__always_inline__)) reference back() noexcept
   { return *priv_value_traits().to_value_ptr(node_traits::get_previous(this->get_root_node())); }






   inline __attribute__ ((__always_inline__)) const_reference back() const noexcept
   { return *priv_value_traits().to_value_ptr(detail::uncast(node_traits::get_previous(this->get_root_node()))); }






   inline __attribute__ ((__always_inline__)) iterator begin() noexcept
   { return iterator(node_traits::get_next(this->get_root_node()), this->priv_value_traits_ptr()); }






   inline __attribute__ ((__always_inline__)) const_iterator begin() const noexcept
   { return this->cbegin(); }






   inline __attribute__ ((__always_inline__)) const_iterator cbegin() const noexcept
   { return const_iterator(node_traits::get_next(this->get_root_node()), this->priv_value_traits_ptr()); }






   inline __attribute__ ((__always_inline__)) iterator end() noexcept
   { return iterator(this->get_root_node(), this->priv_value_traits_ptr()); }






   inline __attribute__ ((__always_inline__)) const_iterator end() const noexcept
   { return this->cend(); }






   inline __attribute__ ((__always_inline__)) const_iterator cend() const noexcept
   { return const_iterator(detail::uncast(this->get_root_node()), this->priv_value_traits_ptr()); }







   inline __attribute__ ((__always_inline__)) reverse_iterator rbegin() noexcept
   { return reverse_iterator(this->end()); }







   inline __attribute__ ((__always_inline__)) const_reverse_iterator rbegin() const noexcept
   { return this->crbegin(); }







   inline __attribute__ ((__always_inline__)) const_reverse_iterator crbegin() const noexcept
   { return const_reverse_iterator(end()); }







   inline __attribute__ ((__always_inline__)) reverse_iterator rend() noexcept
   { return reverse_iterator(begin()); }







   inline __attribute__ ((__always_inline__)) const_reverse_iterator rend() const noexcept
   { return this->crend(); }







   inline __attribute__ ((__always_inline__)) const_reverse_iterator crend() const noexcept
   { return const_reverse_iterator(this->begin()); }
# 504 "/usr/include/boost/intrusive/list.hpp" 3 4
   inline __attribute__ ((__always_inline__)) static list_impl &container_from_end_iterator(iterator end_iterator) noexcept
   { return list_impl::priv_container_from_end_iterator(end_iterator); }
# 515 "/usr/include/boost/intrusive/list.hpp" 3 4
   inline __attribute__ ((__always_inline__)) static const list_impl &container_from_end_iterator(const_iterator end_iterator) noexcept
   { return list_impl::priv_container_from_end_iterator(end_iterator); }
# 526 "/usr/include/boost/intrusive/list.hpp" 3 4
   inline __attribute__ ((__always_inline__)) size_type size() const noexcept
   {
      if constexpr(constant_time_size)
         return this->priv_size_traits().get_size();
      else
         return node_algorithms::count(this->get_root_node()) - 1;
   }
# 541 "/usr/include/boost/intrusive/list.hpp" 3 4
   inline __attribute__ ((__always_inline__)) bool empty() const noexcept
   { return node_algorithms::unique(this->get_root_node()); }
# 551 "/usr/include/boost/intrusive/list.hpp" 3 4
   void swap(list_impl& other) noexcept
   {
      node_algorithms::swap_nodes(this->get_root_node(), other.get_root_node());
      this->priv_size_traits().swap(other.priv_size_traits());
   }
# 566 "/usr/include/boost/intrusive/list.hpp" 3 4
   inline __attribute__ ((__always_inline__)) void shift_backwards(size_type n = 1) noexcept
   { node_algorithms::move_forward(this->get_root_node(), n); }
# 578 "/usr/include/boost/intrusive/list.hpp" 3 4
   inline __attribute__ ((__always_inline__)) void shift_forward(size_type n = 1) noexcept
   { node_algorithms::move_backwards(this->get_root_node(), n); }
# 593 "/usr/include/boost/intrusive/list.hpp" 3 4
   inline __attribute__ ((__always_inline__)) iterator erase(const_iterator i) noexcept
   { return this->erase_and_dispose(i, detail::null_disposer()); }
# 611 "/usr/include/boost/intrusive/list.hpp" 3 4
   inline __attribute__ ((__always_inline__)) iterator erase(const_iterator b, const_iterator e) noexcept
   {
      if constexpr(safemode_or_autounlink || constant_time_size){
         return this->erase_and_dispose(b, e, detail::null_disposer());
      }
      else{
         node_algorithms::unlink(b.pointed_node(), e.pointed_node());
         return e.unconst();
      }
   }
# 638 "/usr/include/boost/intrusive/list.hpp" 3 4
   iterator erase(const_iterator b, const_iterator e, size_type n) noexcept
   {
      (static_cast <bool> (node_algorithms::distance(b.pointed_node(), e.pointed_node()) == n) ? void (0) : __assert_fail ("node_algorithms::distance(b.pointed_node(), e.pointed_node()) == n", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      (void)n;
      if constexpr(safemode_or_autounlink){
         return this->erase_and_dispose(b, e, detail::null_disposer());
      }
      else{
         if constexpr(constant_time_size){
            this->priv_size_traits().decrease(n);
         }
         node_algorithms::unlink(b.pointed_node(), e.pointed_node());
         return e.unconst();
      }
   }
# 668 "/usr/include/boost/intrusive/list.hpp" 3 4
   template <class Disposer>
   iterator erase_and_dispose(const_iterator i, Disposer disposer) noexcept
   {
      node_ptr to_erase(i.pointed_node());
      ++i;
      node_algorithms::unlink(to_erase);
      this->priv_size_traits().decrement();
      if constexpr(safemode_or_autounlink)
         node_algorithms::init(to_erase);
      disposer(this->priv_value_traits().to_value_ptr(to_erase));
      return i.unconst();
   }


   template<class Disposer>
   iterator erase_and_dispose(iterator i, Disposer disposer) noexcept
   { return this->erase_and_dispose(const_iterator(i), disposer); }
# 701 "/usr/include/boost/intrusive/list.hpp" 3 4
   template <class Disposer>
   iterator erase_and_dispose(const_iterator b, const_iterator e, Disposer disposer) noexcept
   {
      node_ptr bp(b.pointed_node()), ep(e.pointed_node());
      node_algorithms::unlink(bp, ep);
      while(bp != ep){
         node_ptr to_erase(bp);
         bp = node_traits::get_next(bp);
         if constexpr(safemode_or_autounlink)
            node_algorithms::init(to_erase);
         disposer(priv_value_traits().to_value_ptr(to_erase));
         this->priv_size_traits().decrement();
      }
      return e.unconst();
   }
# 726 "/usr/include/boost/intrusive/list.hpp" 3 4
   void clear() noexcept
   {
      if constexpr(safemode_or_autounlink){
         this->clear_and_dispose(detail::null_disposer());
      }
      else{
         node_algorithms::init_header(this->get_root_node());
         this->priv_size_traits().set_size(size_type(0));
      }
   }
# 748 "/usr/include/boost/intrusive/list.hpp" 3 4
   template <class Disposer>
   void clear_and_dispose(Disposer disposer) noexcept
   {
      const_iterator it(this->begin()), itend(this->end());
      while(it != itend){
         node_ptr to_erase(it.pointed_node());
         ++it;
         if constexpr(safemode_or_autounlink)
            node_algorithms::init(to_erase);
         disposer(priv_value_traits().to_value_ptr(to_erase));
      }
      node_algorithms::init_header(this->get_root_node());
      this->priv_size_traits().set_size(0);
   }
# 777 "/usr/include/boost/intrusive/list.hpp" 3 4
   template <class Cloner, class Disposer>
   void clone_from(const list_impl &src, Cloner cloner, Disposer disposer)
   {
      this->clear_and_dispose(disposer);
      detail::exception_disposer<list_impl, Disposer>
         rollback(*this, disposer);
      const_iterator b(src.begin()), e(src.end());
      for(; b != e; ++b){
         this->push_back(*cloner(*b));
      }
      rollback.release();
   }
# 804 "/usr/include/boost/intrusive/list.hpp" 3 4
   template <class Cloner, class Disposer>
   void clone_from(list_impl && src, Cloner cloner, Disposer disposer)
   {
      this->clear_and_dispose(disposer);
      detail::exception_disposer<list_impl, Disposer>
         rollback(*this, disposer);
      iterator b(src.begin()), e(src.end());
      for(; b != e; ++b){
         this->push_back(*cloner(*b));
      }
      rollback.release();
   }
# 828 "/usr/include/boost/intrusive/list.hpp" 3 4
   iterator insert(const_iterator p, reference value) noexcept
   {
      node_ptr to_insert = this->priv_value_traits().to_node_ptr(value);
      (static_cast <bool> (!safemode_or_autounlink || node_algorithms::inited(to_insert)) ? void (0) : __assert_fail ("!safemode_or_autounlink || node_algorithms::inited(to_insert)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      node_algorithms::link_before(p.pointed_node(), to_insert);
      this->priv_size_traits().increment();
      return iterator(to_insert, this->priv_value_traits_ptr());
   }
# 848 "/usr/include/boost/intrusive/list.hpp" 3 4
   template<class Iterator>
   void insert(const_iterator p, Iterator b, Iterator e) noexcept
   {
      for (; b != e; ++b)
         this->insert(p, *b);
   }
# 870 "/usr/include/boost/intrusive/list.hpp" 3 4
   template<class Iterator>
   void assign(Iterator b, Iterator e) noexcept
   {
      this->clear();
      this->insert(this->cend(), b, e);
   }
# 893 "/usr/include/boost/intrusive/list.hpp" 3 4
   template<class Iterator, class Disposer>
   void dispose_and_assign(Disposer disposer, Iterator b, Iterator e) noexcept
   {
      this->clear_and_dispose(disposer);
      this->insert(this->cend(), b, e);
   }
# 911 "/usr/include/boost/intrusive/list.hpp" 3 4
   void splice(const_iterator p, list_impl& x) noexcept
   {
      if(!x.empty()){
         node_algorithms::transfer
            (p.pointed_node(), x.begin().pointed_node(), x.end().pointed_node());
         size_traits &thist = this->priv_size_traits();
         size_traits &xt = x.priv_size_traits();
         thist.increase(xt.get_size());
         xt.set_size(size_type(0));
      }
   }
# 936 "/usr/include/boost/intrusive/list.hpp" 3 4
   void splice(const_iterator p, list_impl&x, const_iterator new_ele) noexcept
   {
      node_algorithms::transfer(p.pointed_node(), new_ele.pointed_node());
      x.priv_size_traits().decrement();
      this->priv_size_traits().increment();
   }
# 956 "/usr/include/boost/intrusive/list.hpp" 3 4
   void splice(const_iterator p, list_impl&x, const_iterator f, const_iterator e) noexcept
   {
      if constexpr(constant_time_size)
         this->splice(p, x, f, e, node_algorithms::distance(f.pointed_node(), e.pointed_node()));
      else
         this->splice(p, x, f, e, 1);
   }
# 977 "/usr/include/boost/intrusive/list.hpp" 3 4
   void splice(const_iterator p, list_impl&x, const_iterator f, const_iterator e, size_type n) noexcept
   {
      if(n){
         if constexpr(constant_time_size){
            (static_cast <bool> (n == node_algorithms::distance(f.pointed_node(), e.pointed_node())) ? void (0) : __assert_fail ("n == node_algorithms::distance(f.pointed_node(), e.pointed_node())", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
            node_algorithms::transfer(p.pointed_node(), f.pointed_node(), e.pointed_node());
            size_traits &thist = this->priv_size_traits();
            size_traits &xt = x.priv_size_traits();
            thist.increase(n);
            xt.decrease(n);
         }
         else{
            node_algorithms::transfer(p.pointed_node(), f.pointed_node(), e.pointed_node());
         }
      }
   }
# 1005 "/usr/include/boost/intrusive/list.hpp" 3 4
   void sort()
   { this->sort(value_less<value_type>()); }
# 1023 "/usr/include/boost/intrusive/list.hpp" 3 4
   template<class Predicate>
   void sort(Predicate p)
   {
      if(node_traits::get_next(this->get_root_node())
         != node_traits::get_previous(this->get_root_node())){
         list_impl carry(this->priv_value_traits());
         detail::array_initializer<list_impl, 64> counter(this->priv_value_traits());
         int fill = 0;
         while(!this->empty()){
            carry.splice(carry.cbegin(), *this, this->cbegin());
            int i = 0;
            while(i < fill && !counter[i].empty()) {
               counter[i].merge(carry, p);
               carry.swap(counter[i++]);
            }
            carry.swap(counter[i]);
            if(i == fill)
               ++fill;
         }
         for (int i = 1; i < fill; ++i)
            counter[i].merge(counter[i-1], p);
         this->swap(counter[fill-1]);
      }
   }
# 1059 "/usr/include/boost/intrusive/list.hpp" 3 4
   void merge(list_impl& x)
   { this->merge(x, value_less<value_type>()); }
# 1076 "/usr/include/boost/intrusive/list.hpp" 3 4
   template<class Predicate>
   void merge(list_impl& x, Predicate p)
   {
      const_iterator e(this->cend()), ex(x.cend());
      const_iterator b(this->cbegin());
      while(!x.empty()){
         const_iterator ix(x.cbegin());
         while (b != e && !p(*ix, *b)){
            ++b;
         }
         if(b == e){

            this->splice(e, x);
            break;
         }
         else{
            size_type n(0);
            do{
               ++ix; ++n;
            } while(ix != ex && p(*ix, *b));
            this->splice(b, x, x.begin(), ix, n);
         }
      }
   }
# 1108 "/usr/include/boost/intrusive/list.hpp" 3 4
   void reverse() noexcept
   { node_algorithms::reverse(this->get_root_node()); }
# 1120 "/usr/include/boost/intrusive/list.hpp" 3 4
   void remove(const_reference value) noexcept
   { this->remove_if(detail::equal_to_value<const_reference>(value)); }
# 1134 "/usr/include/boost/intrusive/list.hpp" 3 4
   template<class Disposer>
   void remove_and_dispose(const_reference value, Disposer disposer) noexcept
   { this->remove_and_dispose_if(detail::equal_to_value<const_reference>(value), disposer); }
# 1147 "/usr/include/boost/intrusive/list.hpp" 3 4
   template<class Pred>
   void remove_if(Pred pred)
   {
      const node_ptr root_node = this->get_root_node();
      typename node_algorithms::stable_partition_info info;
      node_algorithms::stable_partition
         (node_traits::get_next(root_node), root_node, detail::key_nodeptr_comp<Pred, value_traits>(pred, &this->priv_value_traits()), info);


      this->erase( const_iterator(node_traits::get_next(root_node), this->priv_value_traits_ptr())
                 , const_iterator(info.beg_2st_partition, this->priv_value_traits_ptr())
                 , info.num_1st_partition);
   }
# 1173 "/usr/include/boost/intrusive/list.hpp" 3 4
   template<class Pred, class Disposer>
   void remove_and_dispose_if(Pred pred, Disposer disposer)
   {
      const node_ptr root_node = this->get_root_node();
      typename node_algorithms::stable_partition_info info;
      node_algorithms::stable_partition
         (node_traits::get_next(root_node), root_node, detail::key_nodeptr_comp<Pred, value_traits>(pred, &this->priv_value_traits()), info);


      this->erase_and_dispose( const_iterator(node_traits::get_next(root_node), this->priv_value_traits_ptr())
                             , const_iterator(info.beg_2st_partition, this->priv_value_traits_ptr())
                             , disposer);
   }
# 1196 "/usr/include/boost/intrusive/list.hpp" 3 4
   void unique()
   { this->unique_and_dispose(std::equal_to<value_type>(), detail::null_disposer()); }
# 1209 "/usr/include/boost/intrusive/list.hpp" 3 4
   template<class BinaryPredicate>
   void unique(BinaryPredicate pred)
   { this->unique_and_dispose(pred, detail::null_disposer()); }
# 1225 "/usr/include/boost/intrusive/list.hpp" 3 4
   template<class Disposer>
   void unique_and_dispose(Disposer disposer)
   { this->unique_and_dispose(std::equal_to<value_type>(), disposer); }
# 1241 "/usr/include/boost/intrusive/list.hpp" 3 4
   template<class BinaryPredicate, class Disposer>
   void unique_and_dispose(BinaryPredicate pred, Disposer disposer)
   {
      const_iterator itend(this->cend());
      const_iterator cur(this->cbegin());

      if(cur != itend){
         const_iterator after(cur);
         ++after;
         while(after != itend){
            if(pred(*cur, *after)){
               after = this->erase_and_dispose(after, disposer);
            }
            else{
               cur = after;
               ++after;
            }
         }
      }
   }
# 1273 "/usr/include/boost/intrusive/list.hpp" 3 4
   static iterator s_iterator_to(reference value) noexcept
   {
      static_assert((!stateful_value_traits), "(!stateful_value_traits)");
      (static_cast <bool> (!node_algorithms::inited(value_traits::to_node_ptr(value))) ? void (0) : __assert_fail ("!node_algorithms::inited(value_traits::to_node_ptr(value))", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      return iterator(value_traits::to_node_ptr(value), const_value_traits_ptr());
   }
# 1291 "/usr/include/boost/intrusive/list.hpp" 3 4
   static const_iterator s_iterator_to(const_reference value) noexcept
   {
      static_assert((!stateful_value_traits), "(!stateful_value_traits)");
      reference r =*detail::uncast(pointer_traits<const_pointer>::pointer_to(value));
      (static_cast <bool> (!node_algorithms::inited(value_traits::to_node_ptr(r))) ? void (0) : __assert_fail ("!node_algorithms::inited(value_traits::to_node_ptr(r))", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      return const_iterator(value_traits::to_node_ptr(r), const_value_traits_ptr());
   }
# 1308 "/usr/include/boost/intrusive/list.hpp" 3 4
   iterator iterator_to(reference value) noexcept
   {
      (static_cast <bool> (!node_algorithms::inited(this->priv_value_traits().to_node_ptr(value))) ? void (0) : __assert_fail ("!node_algorithms::inited(this->priv_value_traits().to_node_ptr(value))", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      return iterator(this->priv_value_traits().to_node_ptr(value), this->priv_value_traits_ptr());
   }
# 1323 "/usr/include/boost/intrusive/list.hpp" 3 4
   const_iterator iterator_to(const_reference value) const noexcept
   {
      reference r = *detail::uncast(pointer_traits<const_pointer>::pointer_to(value));
      (static_cast <bool> (!node_algorithms::inited(this->priv_value_traits().to_node_ptr(r))) ? void (0) : __assert_fail ("!node_algorithms::inited(this->priv_value_traits().to_node_ptr(r))", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      return const_iterator(this->priv_value_traits().to_node_ptr(r), this->priv_value_traits_ptr());
   }







   void check() const
   {
      const_node_ptr header_ptr = get_root_node();

      (static_cast <bool> (node_traits::get_next(header_ptr)) ? void (0) : __assert_fail ("node_traits::get_next(header_ptr)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      (static_cast <bool> (node_traits::get_previous(header_ptr)) ? void (0) : __assert_fail ("node_traits::get_previous(header_ptr)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));

      (static_cast <bool> ((node_traits::get_next(header_ptr) == header_ptr) == (node_traits::get_previous(header_ptr) == header_ptr)) ? void (0) : __assert_fail ("(node_traits::get_next(header_ptr) == header_ptr) == (node_traits::get_previous(header_ptr) == header_ptr)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));

      if (node_traits::get_next(header_ptr) == header_ptr)
      {
         if constexpr(constant_time_size)
            (static_cast <bool> (this->priv_size_traits().get_size() == 0) ? void (0) : __assert_fail ("this->priv_size_traits().get_size() == 0", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
         return;
      }
      size_t node_count = 0; (void)node_count;
      const_node_ptr p = header_ptr;
      while (true)
      {
         const_node_ptr next_p = node_traits::get_next(p);
         (static_cast <bool> (next_p) ? void (0) : __assert_fail ("next_p", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
         (static_cast <bool> (node_traits::get_previous(next_p) == p) ? void (0) : __assert_fail ("node_traits::get_previous(next_p) == p", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
         p = next_p;
         if (p == header_ptr) break;
         ++node_count;
      }
      if constexpr(constant_time_size)
         (static_cast <bool> (this->priv_size_traits().get_size() == node_count) ? void (0) : __assert_fail ("this->priv_size_traits().get_size() == node_count", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
   }

   friend bool operator==(const list_impl &x, const list_impl &y)
   {
      if(constant_time_size && x.size() != y.size()){
         return false;
      }
      return ::boost::intrusive::algo_equal(x.cbegin(), x.cend(), y.cbegin(), y.cend());
   }

   inline __attribute__ ((__always_inline__)) friend bool operator!=(const list_impl &x, const list_impl &y)
   { return !(x == y); }

   inline __attribute__ ((__always_inline__)) friend bool operator<(const list_impl &x, const list_impl &y)
   { return ::boost::intrusive::algo_lexicographical_compare(x.begin(), x.end(), y.begin(), y.end()); }

   inline __attribute__ ((__always_inline__)) friend bool operator>(const list_impl &x, const list_impl &y)
   { return y < x; }

   inline __attribute__ ((__always_inline__)) friend bool operator<=(const list_impl &x, const list_impl &y)
   { return !(y < x); }

   inline __attribute__ ((__always_inline__)) friend bool operator>=(const list_impl &x, const list_impl &y)
   { return !(x < y); }

   inline __attribute__ ((__always_inline__)) friend void swap(list_impl &x, list_impl &y) noexcept
   { x.swap(y); }



   private:
   static list_impl &priv_container_from_end_iterator(const const_iterator &end_iterator) noexcept
   {
      static_assert((has_container_from_iterator), "(has_container_from_iterator)");
      node_ptr p = end_iterator.pointed_node();
      header_holder_type* h = header_holder_type::get_holder(p);
      root_plus_size* r = detail::parent_from_member
         < root_plus_size, header_holder_type>(h, &root_plus_size::m_header);
      data_t *d = detail::parent_from_member<data_t, root_plus_size>
         ( r, &data_t::root_plus_size_);
      list_impl *s = detail::parent_from_member<list_impl, data_t>(d, &list_impl::data_);
      return *s;
   }

};





template<class T, class ...Options>



struct make_list
{

   typedef typename pack_options
      < list_defaults,



         Options...

      >::type packed_options;

   typedef typename detail::get_value_traits
      <T, typename packed_options::proto_value_traits>::type value_traits;
   typedef list_impl
      <
         value_traits,
         typename packed_options::size_type,
         packed_options::constant_time_size,
         typename packed_options::header_holder_type
      > implementation_defined;

   typedef implementation_defined type;
};







template<class T, class ...Options>

class list
   : public make_list<T,



      Options...

   >::type
{
   typedef typename make_list
      <T,



      Options...

      >::type Base;

   static_assert((detail::is_same<typename Base::value_traits::value_type, T>::value), "(detail::is_same<typename Base::value_traits::value_type, T>::value)");
   public: list(list const &) = delete; list& operator=(list const &) = delete; public: typedef int boost_move_no_copy_constructor_or_assign; private: public: typedef int boost_move_emulation_t; private:

   public:
   typedef typename Base::value_traits value_traits;
   typedef typename Base::iterator iterator;
   typedef typename Base::const_iterator const_iterator;

   inline __attribute__ ((__always_inline__)) list()
      : Base()
   {}

   inline __attribute__ ((__always_inline__)) explicit list(const value_traits &v_traits)
      : Base(v_traits)
   {}

   template<class Iterator>
   inline __attribute__ ((__always_inline__)) list(Iterator b, Iterator e, const value_traits &v_traits = value_traits())
      : Base(b, e, v_traits)
   {}

   inline __attribute__ ((__always_inline__)) list(list && x)
      : Base(::boost::move((Base&)(x)))
   {}

   inline __attribute__ ((__always_inline__)) list& operator=(list && x)
   { return static_cast<list &>(this->Base::operator=(::boost::move((Base&)(x)))); }

   template <class Cloner, class Disposer>
   inline __attribute__ ((__always_inline__)) void clone_from(const list &src, Cloner cloner, Disposer disposer)
   { Base::clone_from(src, cloner, disposer); }

   template <class Cloner, class Disposer>
   inline __attribute__ ((__always_inline__)) void clone_from(list && src, Cloner cloner, Disposer disposer)
   { Base::clone_from(::boost::move((Base&)(src)), cloner, disposer); }

   inline __attribute__ ((__always_inline__)) static list &container_from_end_iterator(iterator end_iterator) noexcept
   { return static_cast<list &>(Base::container_from_end_iterator(end_iterator)); }

   inline __attribute__ ((__always_inline__)) static const list &container_from_end_iterator(const_iterator end_iterator) noexcept
   { return static_cast<const list &>(Base::container_from_end_iterator(end_iterator)); }
};



}
}

# 1 "/usr/include/boost/intrusive/detail/config_end.hpp" 1 3 4
# 1518 "/usr/include/boost/intrusive/list.hpp" 2 3 4
# 29 "/home/avi/scylla-maint/seastar/include/seastar/rpc/rpc.hh" 2
# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/future.hh" 1
# 25 "/home/avi/scylla-maint/seastar/include/seastar/core/future.hh"
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 1 3
# 42 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 3


# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 45 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 2 3
# 26 "/home/avi/scylla-maint/seastar/include/seastar/core/future.hh" 2

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdlib" 1 3
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdlib" 3
# 28 "/home/avi/scylla-maint/seastar/include/seastar/core/future.hh" 2
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 1 3
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 3


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 43 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 2 3
# 1 "/usr/include/string.h" 1 3 4
# 26 "/usr/include/string.h" 3 4
# 1 "/usr/include/bits/libc-header-start.h" 1 3 4
# 27 "/usr/include/string.h" 2 3 4

extern "C" {




# 1 "/usr/bin/../lib/clang/18/include/stddef.h" 1 3 4
# 77 "/usr/bin/../lib/clang/18/include/stddef.h" 3 4
# 1 "/usr/bin/../lib/clang/18/include/__stddef_size_t.h" 1 3 4
# 18 "/usr/bin/../lib/clang/18/include/__stddef_size_t.h" 3 4
typedef long unsigned int size_t;
# 78 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3 4
# 92 "/usr/bin/../lib/clang/18/include/stddef.h" 3 4
# 1 "/usr/bin/../lib/clang/18/include/__stddef_null.h" 1 3 4
# 93 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3 4
# 34 "/usr/include/string.h" 2 3 4
# 43 "/usr/include/string.h" 3 4
extern void *memcpy (void *__restrict __dest, const void *__restrict __src,
       size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern void *memmove (void *__dest, const void *__src, size_t __n)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));





extern void *memccpy (void *__restrict __dest, const void *__restrict __src,
        int __c, size_t __n)
    noexcept (true) __attribute__ ((__nonnull__ (1, 2))) ;




extern void *memset (void *__s, int __c, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int memcmp (const void *__s1, const void *__s2, size_t __n)
     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
# 80 "/usr/include/string.h" 3 4
extern int __memcmpeq (const void *__s1, const void *__s2, size_t __n)
     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));



extern "C++"
{
extern void *memchr (void *__s, int __c, size_t __n)
      noexcept (true) __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern const void *memchr (const void *__s, int __c, size_t __n)
      noexcept (true) __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) void *
memchr (void *__s, int __c, size_t __n) noexcept (true)
{
  return __builtin_memchr (__s, __c, __n);
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const void *
memchr (const void *__s, int __c, size_t __n) noexcept (true)
{
  return __builtin_memchr (__s, __c, __n);
}

}
# 115 "/usr/include/string.h" 3 4
extern "C++" void *rawmemchr (void *__s, int __c)
     noexcept (true) __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern "C++" const void *rawmemchr (const void *__s, int __c)
     noexcept (true) __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));







extern "C++" void *memrchr (void *__s, int __c, size_t __n)
      noexcept (true) __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)))
                                           ;
extern "C++" const void *memrchr (const void *__s, int __c, size_t __n)
      noexcept (true) __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)))
                                           ;
# 141 "/usr/include/string.h" 3 4
extern char *strcpy (char *__restrict __dest, const char *__restrict __src)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));

extern char *strncpy (char *__restrict __dest,
        const char *__restrict __src, size_t __n)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern char *strcat (char *__restrict __dest, const char *__restrict __src)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));

extern char *strncat (char *__restrict __dest, const char *__restrict __src,
        size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern int strcmp (const char *__s1, const char *__s2)
     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern int strncmp (const char *__s1, const char *__s2, size_t __n)
     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern int strcoll (const char *__s1, const char *__s2)
     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));

extern size_t strxfrm (char *__restrict __dest,
         const char *__restrict __src, size_t __n)
    noexcept (true) __attribute__ ((__nonnull__ (2))) ;






extern int strcoll_l (const char *__s1, const char *__s2, locale_t __l)
     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));


extern size_t strxfrm_l (char *__dest, const char *__src, size_t __n,
    locale_t __l) noexcept (true) __attribute__ ((__nonnull__ (2, 4)))
                                           ;





extern char *strdup (const char *__s)
     noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));






extern char *strndup (const char *__string, size_t __n)
     noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1)));
# 224 "/usr/include/string.h" 3 4
extern "C++"
{
extern char *strchr (char *__s, int __c)
     noexcept (true) __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern const char *strchr (const char *__s, int __c)
     noexcept (true) __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char *
strchr (char *__s, int __c) noexcept (true)
{
  return __builtin_strchr (__s, __c);
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char *
strchr (const char *__s, int __c) noexcept (true)
{
  return __builtin_strchr (__s, __c);
}

}






extern "C++"
{
extern char *strrchr (char *__s, int __c)
     noexcept (true) __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern const char *strrchr (const char *__s, int __c)
     noexcept (true) __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char *
strrchr (char *__s, int __c) noexcept (true)
{
  return __builtin_strrchr (__s, __c);
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char *
strrchr (const char *__s, int __c) noexcept (true)
{
  return __builtin_strrchr (__s, __c);
}

}
# 281 "/usr/include/string.h" 3 4
extern "C++" char *strchrnul (char *__s, int __c)
     noexcept (true) __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
extern "C++" const char *strchrnul (const char *__s, int __c)
     noexcept (true) __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
# 293 "/usr/include/string.h" 3 4
extern size_t strcspn (const char *__s, const char *__reject)
     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern size_t strspn (const char *__s, const char *__accept)
     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern "C++"
{
extern char *strpbrk (char *__s, const char *__accept)
     noexcept (true) __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern const char *strpbrk (const char *__s, const char *__accept)
     noexcept (true) __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char *
strpbrk (char *__s, const char *__accept) noexcept (true)
{
  return __builtin_strpbrk (__s, __accept);
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char *
strpbrk (const char *__s, const char *__accept) noexcept (true)
{
  return __builtin_strpbrk (__s, __accept);
}

}






extern "C++"
{
extern char *strstr (char *__haystack, const char *__needle)
     noexcept (true) __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern const char *strstr (const char *__haystack, const char *__needle)
     noexcept (true) __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char *
strstr (char *__haystack, const char *__needle) noexcept (true)
{
  return __builtin_strstr (__haystack, __needle);
}

extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char *
strstr (const char *__haystack, const char *__needle) noexcept (true)
{
  return __builtin_strstr (__haystack, __needle);
}

}







extern char *strtok (char *__restrict __s, const char *__restrict __delim)
     noexcept (true) __attribute__ ((__nonnull__ (2)));



extern char *__strtok_r (char *__restrict __s,
    const char *__restrict __delim,
    char **__restrict __save_ptr)
     noexcept (true) __attribute__ ((__nonnull__ (2, 3)));

extern char *strtok_r (char *__restrict __s, const char *__restrict __delim,
         char **__restrict __save_ptr)
     noexcept (true) __attribute__ ((__nonnull__ (2, 3)));





extern "C++" char *strcasestr (char *__haystack, const char *__needle)
     noexcept (true) __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern "C++" const char *strcasestr (const char *__haystack,
         const char *__needle)
     noexcept (true) __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
# 389 "/usr/include/string.h" 3 4
extern void *memmem (const void *__haystack, size_t __haystacklen,
       const void *__needle, size_t __needlelen)
     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 3)))

                                         ;



extern void *__mempcpy (void *__restrict __dest,
   const void *__restrict __src, size_t __n)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
extern void *mempcpy (void *__restrict __dest,
        const void *__restrict __src, size_t __n)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));




extern size_t strlen (const char *__s)
     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));




extern size_t strnlen (const char *__string, size_t __maxlen)
     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));




extern char *strerror (int __errnum) noexcept (true);
# 444 "/usr/include/string.h" 3 4
extern char *strerror_r (int __errnum, char *__buf, size_t __buflen)
     noexcept (true) __attribute__ ((__nonnull__ (2))) ;




extern const char *strerrordesc_np (int __err) noexcept (true);

extern const char *strerrorname_np (int __err) noexcept (true);





extern char *strerror_l (int __errnum, locale_t __l) noexcept (true);



# 1 "/usr/include/strings.h" 1 3 4
# 23 "/usr/include/strings.h" 3 4
# 1 "/usr/bin/../lib/clang/18/include/stddef.h" 1 3 4
# 77 "/usr/bin/../lib/clang/18/include/stddef.h" 3 4
# 1 "/usr/bin/../lib/clang/18/include/__stddef_size_t.h" 1 3 4
# 18 "/usr/bin/../lib/clang/18/include/__stddef_size_t.h" 3 4
typedef long unsigned int size_t;
# 78 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3 4
# 24 "/usr/include/strings.h" 2 3 4






extern "C" {



extern int bcmp (const void *__s1, const void *__s2, size_t __n)
     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern void bcopy (const void *__src, void *__dest, size_t __n)
  noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern void bzero (void *__s, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1)));
# 68 "/usr/include/strings.h" 3 4
extern char *index (const char *__s, int __c)
     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));
# 96 "/usr/include/strings.h" 3 4
extern char *rindex (const char *__s, int __c)
     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1)));






extern int ffs (int __i) noexcept (true) __attribute__ ((__const__));





extern int ffsl (long int __l) noexcept (true) __attribute__ ((__const__));
__extension__ extern int ffsll (long long int __ll)
     noexcept (true) __attribute__ ((__const__));



extern int strcasecmp (const char *__s1, const char *__s2)
     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern int strncasecmp (const char *__s1, const char *__s2, size_t __n)
     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));






extern int strcasecmp_l (const char *__s1, const char *__s2, locale_t __loc)
     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3)));



extern int strncasecmp_l (const char *__s1, const char *__s2,
     size_t __n, locale_t __loc)
     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 4)));


}
# 463 "/usr/include/string.h" 2 3 4



extern void explicit_bzero (void *__s, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1)))
                                                  ;



extern char *strsep (char **__restrict __stringp,
       const char *__restrict __delim)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));




extern char *strsignal (int __sig) noexcept (true);



extern const char *sigabbrev_np (int __sig) noexcept (true);


extern const char *sigdescr_np (int __sig) noexcept (true);



extern char *__stpcpy (char *__restrict __dest, const char *__restrict __src)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
extern char *stpcpy (char *__restrict __dest, const char *__restrict __src)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));



extern char *__stpncpy (char *__restrict __dest,
   const char *__restrict __src, size_t __n)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
extern char *stpncpy (char *__restrict __dest,
        const char *__restrict __src, size_t __n)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));




extern size_t strlcpy (char *__restrict __dest,
         const char *__restrict __src, size_t __n)
  noexcept (true) __attribute__ ((__nonnull__ (1, 2))) ;



extern size_t strlcat (char *__restrict __dest,
         const char *__restrict __src, size_t __n)
  noexcept (true) __attribute__ ((__nonnull__ (1, 2))) ;




extern int strverscmp (const char *__s1, const char *__s2)
     noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));


extern char *strfry (char *__string) noexcept (true) __attribute__ ((__nonnull__ (1)));


extern void *memfrob (void *__s, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1)))
                                          ;







extern "C++" char *basename (char *__filename)
     noexcept (true) __asm ("basename") __attribute__ ((__nonnull__ (1)));
extern "C++" const char *basename (const char *__filename)
     noexcept (true) __asm ("basename") __attribute__ ((__nonnull__ (1)));
# 552 "/usr/include/string.h" 3 4
}
# 44 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 2 3
# 72 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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;
# 126 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 3
}
}
# 29 "/home/avi/scylla-maint/seastar/include/seastar/core/future.hh" 2
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/functional" 1 3
# 47 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/functional" 3
# 59 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/functional" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/std_function.h" 1 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/std_function.h" 3
# 45 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/std_function.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{







  class bad_function_call : public std::exception
  {
  public:
    virtual ~bad_function_call() noexcept;

    const char* what() const noexcept;
  };







  template<typename _Tp>
    struct __is_location_invariant
    : is_trivially_copyable<_Tp>::type
    { };

  class _Undefined_class;

  union _Nocopy_types
  {
    void* _M_object;
    const void* _M_const_object;
    void (*_M_function_pointer)();
    void (_Undefined_class::*_M_member_pointer)();
  };

  union [[gnu::may_alias]] _Any_data
  {
    void* _M_access() noexcept { return &_M_pod_data[0]; }
    const void* _M_access() const noexcept { return &_M_pod_data[0]; }

    template<typename _Tp>
      _Tp&
      _M_access() noexcept
      { return *static_cast<_Tp*>(_M_access()); }

    template<typename _Tp>
      const _Tp&
      _M_access() const noexcept
      { return *static_cast<const _Tp*>(_M_access()); }

    _Nocopy_types _M_unused;
    char _M_pod_data[sizeof(_Nocopy_types)];
  };

  enum _Manager_operation
  {
    __get_type_info,
    __get_functor_ptr,
    __clone_functor,
    __destroy_functor
  };

  template<typename _Signature>
    class function;


  class _Function_base
  {
  public:
    static const size_t _M_max_size = sizeof(_Nocopy_types);
    static const size_t _M_max_align = __alignof__(_Nocopy_types);

    template<typename _Functor>
      class _Base_manager
      {
      protected:
 static const bool __stored_locally =
 (__is_location_invariant<_Functor>::value
  && sizeof(_Functor) <= _M_max_size
  && __alignof__(_Functor) <= _M_max_align
  && (_M_max_align % __alignof__(_Functor) == 0));

 using _Local_storage = integral_constant<bool, __stored_locally>;


 static _Functor*
 _M_get_pointer(const _Any_data& __source) noexcept
 {
   if constexpr (__stored_locally)
     {
       const _Functor& __f = __source._M_access<_Functor>();
       return const_cast<_Functor*>(std::__addressof(__f));
     }
   else
     return __source._M_access<_Functor*>();
 }

      private:


 template<typename _Fn>
   static void
   _M_create(_Any_data& __dest, _Fn&& __f, true_type)
   {
     ::new (__dest._M_access()) _Functor(std::forward<_Fn>(__f));
   }


 template<typename _Fn>
   static void
   _M_create(_Any_data& __dest, _Fn&& __f, false_type)
   {
     __dest._M_access<_Functor*>()
       = new _Functor(std::forward<_Fn>(__f));
   }


 static void
 _M_destroy(_Any_data& __victim, true_type)
 {
   __victim._M_access<_Functor>().~_Functor();
 }


 static void
 _M_destroy(_Any_data& __victim, false_type)
 {
   delete __victim._M_access<_Functor*>();
 }

      public:
 static bool
 _M_manager(_Any_data& __dest, const _Any_data& __source,
     _Manager_operation __op)
 {
   switch (__op)
     {
     case __get_type_info:

       __dest._M_access<const type_info*>() = &typeid(_Functor);



       break;

     case __get_functor_ptr:
       __dest._M_access<_Functor*>() = _M_get_pointer(__source);
       break;

     case __clone_functor:
       _M_init_functor(__dest,
    *const_cast<const _Functor*>(_M_get_pointer(__source)));
       break;

     case __destroy_functor:
       _M_destroy(__dest, _Local_storage());
       break;
     }
   return false;
 }

 template<typename _Fn>
   static void
   _M_init_functor(_Any_data& __functor, _Fn&& __f)
   noexcept(__and_<_Local_storage,
     is_nothrow_constructible<_Functor, _Fn>>::value)
   {
     _M_create(__functor, std::forward<_Fn>(__f), _Local_storage());
   }

 template<typename _Signature>
   static bool
   _M_not_empty_function(const function<_Signature>& __f) noexcept
   { return static_cast<bool>(__f); }

 template<typename _Tp>
   static bool
   _M_not_empty_function(_Tp* __fp) noexcept
   { return __fp != nullptr; }

 template<typename _Class, typename _Tp>
   static bool
   _M_not_empty_function(_Tp _Class::* __mp) noexcept
   { return __mp != nullptr; }

 template<typename _Tp>
   static bool
   _M_not_empty_function(const _Tp&) noexcept
   { return true; }
      };

    _Function_base() = default;

    ~_Function_base()
    {
      if (_M_manager)
 _M_manager(_M_functor, _M_functor, __destroy_functor);
    }

    bool _M_empty() const { return !_M_manager; }

    using _Manager_type
      = bool (*)(_Any_data&, const _Any_data&, _Manager_operation);

    _Any_data _M_functor{};
    _Manager_type _M_manager{};
  };

  template<typename _Signature, typename _Functor>
    class _Function_handler;

  template<typename _Res, typename _Functor, typename... _ArgTypes>
    class _Function_handler<_Res(_ArgTypes...), _Functor>
    : public _Function_base::_Base_manager<_Functor>
    {
      using _Base = _Function_base::_Base_manager<_Functor>;

    public:
      static bool
      _M_manager(_Any_data& __dest, const _Any_data& __source,
   _Manager_operation __op)
      {
 switch (__op)
   {

   case __get_type_info:
     __dest._M_access<const type_info*>() = &typeid(_Functor);
     break;

   case __get_functor_ptr:
     __dest._M_access<_Functor*>() = _Base::_M_get_pointer(__source);
     break;

   default:
     _Base::_M_manager(__dest, __source, __op);
   }
 return false;
      }

      static _Res
      _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
      {
 return std::__invoke_r<_Res>(*_Base::_M_get_pointer(__functor),
         std::forward<_ArgTypes>(__args)...);
      }

      template<typename _Fn>
 static constexpr bool
 _S_nothrow_init() noexcept
 {
   return __and_<typename _Base::_Local_storage,
   is_nothrow_constructible<_Functor, _Fn>>::value;
 }
    };


  template<>
    class _Function_handler<void, void>
    {
    public:
      static bool
      _M_manager(_Any_data&, const _Any_data&, _Manager_operation)
      { return false; }
    };





  template<typename _Signature, typename _Functor,
    bool __valid = is_object<_Functor>::value>
    struct _Target_handler
    : _Function_handler<_Signature, typename remove_cv<_Functor>::type>
    { };

  template<typename _Signature, typename _Functor>
    struct _Target_handler<_Signature, _Functor, false>
    : _Function_handler<void, void>
    { };






  template<typename _Res, typename... _ArgTypes>
    class function<_Res(_ArgTypes...)>
    : public _Maybe_unary_or_binary_function<_Res, _ArgTypes...>,
      private _Function_base
    {


      template<typename _Func,
        bool _Self = is_same<__remove_cvref_t<_Func>, function>::value>
 using _Decay_t
   = typename __enable_if_t<!_Self, decay<_Func>>::type;

      template<typename _Func,
        typename _DFunc = _Decay_t<_Func>,
        typename _Res2 = __invoke_result<_DFunc&, _ArgTypes...>>
 struct _Callable
 : __is_invocable_impl<_Res2, _Res>::type
 { };

      template<typename _Cond, typename _Tp = void>
 using _Requires = __enable_if_t<_Cond::value, _Tp>;

      template<typename _Functor>
 using _Handler
   = _Function_handler<_Res(_ArgTypes...), __decay_t<_Functor>>;

    public:
      typedef _Res result_type;







      function() noexcept
      : _Function_base() { }





      function(nullptr_t) noexcept
      : _Function_base() { }
# 386 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/std_function.h" 3
      function(const function& __x)
      : _Function_base()
      {
 if (static_cast<bool>(__x))
   {
     __x._M_manager(_M_functor, __x._M_functor, __clone_functor);
     _M_invoker = __x._M_invoker;
     _M_manager = __x._M_manager;
   }
      }
# 404 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/std_function.h" 3
      function(function&& __x) noexcept
      : _Function_base(), _M_invoker(__x._M_invoker)
      {
 if (static_cast<bool>(__x))
   {
     _M_functor = __x._M_functor;
     _M_manager = __x._M_manager;
     __x._M_manager = nullptr;
     __x._M_invoker = nullptr;
   }
      }
# 433 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/std_function.h" 3
      template<typename _Functor,
        typename _Constraints = _Requires<_Callable<_Functor>>>
 function(_Functor&& __f)
 noexcept(_Handler<_Functor>::template _S_nothrow_init<_Functor>())
 : _Function_base()
 {
   static_assert(is_copy_constructible<__decay_t<_Functor>>::value,
       "std::function target must be copy-constructible");
   static_assert(is_constructible<__decay_t<_Functor>, _Functor>::value,
       "std::function target must be constructible from the "
       "constructor argument");

   using _My_handler = _Handler<_Functor>;

   if (_My_handler::_M_not_empty_function(__f))
     {
       _My_handler::_M_init_functor(_M_functor,
        std::forward<_Functor>(__f));
       _M_invoker = &_My_handler::_M_invoke;
       _M_manager = &_My_handler::_M_manager;
     }
 }
# 468 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/std_function.h" 3
      function&
      operator=(const function& __x)
      {
 function(__x).swap(*this);
 return *this;
      }
# 486 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/std_function.h" 3
      function&
      operator=(function&& __x) noexcept
      {
 function(std::move(__x)).swap(*this);
 return *this;
      }
# 500 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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;
      }
# 529 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/std_function.h" 3
      template<typename _Functor>
 _Requires<_Callable<_Functor>, function&>
 operator=(_Functor&& __f)
 noexcept(_Handler<_Functor>::template _S_nothrow_init<_Functor>())
 {
   function(std::forward<_Functor>(__f)).swap(*this);
   return *this;
 }


      template<typename _Functor>
 function&
 operator=(reference_wrapper<_Functor> __f) noexcept
 {
   function(__f).swap(*this);
   return *this;
 }
# 556 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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);
      }
# 573 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/std_function.h" 3
      explicit operator bool() const noexcept
      { return !_M_empty(); }
# 586 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/std_function.h" 3
      _Res
      operator()(_ArgTypes... __args) const
      {
 if (_M_empty())
   __throw_bad_function_call();
 return _M_invoker(_M_functor, std::forward<_ArgTypes>(__args)...);
      }
# 605 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/std_function.h" 3
      const type_info&
      target_type() const noexcept
      {
 if (_M_manager)
   {
     _Any_data __typeinfo_result;
     _M_manager(__typeinfo_result, _M_functor, __get_type_info);
     if (auto __ti = __typeinfo_result._M_access<const type_info*>())
       return *__ti;
   }
 return typeid(void);
      }
# 630 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/std_function.h" 3
      template<typename _Functor>
 _Functor*
 target() noexcept
 {
   const function* __const_this = this;
   const _Functor* __func = __const_this->template target<_Functor>();


   return *const_cast<_Functor**>(&__func);
 }

      template<typename _Functor>
 const _Functor*
 target() const noexcept
 {
   if constexpr (is_object<_Functor>::value)
     {


       using _Handler = _Target_handler<_Res(_ArgTypes...), _Functor>;

       if (_M_manager == &_Handler::_M_manager

    || (_M_manager && typeid(_Functor) == target_type())

   )
  {
    _Any_data __ptr;
    _M_manager(__ptr, _M_functor, __get_functor_ptr);
    return __ptr._M_access<const _Functor*>();
  }
     }
   return nullptr;
 }


    private:
      using _Invoker_type = _Res (*)(const _Any_data&, _ArgTypes&&...);
      _Invoker_type _M_invoker = nullptr;
    };


  template<typename>
    struct __function_guide_helper
    { };

  template<typename _Res, typename _Tp, bool _Nx, typename... _Args>
    struct __function_guide_helper<
      _Res (_Tp::*) (_Args...) noexcept(_Nx)
    >
    { using type = _Res(_Args...); };

  template<typename _Res, typename _Tp, bool _Nx, typename... _Args>
    struct __function_guide_helper<
      _Res (_Tp::*) (_Args...) & noexcept(_Nx)
    >
    { using type = _Res(_Args...); };

  template<typename _Res, typename _Tp, bool _Nx, typename... _Args>
    struct __function_guide_helper<
      _Res (_Tp::*) (_Args...) const noexcept(_Nx)
    >
    { using type = _Res(_Args...); };

  template<typename _Res, typename _Tp, bool _Nx, typename... _Args>
    struct __function_guide_helper<
      _Res (_Tp::*) (_Args...) const & noexcept(_Nx)
    >
    { using type = _Res(_Args...); };
# 721 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/std_function.h" 3
  template<typename _Fn, typename _Op>
    using __function_guide_t = typename __function_guide_helper<_Op>::type;


  template<typename _Res, typename... _ArgTypes>
    function(_Res(*)(_ArgTypes...)) -> function<_Res(_ArgTypes...)>;

  template<typename _Fn, typename _Signature
      = __function_guide_t<_Fn, decltype(&_Fn::operator())>>
    function(_Fn) -> function<_Signature>;
# 741 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/std_function.h" 3
  template<typename _Res, typename... _Args>
    inline bool
    operator==(const function<_Res(_Args...)>& __f, nullptr_t) noexcept
    { return !static_cast<bool>(__f); }
# 780 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/std_function.h" 3
  template<typename _Res, typename... _Args>
    inline void
    swap(function<_Res(_Args...)>& __x, function<_Res(_Args...)>& __y) noexcept
    { __x.swap(__y); }


  namespace __detail::__variant
  {
    template<typename> struct _Never_valueless_alt;



    template<typename _Signature>
      struct _Never_valueless_alt<std::function<_Signature>>
      : std::true_type
      { };
  }



}
# 60 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/functional" 2 3




# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/vector" 1 3
# 59 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/vector" 3






# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_uninitialized.h" 1 3
# 70 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_uninitialized.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 81 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_uninitialized.h" 3
  template<typename _ValueType, typename _Tp>
    constexpr bool
    __check_constructible()
    {





      static_assert(is_constructible<_ValueType, _Tp>::value,
   "result type must be constructible from input type");

      return true;
    }
# 110 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_uninitialized.h" 3
  template<typename _InputIterator, typename _ForwardIterator>
    constexpr
    _ForwardIterator
    __do_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<bool _TrivialValueTypes>
    struct __uninitialized_copy
    {
      template<typename _InputIterator, typename _ForwardIterator>
        static _ForwardIterator
        __uninit_copy(_InputIterator __first, _InputIterator __last,
        _ForwardIterator __result)
 { return std::__do_uninit_copy(__first, __last, __result); }
    };

  template<>
    struct __uninitialized_copy<true>
    {
      template<typename _InputIterator, typename _ForwardIterator>
        static _ForwardIterator
        __uninit_copy(_InputIterator __first, _InputIterator __last,
        _ForwardIterator __result)
        { return std::copy(__first, __last, __result); }
    };
# 161 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_uninitialized.h" 3
  template<typename _InputIterator, typename _ForwardIterator>
    inline _ForwardIterator
    uninitialized_copy(_InputIterator __first, _InputIterator __last,
         _ForwardIterator __result)
    {
      typedef typename iterator_traits<_InputIterator>::value_type
 _ValueType1;
      typedef typename iterator_traits<_ForwardIterator>::value_type
 _ValueType2;




      const bool __can_memmove = __is_trivial(_ValueType1);




      using _From = decltype(*__first);

      const bool __assignable
 = __is_trivial(_ValueType2) && __is_assignable(_ValueType2&, _From) && std::__check_constructible<_ValueType2, _From>();

      return std::__uninitialized_copy<__can_memmove && __assignable>::
 __uninit_copy(__first, __last, __result);
    }



  template<typename _ForwardIterator, typename _Tp>
    constexpr void
    __do_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<bool _TrivialValueType>
    struct __uninitialized_fill
    {
      template<typename _ForwardIterator, typename _Tp>
        static void
        __uninit_fill(_ForwardIterator __first, _ForwardIterator __last,
        const _Tp& __x)
 { std::__do_uninit_fill(__first, __last, __x); }
    };

  template<>
    struct __uninitialized_fill<true>
    {
      template<typename _ForwardIterator, typename _Tp>
        static void
        __uninit_fill(_ForwardIterator __first, _ForwardIterator __last,
        const _Tp& __x)
        { std::fill(__first, __last, __x); }
    };
# 239 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_uninitialized.h" 3
  template<typename _ForwardIterator, typename _Tp>
    inline void
    uninitialized_fill(_ForwardIterator __first, _ForwardIterator __last,
         const _Tp& __x)
    {
      typedef typename iterator_traits<_ForwardIterator>::value_type
 _ValueType;



      const bool __can_fill
 = __is_trivial(_ValueType) && __is_assignable(_ValueType&, const _Tp&) && std::__check_constructible<_ValueType, const _Tp&>();

      std::__uninitialized_fill<__can_fill>::
 __uninit_fill(__first, __last, __x);
    }



  template<typename _ForwardIterator, typename _Size, typename _Tp>
    constexpr
    _ForwardIterator
    __do_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<bool _TrivialValueType>
    struct __uninitialized_fill_n
    {
      template<typename _ForwardIterator, typename _Size, typename _Tp>
 static _ForwardIterator
        __uninit_fill_n(_ForwardIterator __first, _Size __n,
   const _Tp& __x)
 { return std::__do_uninit_fill_n(__first, __n, __x); }
    };

  template<>
    struct __uninitialized_fill_n<true>
    {
      template<typename _ForwardIterator, typename _Size, typename _Tp>
 static _ForwardIterator
        __uninit_fill_n(_ForwardIterator __first, _Size __n,
   const _Tp& __x)
        { return std::fill_n(__first, __n, __x); }
    };
# 310 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_uninitialized.h" 3
  template<typename _ForwardIterator, typename _Size, typename _Tp>
    inline _ForwardIterator
    uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x)
    {
      typedef typename iterator_traits<_ForwardIterator>::value_type
 _ValueType;



      const bool __can_fill
 = __is_trivial(_ValueType) && __is_assignable(_ValueType&, const _Tp&) && std::__check_constructible<_ValueType, const _Tp&>()



 && __is_integer<_Size>::__value;

      return __uninitialized_fill_n<__can_fill>::
 __uninit_fill_n(__first, __n, __x);
    }
# 340 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_uninitialized.h" 3
  template<typename _InputIterator, typename _ForwardIterator,
    typename _Allocator>
    constexpr
    _ForwardIterator
    __uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
      _ForwardIterator __result, _Allocator& __alloc)
    {
      _ForwardIterator __cur = __result;
      try
 {
   typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
   for (; __first != __last; ++__first, (void)++__cur)
     __traits::construct(__alloc, std::__addressof(*__cur), *__first);
   return __cur;
 }
      catch(...)
 {
   std::_Destroy(__result, __cur, __alloc);
   throw;
 }
    }


  template<typename _InputIterator, typename _ForwardIterator, typename _Tp>
    constexpr
    inline _ForwardIterator
    __uninitialized_copy_a(_InputIterator __first, _InputIterator __last,
      _ForwardIterator __result, allocator<_Tp>&)
    {

      if (std::is_constant_evaluated())
 return std::__do_uninit_copy(__first, __last, __result);

      return std::uninitialized_copy(__first, __last, __result);
    }


  template<typename _InputIterator, typename _ForwardIterator,
    typename _Allocator>
    constexpr
    inline _ForwardIterator
    __uninitialized_move_a(_InputIterator __first, _InputIterator __last,
      _ForwardIterator __result, _Allocator& __alloc)
    {
      return std::__uninitialized_copy_a(std::make_move_iterator(__first),
      std::make_move_iterator(__last),
      __result, __alloc);
    }

  template<typename _InputIterator, typename _ForwardIterator,
    typename _Allocator>
    constexpr
    inline _ForwardIterator
    __uninitialized_move_if_noexcept_a(_InputIterator __first,
           _InputIterator __last,
           _ForwardIterator __result,
           _Allocator& __alloc)
    {
      return std::__uninitialized_copy_a
 (std::__make_move_if_noexcept_iterator(__first),
  std::__make_move_if_noexcept_iterator(__last), __result, __alloc);
    }

  template<typename _ForwardIterator, typename _Tp, typename _Allocator>
    constexpr
    void
    __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
      const _Tp& __x, _Allocator& __alloc)
    {
      _ForwardIterator __cur = __first;
      try
 {
   typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
   for (; __cur != __last; ++__cur)
     __traits::construct(__alloc, std::__addressof(*__cur), __x);
 }
      catch(...)
 {
   std::_Destroy(__first, __cur, __alloc);
   throw;
 }
    }


  template<typename _ForwardIterator, typename _Tp, typename _Tp2>
    constexpr
    inline void
    __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last,
      const _Tp& __x, allocator<_Tp2>&)
    {

      if (std::is_constant_evaluated())
 return std::__do_uninit_fill(__first, __last, __x);

      std::uninitialized_fill(__first, __last, __x);
    }


  template<typename _ForwardIterator, typename _Size, typename _Tp,
    typename _Allocator>
     constexpr
    _ForwardIterator
    __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
        const _Tp& __x, _Allocator& __alloc)
    {
      _ForwardIterator __cur = __first;
      try
 {
   typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
   for (; __n > 0; --__n, (void) ++__cur)
     __traits::construct(__alloc, std::__addressof(*__cur), __x);
   return __cur;
 }
      catch(...)
 {
   std::_Destroy(__first, __cur, __alloc);
   throw;
 }
    }


  template<typename _ForwardIterator, typename _Size, typename _Tp,
    typename _Tp2>
    constexpr
    inline _ForwardIterator
    __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n,
        const _Tp& __x, allocator<_Tp2>&)
    {

      if (std::is_constant_evaluated())
 return std::__do_uninit_fill_n(__first, __n, __x);

      return std::uninitialized_fill_n(__first, __n, __x);
    }
# 485 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_uninitialized.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _ForwardIterator, typename _Allocator>
    inline _ForwardIterator
    __uninitialized_copy_move(_InputIterator1 __first1,
         _InputIterator1 __last1,
         _InputIterator2 __first2,
         _InputIterator2 __last2,
         _ForwardIterator __result,
         _Allocator& __alloc)
    {
      _ForwardIterator __mid = std::__uninitialized_copy_a(__first1, __last1,
          __result,
          __alloc);
      try
 {
   return std::__uninitialized_move_a(__first2, __last2, __mid, __alloc);
 }
      catch(...)
 {
   std::_Destroy(__result, __mid, __alloc);
   throw;
 }
    }





  template<typename _InputIterator1, typename _InputIterator2,
    typename _ForwardIterator, typename _Allocator>
    inline _ForwardIterator
    __uninitialized_move_copy(_InputIterator1 __first1,
         _InputIterator1 __last1,
         _InputIterator2 __first2,
         _InputIterator2 __last2,
         _ForwardIterator __result,
         _Allocator& __alloc)
    {
      _ForwardIterator __mid = std::__uninitialized_move_a(__first1, __last1,
          __result,
          __alloc);
      try
 {
   return std::__uninitialized_copy_a(__first2, __last2, __mid, __alloc);
 }
      catch(...)
 {
   std::_Destroy(__result, __mid, __alloc);
   throw;
 }
    }




  template<typename _ForwardIterator, typename _Tp, typename _InputIterator,
    typename _Allocator>
    inline _ForwardIterator
    __uninitialized_fill_move(_ForwardIterator __result, _ForwardIterator __mid,
         const _Tp& __x, _InputIterator __first,
         _InputIterator __last, _Allocator& __alloc)
    {
      std::__uninitialized_fill_a(__result, __mid, __x, __alloc);
      try
 {
   return std::__uninitialized_move_a(__first, __last, __mid, __alloc);
 }
      catch(...)
 {
   std::_Destroy(__result, __mid, __alloc);
   throw;
 }
    }




  template<typename _InputIterator, typename _ForwardIterator, typename _Tp,
    typename _Allocator>
    inline void
    __uninitialized_move_fill(_InputIterator __first1, _InputIterator __last1,
         _ForwardIterator __first2,
         _ForwardIterator __last2, const _Tp& __x,
         _Allocator& __alloc)
    {
      _ForwardIterator __mid2 = std::__uninitialized_move_a(__first1, __last1,
           __first2,
           __alloc);
      try
 {
   std::__uninitialized_fill_a(__mid2, __last2, __x, __alloc);
 }
      catch(...)
 {
   std::_Destroy(__first2, __mid2, __alloc);
   throw;
 }
    }
# 592 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_uninitialized.h" 3
  template<bool _TrivialValueType>
    struct __uninitialized_default_1
    {
      template<typename _ForwardIterator>
        static void
        __uninit_default(_ForwardIterator __first, _ForwardIterator __last)
        {
   _ForwardIterator __cur = __first;
   try
     {
       for (; __cur != __last; ++__cur)
  std::_Construct(std::__addressof(*__cur));
     }
   catch(...)
     {
       std::_Destroy(__first, __cur);
       throw;
     }
 }
    };

  template<>
    struct __uninitialized_default_1<true>
    {
      template<typename _ForwardIterator>
        static void
        __uninit_default(_ForwardIterator __first, _ForwardIterator __last)
        {
   if (__first == __last)
     return;

   typename iterator_traits<_ForwardIterator>::value_type* __val
     = std::__addressof(*__first);
   std::_Construct(__val);
   if (++__first != __last)
     std::fill(__first, __last, *__val);
 }
    };

  template<bool _TrivialValueType>
    struct __uninitialized_default_n_1
    {
      template<typename _ForwardIterator, typename _Size>
 constexpr
        static _ForwardIterator
        __uninit_default_n(_ForwardIterator __first, _Size __n)
        {
   _ForwardIterator __cur = __first;
   try
     {
       for (; __n > 0; --__n, (void) ++__cur)
  std::_Construct(std::__addressof(*__cur));
       return __cur;
     }
   catch(...)
     {
       std::_Destroy(__first, __cur);
       throw;
     }
 }
    };

  template<>
    struct __uninitialized_default_n_1<true>
    {
      template<typename _ForwardIterator, typename _Size>
 constexpr
        static _ForwardIterator
        __uninit_default_n(_ForwardIterator __first, _Size __n)
        {
   if (__n > 0)
     {
       typename iterator_traits<_ForwardIterator>::value_type* __val
  = std::__addressof(*__first);
       std::_Construct(__val);
       ++__first;
       __first = std::fill_n(__first, __n - 1, *__val);
     }
   return __first;
 }
    };



  template<typename _ForwardIterator>
    inline void
    __uninitialized_default(_ForwardIterator __first,
       _ForwardIterator __last)
    {
      typedef typename iterator_traits<_ForwardIterator>::value_type
 _ValueType;

      const bool __assignable = is_copy_assignable<_ValueType>::value;

      std::__uninitialized_default_1<__is_trivial(_ValueType)
         && __assignable>::
 __uninit_default(__first, __last);
    }



  template<typename _ForwardIterator, typename _Size>
    constexpr
    inline _ForwardIterator
    __uninitialized_default_n(_ForwardIterator __first, _Size __n)
    {

      if (std::is_constant_evaluated())
 return __uninitialized_default_n_1<false>::
   __uninit_default_n(__first, __n);


      typedef typename iterator_traits<_ForwardIterator>::value_type
 _ValueType;

      constexpr bool __can_fill
 = __and_<is_integral<_Size>, is_copy_assignable<_ValueType>>::value;

      return __uninitialized_default_n_1<__is_trivial(_ValueType)
      && __can_fill>::
 __uninit_default_n(__first, __n);
    }





  template<typename _ForwardIterator, typename _Allocator>
    void
    __uninitialized_default_a(_ForwardIterator __first,
         _ForwardIterator __last,
         _Allocator& __alloc)
    {
      _ForwardIterator __cur = __first;
      try
 {
   typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
   for (; __cur != __last; ++__cur)
     __traits::construct(__alloc, std::__addressof(*__cur));
 }
      catch(...)
 {
   std::_Destroy(__first, __cur, __alloc);
   throw;
 }
    }


  template<typename _ForwardIterator, typename _Tp>
    inline void
    __uninitialized_default_a(_ForwardIterator __first,
         _ForwardIterator __last,
         allocator<_Tp>&)
    { std::__uninitialized_default(__first, __last); }





  template<typename _ForwardIterator, typename _Size, typename _Allocator>
    constexpr _ForwardIterator
    __uninitialized_default_n_a(_ForwardIterator __first, _Size __n,
    _Allocator& __alloc)
    {
      _ForwardIterator __cur = __first;
      try
 {
   typedef __gnu_cxx::__alloc_traits<_Allocator> __traits;
   for (; __n > 0; --__n, (void) ++__cur)
     __traits::construct(__alloc, std::__addressof(*__cur));
   return __cur;
 }
      catch(...)
 {
   std::_Destroy(__first, __cur, __alloc);
   throw;
 }
    }




  template<typename _ForwardIterator, typename _Size, typename _Tp>
    constexpr
    inline _ForwardIterator
    __uninitialized_default_n_a(_ForwardIterator __first, _Size __n,
    allocator<_Tp>&)
    { return std::__uninitialized_default_n(__first, __n); }


  template<bool _TrivialValueType>
    struct __uninitialized_default_novalue_1
    {
      template<typename _ForwardIterator>
 static void
 __uninit_default_novalue(_ForwardIterator __first,
     _ForwardIterator __last)
 {
   _ForwardIterator __cur = __first;
   try
     {
       for (; __cur != __last; ++__cur)
  std::_Construct_novalue(std::__addressof(*__cur));
     }
   catch(...)
     {
       std::_Destroy(__first, __cur);
       throw;
     }
 }
    };

  template<>
    struct __uninitialized_default_novalue_1<true>
    {
      template<typename _ForwardIterator>
        static void
        __uninit_default_novalue(_ForwardIterator, _ForwardIterator)
 {
 }
    };

  template<bool _TrivialValueType>
    struct __uninitialized_default_novalue_n_1
    {
      template<typename _ForwardIterator, typename _Size>
 static _ForwardIterator
 __uninit_default_novalue_n(_ForwardIterator __first, _Size __n)
 {
   _ForwardIterator __cur = __first;
   try
     {
       for (; __n > 0; --__n, (void) ++__cur)
  std::_Construct_novalue(std::__addressof(*__cur));
       return __cur;
     }
   catch(...)
     {
       std::_Destroy(__first, __cur);
       throw;
     }
 }
    };

  template<>
    struct __uninitialized_default_novalue_n_1<true>
    {
      template<typename _ForwardIterator, typename _Size>
 static _ForwardIterator
 __uninit_default_novalue_n(_ForwardIterator __first, _Size __n)
 { return std::next(__first, __n); }
    };



  template<typename _ForwardIterator>
    inline void
    __uninitialized_default_novalue(_ForwardIterator __first,
        _ForwardIterator __last)
    {
      typedef typename iterator_traits<_ForwardIterator>::value_type
 _ValueType;

      std::__uninitialized_default_novalue_1<
 is_trivially_default_constructible<_ValueType>::value>::
 __uninit_default_novalue(__first, __last);
    }



  template<typename _ForwardIterator, typename _Size>
    inline _ForwardIterator
    __uninitialized_default_novalue_n(_ForwardIterator __first, _Size __n)
    {
      typedef typename iterator_traits<_ForwardIterator>::value_type
 _ValueType;

      return __uninitialized_default_novalue_n_1<
 is_trivially_default_constructible<_ValueType>::value>::
 __uninit_default_novalue_n(__first, __n);
    }

  template<typename _InputIterator, typename _Size,
    typename _ForwardIterator>
    _ForwardIterator
    __uninitialized_copy_n(_InputIterator __first, _Size __n,
      _ForwardIterator __result, input_iterator_tag)
    {
      _ForwardIterator __cur = __result;
      try
 {
   for (; __n > 0; --__n, (void) ++__first, ++__cur)
     std::_Construct(std::__addressof(*__cur), *__first);
   return __cur;
 }
      catch(...)
 {
   std::_Destroy(__result, __cur);
   throw;
 }
    }

  template<typename _RandomAccessIterator, typename _Size,
    typename _ForwardIterator>
    inline _ForwardIterator
    __uninitialized_copy_n(_RandomAccessIterator __first, _Size __n,
      _ForwardIterator __result,
      random_access_iterator_tag)
    { return std::uninitialized_copy(__first, __first + __n, __result); }

  template<typename _InputIterator, typename _Size,
    typename _ForwardIterator>
    pair<_InputIterator, _ForwardIterator>
    __uninitialized_copy_n_pair(_InputIterator __first, _Size __n,
      _ForwardIterator __result, input_iterator_tag)
    {
      _ForwardIterator __cur = __result;
      try
 {
   for (; __n > 0; --__n, (void) ++__first, ++__cur)
     std::_Construct(std::__addressof(*__cur), *__first);
   return {__first, __cur};
 }
      catch(...)
 {
   std::_Destroy(__result, __cur);
   throw;
 }
    }

  template<typename _RandomAccessIterator, typename _Size,
    typename _ForwardIterator>
    inline pair<_RandomAccessIterator, _ForwardIterator>
    __uninitialized_copy_n_pair(_RandomAccessIterator __first, _Size __n,
      _ForwardIterator __result,
      random_access_iterator_tag)
    {
      auto __second_res = uninitialized_copy(__first, __first + __n, __result);
      auto __first_res = std::next(__first, __n);
      return {__first_res, __second_res};
    }
# 946 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_uninitialized.h" 3
  template<typename _InputIterator, typename _Size, typename _ForwardIterator>
    inline _ForwardIterator
    uninitialized_copy_n(_InputIterator __first, _Size __n,
    _ForwardIterator __result)
    { return std::__uninitialized_copy_n(__first, __n, __result,
      std::__iterator_category(__first)); }


  template<typename _InputIterator, typename _Size, typename _ForwardIterator>
    inline pair<_InputIterator, _ForwardIterator>
    __uninitialized_copy_n_pair(_InputIterator __first, _Size __n,
         _ForwardIterator __result)
    {
      return
 std::__uninitialized_copy_n_pair(__first, __n, __result,
      std::__iterator_category(__first));
    }
# 973 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_uninitialized.h" 3
  template <typename _ForwardIterator>
    inline void
    uninitialized_default_construct(_ForwardIterator __first,
        _ForwardIterator __last)
    {
      __uninitialized_default_novalue(__first, __last);
    }
# 988 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_uninitialized.h" 3
  template <typename _ForwardIterator, typename _Size>
    inline _ForwardIterator
    uninitialized_default_construct_n(_ForwardIterator __first, _Size __count)
    {
      return __uninitialized_default_novalue_n(__first, __count);
    }







  template <typename _ForwardIterator>
    inline void
    uninitialized_value_construct(_ForwardIterator __first,
      _ForwardIterator __last)
    {
      return __uninitialized_default(__first, __last);
    }
# 1016 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_uninitialized.h" 3
  template <typename _ForwardIterator, typename _Size>
    inline _ForwardIterator
    uninitialized_value_construct_n(_ForwardIterator __first, _Size __count)
    {
      return __uninitialized_default_n(__first, __count);
    }
# 1031 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_uninitialized.h" 3
  template <typename _InputIterator, typename _ForwardIterator>
    inline _ForwardIterator
    uninitialized_move(_InputIterator __first, _InputIterator __last,
         _ForwardIterator __result)
    {
      return std::uninitialized_copy
 (std::make_move_iterator(__first),
  std::make_move_iterator(__last), __result);
    }
# 1049 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_uninitialized.h" 3
  template <typename _InputIterator, typename _Size, typename _ForwardIterator>
    inline pair<_InputIterator, _ForwardIterator>
    uninitialized_move_n(_InputIterator __first, _Size __count,
    _ForwardIterator __result)
    {
      auto __res = std::__uninitialized_copy_n_pair
 (std::make_move_iterator(__first),
  __count, __result);
      return {__res.first.base(), __res.second};
    }





  template<typename _Tp, typename _Up, typename _Allocator>
    constexpr
    inline void
    __relocate_object_a(_Tp* __restrict __dest, _Up* __restrict __orig,
   _Allocator& __alloc)
    noexcept(noexcept(std::allocator_traits<_Allocator>::construct(__alloc,
    __dest, std::move(*__orig)))
      && noexcept(std::allocator_traits<_Allocator>::destroy(
       __alloc, std::__addressof(*__orig))))
    {
      typedef std::allocator_traits<_Allocator> __traits;
      __traits::construct(__alloc, __dest, std::move(*__orig));
      __traits::destroy(__alloc, std::__addressof(*__orig));
    }



  template<typename _Tp, typename = void>
    struct __is_bitwise_relocatable
    : is_trivial<_Tp> { };

  template <typename _InputIterator, typename _ForwardIterator,
     typename _Allocator>
    constexpr
    inline _ForwardIterator
    __relocate_a_1(_InputIterator __first, _InputIterator __last,
     _ForwardIterator __result, _Allocator& __alloc)
    noexcept(noexcept(std::__relocate_object_a(std::addressof(*__result),
            std::addressof(*__first),
            __alloc)))
    {
      typedef typename iterator_traits<_InputIterator>::value_type
 _ValueType;
      typedef typename iterator_traits<_ForwardIterator>::value_type
 _ValueType2;
      static_assert(std::is_same<_ValueType, _ValueType2>::value,
   "relocation is only possible for values of the same type");
      _ForwardIterator __cur = __result;
      for (; __first != __last; ++__first, (void)++__cur)
 std::__relocate_object_a(std::__addressof(*__cur),
     std::__addressof(*__first), __alloc);
      return __cur;
    }


  template <typename _Tp, typename _Up>
    constexpr
    inline __enable_if_t<std::__is_bitwise_relocatable<_Tp>::value, _Tp*>
    __relocate_a_1(_Tp* __first, _Tp* __last,
     _Tp* __result,
     [[__maybe_unused__]] allocator<_Up>& __alloc) noexcept
    {
      ptrdiff_t __count = __last - __first;
      if (__count > 0)
 {

   if (std::is_constant_evaluated())
     {


       __gnu_cxx::__normal_iterator<_Tp*, void> __out(__result);
       __out = std::__relocate_a_1(__first, __last, __out, __alloc);
       return __out.base();
     }

   __builtin_memcpy(__result, __first, __count * sizeof(_Tp));
 }
      return __result + __count;
    }


  template <typename _InputIterator, typename _ForwardIterator,
     typename _Allocator>
    constexpr
    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 std::__relocate_a_1(std::__niter_base(__first),
     std::__niter_base(__last),
     std::__niter_base(__result), __alloc);
    }







}
# 66 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/vector" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_vector.h" 1 3
# 77 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_vector.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{




  template<typename _Tp, typename _Alloc>
    struct _Vector_base
    {
      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
 rebind<_Tp>::other _Tp_alloc_type;
      typedef typename __gnu_cxx::__alloc_traits<_Tp_alloc_type>::pointer
        pointer;

      struct _Vector_impl_data
      {
 pointer _M_start;
 pointer _M_finish;
 pointer _M_end_of_storage;

 constexpr
 _Vector_impl_data() noexcept
 : _M_start(), _M_finish(), _M_end_of_storage()
 { }


 constexpr
 _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(); }


 constexpr
 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;
 }

 constexpr
 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
      {
 constexpr
 _Vector_impl() noexcept(is_nothrow_default_constructible<_Tp_alloc_type>::value)


 requires is_default_constructible_v<_Tp_alloc_type>

 : _Tp_alloc_type()
 { }

 constexpr
 _Vector_impl(_Tp_alloc_type const& __a) noexcept
 : _Tp_alloc_type(__a)
 { }




 constexpr
 _Vector_impl(_Vector_impl&& __x) noexcept
 : _Tp_alloc_type(std::move(__x)), _Vector_impl_data(std::move(__x))
 { }

 constexpr
 _Vector_impl(_Tp_alloc_type&& __a) noexcept
 : _Tp_alloc_type(std::move(__a))
 { }

 constexpr
 _Vector_impl(_Tp_alloc_type&& __a, _Vector_impl&& __rv) noexcept
 : _Tp_alloc_type(std::move(__a)), _Vector_impl_data(std::move(__rv))
 { }
# 293 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_vector.h" 3
      };

    public:
      typedef _Alloc allocator_type;

      constexpr
      _Tp_alloc_type&
      _M_get_Tp_allocator() noexcept
      { return this->_M_impl; }

      constexpr
      const _Tp_alloc_type&
      _M_get_Tp_allocator() const noexcept
      { return this->_M_impl; }

      constexpr
      allocator_type
      get_allocator() const noexcept
      { return allocator_type(_M_get_Tp_allocator()); }


      _Vector_base() = default;




      constexpr
      _Vector_base(const allocator_type& __a) noexcept
      : _M_impl(__a) { }



      constexpr
      _Vector_base(size_t __n)
      : _M_impl()
      { _M_create_storage(__n); }


      constexpr
      _Vector_base(size_t __n, const allocator_type& __a)
      : _M_impl(__a)
      { _M_create_storage(__n); }


      _Vector_base(_Vector_base&&) = default;



      constexpr
      _Vector_base(_Tp_alloc_type&& __a) noexcept
      : _M_impl(std::move(__a)) { }

      constexpr
      _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);
   }
      }


      constexpr
      _Vector_base(const allocator_type& __a, _Vector_base&& __x)
      : _M_impl(_Tp_alloc_type(__a), std::move(__x._M_impl))
      { }


      constexpr
      ~_Vector_base() noexcept
      {
 _M_deallocate(_M_impl._M_start,
        _M_impl._M_end_of_storage - _M_impl._M_start);
      }

    public:
      _Vector_impl _M_impl;

      constexpr
      pointer
      _M_allocate(size_t __n)
      {
 typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr;
 return __n != 0 ? _Tr::allocate(_M_impl, __n) : pointer();
      }

      constexpr
      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:

      constexpr
      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;
      }
    };
# 427 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_vector.h" 3
  template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
    class vector : protected _Vector_base<_Tp, _Alloc>
    {
# 440 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_vector.h" 3
      static_assert(is_same<typename remove_cv<_Tp>::type, _Tp>::value,
   "std::vector must have a non-const, non-volatile value_type");

      static_assert(is_same<typename _Alloc::value_type, _Tp>::value,
   "std::vector must have the same value_type as its allocator");



      typedef _Vector_base<_Tp, _Alloc> _Base;
      typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;
      typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Alloc_traits;

    public:
      typedef _Tp value_type;
      typedef typename _Base::pointer pointer;
      typedef typename _Alloc_traits::const_pointer const_pointer;
      typedef typename _Alloc_traits::reference reference;
      typedef typename _Alloc_traits::const_reference const_reference;
      typedef __gnu_cxx::__normal_iterator<pointer, vector> iterator;
      typedef __gnu_cxx::__normal_iterator<const_pointer, vector>
      const_iterator;
      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
      typedef std::reverse_iterator<iterator> reverse_iterator;
      typedef size_t size_type;
      typedef ptrdiff_t difference_type;
      typedef _Alloc allocator_type;

    private:

      static constexpr bool
      _S_nothrow_relocate(true_type)
      {
 return noexcept(std::__relocate_a(std::declval<pointer>(),
       std::declval<pointer>(),
       std::declval<pointer>(),
       std::declval<_Tp_alloc_type&>()));
      }

      static constexpr bool
      _S_nothrow_relocate(false_type)
      { return false; }

      static constexpr bool
      _S_use_relocate()
      {



 return _S_nothrow_relocate(__is_move_insertable<_Tp_alloc_type>{});
      }

      static pointer
      _S_do_relocate(pointer __first, pointer __last, pointer __result,
       _Tp_alloc_type& __alloc, true_type) noexcept
      {
 return std::__relocate_a(__first, __last, __result, __alloc);
      }

      static pointer
      _S_do_relocate(pointer, pointer, pointer __result,
       _Tp_alloc_type&, false_type) noexcept
      { return __result; }

      static constexpr pointer
      _S_relocate(pointer __first, pointer __last, pointer __result,
    _Tp_alloc_type& __alloc) noexcept
      {


 return std::__relocate_a(__first, __last, __result, __alloc);




      }


    protected:
      using _Base::_M_allocate;
      using _Base::_M_deallocate;
      using _Base::_M_impl;
      using _Base::_M_get_Tp_allocator;

    public:







      vector() = default;
# 540 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_vector.h" 3
      explicit
      constexpr
      vector(const allocator_type& __a) noexcept
      : _Base(__a) { }
# 554 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_vector.h" 3
      explicit
      constexpr
      vector(size_type __n, const allocator_type& __a = allocator_type())
      : _Base(_S_check_init_len(__n, __a), __a)
      { _M_default_initialize(__n); }
# 568 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_vector.h" 3
      constexpr
      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); }
# 600 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_vector.h" 3
      constexpr
      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());
      }
# 620 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_vector.h" 3
      vector(vector&&) noexcept = default;


      constexpr
      vector(const vector& __x, const __type_identity_t<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:
      constexpr
      vector(vector&& __rv, const allocator_type& __m, true_type) noexcept
      : _Base(__m, std::move(__rv))
      { }

      constexpr
      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:

      constexpr
      vector(vector&& __rv, const __type_identity_t<allocator_type>& __m)
      noexcept( noexcept(
 vector(std::declval<vector&&>(), std::declval<const allocator_type&>(),
        std::declval<typename _Alloc_traits::is_always_equal>())) )
      : vector(std::move(__rv), __m, typename _Alloc_traits::is_always_equal{})
      { }
# 677 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_vector.h" 3
      constexpr
      vector(initializer_list<value_type> __l,
      const allocator_type& __a = allocator_type())
      : _Base(__a)
      {
 _M_range_initialize(__l.begin(), __l.end(),
       random_access_iterator_tag());
      }
# 704 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_vector.h" 3
      template<typename _InputIterator,
        typename = std::_RequireInputIter<_InputIterator>>
 constexpr
 vector(_InputIterator __first, _InputIterator __last,
        const allocator_type& __a = allocator_type())
 : _Base(__a)
 {
   _M_range_initialize(__first, __last,
         std::__iterator_category(__first));
 }
# 732 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_vector.h" 3
      constexpr
      ~vector() noexcept
      {
 std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
        _M_get_Tp_allocator());
                                      ;
      }
# 749 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_vector.h" 3
      constexpr
      vector&
      operator=(const vector& __x);
# 764 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_vector.h" 3
      constexpr
      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;
      }
# 786 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_vector.h" 3
      constexpr
      vector&
      operator=(initializer_list<value_type> __l)
      {
 this->_M_assign_aux(__l.begin(), __l.end(),
       random_access_iterator_tag());
 return *this;
      }
# 806 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_vector.h" 3
      constexpr
      void
      assign(size_type __n, const value_type& __val)
      { _M_fill_assign(__n, __val); }
# 824 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_vector.h" 3
      template<typename _InputIterator,
        typename = std::_RequireInputIter<_InputIterator>>
 constexpr
 void
 assign(_InputIterator __first, _InputIterator __last)
 { _M_assign_aux(__first, __last, std::__iterator_category(__first)); }
# 853 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_vector.h" 3
      constexpr
      void
      assign(initializer_list<value_type> __l)
      {
 this->_M_assign_aux(__l.begin(), __l.end(),
       random_access_iterator_tag());
      }



      using _Base::get_allocator;







      [[__nodiscard__]] constexpr
      iterator
      begin() noexcept
      { return iterator(this->_M_impl._M_start); }






      [[__nodiscard__]] constexpr
      const_iterator
      begin() const noexcept
      { return const_iterator(this->_M_impl._M_start); }






      [[__nodiscard__]] constexpr
      iterator
      end() noexcept
      { return iterator(this->_M_impl._M_finish); }






      [[__nodiscard__]] constexpr
      const_iterator
      end() const noexcept
      { return const_iterator(this->_M_impl._M_finish); }






      [[__nodiscard__]] constexpr
      reverse_iterator
      rbegin() noexcept
      { return reverse_iterator(end()); }






      [[__nodiscard__]] constexpr
      const_reverse_iterator
      rbegin() const noexcept
      { return const_reverse_iterator(end()); }






      [[__nodiscard__]] constexpr
      reverse_iterator
      rend() noexcept
      { return reverse_iterator(begin()); }






      [[__nodiscard__]] constexpr
      const_reverse_iterator
      rend() const noexcept
      { return const_reverse_iterator(begin()); }







      [[__nodiscard__]] constexpr
      const_iterator
      cbegin() const noexcept
      { return const_iterator(this->_M_impl._M_start); }






      [[__nodiscard__]] constexpr
      const_iterator
      cend() const noexcept
      { return const_iterator(this->_M_impl._M_finish); }






      [[__nodiscard__]] constexpr
      const_reverse_iterator
      crbegin() const noexcept
      { return const_reverse_iterator(end()); }






      [[__nodiscard__]] constexpr
      const_reverse_iterator
      crend() const noexcept
      { return const_reverse_iterator(begin()); }




      [[__nodiscard__]] constexpr
      size_type
      size() const noexcept
      { return size_type(this->_M_impl._M_finish - this->_M_impl._M_start); }


      [[__nodiscard__]] constexpr
      size_type
      max_size() const noexcept
      { return _S_max_size(_M_get_Tp_allocator()); }
# 1011 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_vector.h" 3
      constexpr
      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);
      }
# 1032 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_vector.h" 3
      constexpr
      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);
      }
# 1066 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_vector.h" 3
      constexpr
      void
      shrink_to_fit()
      { _M_shrink_to_fit(); }






      [[__nodiscard__]] constexpr
      size_type
      capacity() const noexcept
      {
 return size_type(this->_M_impl._M_end_of_storage
      - this->_M_impl._M_start);
      }





      [[__nodiscard__]] constexpr
      bool
      empty() const noexcept
      { return begin() == end(); }
# 1110 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_vector.h" 3
      constexpr
      void
      reserve(size_type __n);
# 1126 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_vector.h" 3
      [[__nodiscard__]] constexpr
      reference
      operator[](size_type __n) noexcept
      {
                                  ;
 return *(this->_M_impl._M_start + __n);
      }
# 1145 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_vector.h" 3
      [[__nodiscard__]] constexpr
      const_reference
      operator[](size_type __n) const noexcept
      {
                                  ;
 return *(this->_M_impl._M_start + __n);
      }

    protected:

      constexpr
      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:
# 1178 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_vector.h" 3
      [[__nodiscard__]] constexpr
      reference
      at(size_type __n)
      {
 _M_range_check(__n);
 return (*this)[__n];
      }
# 1197 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_vector.h" 3
      [[__nodiscard__]] constexpr
      const_reference
      at(size_type __n) const
      {
 _M_range_check(__n);
 return (*this)[__n];
      }





      [[__nodiscard__]] constexpr
      reference
      front() noexcept
      {
                              ;
 return *begin();
      }





      [[__nodiscard__]] constexpr
      const_reference
      front() const noexcept
      {
                              ;
 return *begin();
      }





      [[__nodiscard__]] constexpr
      reference
      back() noexcept
      {
                              ;
 return *(end() - 1);
      }





      [[__nodiscard__]] constexpr
      const_reference
      back() const noexcept
      {
                              ;
 return *(end() - 1);
      }
# 1260 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_vector.h" 3
      [[__nodiscard__]] constexpr
      _Tp*
      data() noexcept
      { return _M_data_ptr(this->_M_impl._M_start); }

      [[__nodiscard__]] constexpr
      const _Tp*
      data() const noexcept
      { return _M_data_ptr(this->_M_impl._M_start); }
# 1281 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_vector.h" 3
      constexpr
      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_append(__x);
      }


      constexpr
      void
      push_back(value_type&& __x)
      { emplace_back(std::move(__x)); }

      template<typename... _Args>

 constexpr
 reference



 emplace_back(_Args&&... __args);
# 1322 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_vector.h" 3
      constexpr
      void
      pop_back() noexcept
      {
                              ;
 --this->_M_impl._M_finish;
 _Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish);
                                 ;
      }
# 1345 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_vector.h" 3
      template<typename... _Args>
 constexpr
 iterator
 emplace(const_iterator __position, _Args&&... __args)
 { return _M_emplace_aux(__position, std::forward<_Args>(__args)...); }
# 1362 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_vector.h" 3
      constexpr
      iterator
      insert(const_iterator __position, const value_type& __x);
# 1393 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_vector.h" 3
      constexpr
      iterator
      insert(const_iterator __position, value_type&& __x)
      { return _M_insert_rval(__position, std::move(__x)); }
# 1411 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_vector.h" 3
      constexpr
      iterator
      insert(const_iterator __position, initializer_list<value_type> __l)
      {
 auto __offset = __position - cbegin();
 _M_range_insert(begin() + __offset, __l.begin(), __l.end(),
   std::random_access_iterator_tag());
 return begin() + __offset;
      }
# 1437 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_vector.h" 3
      constexpr
      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;
      }
# 1480 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_vector.h" 3
      template<typename _InputIterator,
        typename = std::_RequireInputIter<_InputIterator>>
 constexpr
 iterator
 insert(const_iterator __position, _InputIterator __first,
        _InputIterator __last)
 {
   difference_type __offset = __position - cbegin();
   _M_range_insert(begin() + __offset, __first, __last,
     std::__iterator_category(__first));
   return begin() + __offset;
 }
# 1533 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_vector.h" 3
      constexpr
      iterator

      erase(const_iterator __position)
      { return _M_erase(begin() + (__position - cbegin())); }
# 1561 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_vector.h" 3
      constexpr
      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));
      }
# 1586 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_vector.h" 3
      constexpr
      void
      swap(vector& __x) noexcept
      {

 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(_Alloc_traits::propagate_on_container_swap::value || _M_get_Tp_allocator() == __x._M_get_Tp_allocator()), false)) std::__glibcxx_assert_fail(); } while (false);


 this->_M_impl._M_swap_data(__x._M_impl);
 _Alloc_traits::_S_on_swap(_M_get_Tp_allocator(),
      __x._M_get_Tp_allocator());
      }







      constexpr
      void
      clear() noexcept
      { _M_erase_at_end(this->_M_impl._M_start); }

    protected:




      template<typename _ForwardIterator>
 constexpr
 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;
     }
 }
# 1666 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_vector.h" 3
      template<typename _InputIterator>
 constexpr
 void
 _M_range_initialize(_InputIterator __first, _InputIterator __last,
       std::input_iterator_tag)
 {
   try {
     for (; __first != __last; ++__first)

       emplace_back(*__first);



   } catch(...) {
     clear();
     throw;
   }
 }


      template<typename _ForwardIterator>
 constexpr
 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());
 }



      constexpr
      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());
      }



      constexpr
      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());
      }
# 1732 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_vector.h" 3
      template<typename _Integer>
 constexpr
 void
 _M_assign_dispatch(_Integer __n, _Integer __val, __true_type)
 { _M_fill_assign(__n, __val); }


      template<typename _InputIterator>
 constexpr
 void
 _M_assign_dispatch(_InputIterator __first, _InputIterator __last,
      __false_type)
 { _M_assign_aux(__first, __last, std::__iterator_category(__first)); }


      template<typename _InputIterator>
 constexpr
 void
 _M_assign_aux(_InputIterator __first, _InputIterator __last,
        std::input_iterator_tag);


      template<typename _ForwardIterator>
 constexpr
 void
 _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
        std::forward_iterator_tag);



      constexpr
      void
      _M_fill_assign(size_type __n, const value_type& __val);







      template<typename _Integer>
 constexpr
 void
 _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val,
      __true_type)
 { _M_fill_insert(__pos, __n, __val); }


      template<typename _InputIterator>
 constexpr
 void
 _M_insert_dispatch(iterator __pos, _InputIterator __first,
      _InputIterator __last, __false_type)
 {
   _M_range_insert(__pos, __first, __last,
     std::__iterator_category(__first));
 }


      template<typename _InputIterator>
 constexpr
 void
 _M_range_insert(iterator __pos, _InputIterator __first,
   _InputIterator __last, std::input_iterator_tag);


      template<typename _ForwardIterator>
 constexpr
 void
 _M_range_insert(iterator __pos, _ForwardIterator __first,
   _ForwardIterator __last, std::forward_iterator_tag);



      constexpr
      void
      _M_fill_insert(iterator __pos, size_type __n, const value_type& __x);



      constexpr
      void
      _M_default_append(size_type __n);

      constexpr
      bool
      _M_shrink_to_fit();
# 1834 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_vector.h" 3
      struct _Temporary_value
      {
 template<typename... _Args>
   constexpr explicit
   _Temporary_value(vector* __vec, _Args&&... __args) : _M_this(__vec)
   {
     _Alloc_traits::construct(_M_this->_M_impl, _M_ptr(),
         std::forward<_Args>(__args)...);
   }

 constexpr
 ~_Temporary_value()
 { _Alloc_traits::destroy(_M_this->_M_impl, _M_ptr()); }

 constexpr value_type&
 _M_val() noexcept { return _M_storage._M_val; }

      private:
 constexpr _Tp*
 _M_ptr() noexcept { return std::__addressof(_M_storage._M_val); }

 union _Storage
 {
   constexpr _Storage() : _M_byte() { }
   constexpr ~_Storage() { }
   _Storage& operator=(const _Storage&) = delete;
   unsigned char _M_byte;
   _Tp _M_val;
 };

 vector* _M_this;
 _Storage _M_storage;
      };



      template<typename _Arg>
 constexpr
 void
 _M_insert_aux(iterator __position, _Arg&& __arg);

      template<typename... _Args>
 constexpr
 void
 _M_realloc_insert(iterator __position, _Args&&... __args);

      template<typename... _Args>
 constexpr
 void
 _M_realloc_append(_Args&&... __args);


      constexpr
      iterator
      _M_insert_rval(const_iterator __position, value_type&& __v);


      template<typename... _Args>
 constexpr
 iterator
 _M_emplace_aux(const_iterator __position, _Args&&... __args);


      constexpr
      iterator
      _M_emplace_aux(const_iterator __position, value_type&& __v)
      { return _M_insert_rval(__position, std::move(__v)); }



      constexpr
      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 constexpr 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 constexpr size_type
      _S_max_size(const _Tp_alloc_type& __a) noexcept
      {



 const size_t __diffmax
   = __gnu_cxx::__numeric_traits<ptrdiff_t>::__max / sizeof(_Tp);
 const size_t __allocmax = _Alloc_traits::max_size(__a);
 return (std::min)(__diffmax, __allocmax);
      }





      constexpr
      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;
                                       ;
   }
      }

      constexpr
      iterator
      _M_erase(iterator __position);

      constexpr
      iterator
      _M_erase(iterator __first, iterator __last);


    private:



      constexpr
      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());
      }



      constexpr
      void
      _M_move_assign(vector&& __x, false_type)
      {
 if (__x._M_get_Tp_allocator() == this->_M_get_Tp_allocator())
   _M_move_assign(std::move(__x), true_type());
 else
   {


     this->_M_assign_aux(std::make_move_iterator(__x.begin()),
           std::make_move_iterator(__x.end()),
    std::random_access_iterator_tag());
     __x.clear();
   }
      }


      template<typename _Up>
 constexpr
 _Up*
 _M_data_ptr(_Up* __ptr) const noexcept
 { return __ptr; }


      template<typename _Ptr>
 constexpr
 typename std::pointer_traits<_Ptr>::element_type*
 _M_data_ptr(_Ptr __ptr) const
 { return empty() ? nullptr : std::__to_address(__ptr); }
# 2025 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_vector.h" 3
    };


  template<typename _InputIterator, typename _ValT
      = typename iterator_traits<_InputIterator>::value_type,
    typename _Allocator = allocator<_ValT>,
    typename = _RequireInputIter<_InputIterator>,
    typename = _RequireAllocator<_Allocator>>
    vector(_InputIterator, _InputIterator, _Allocator = _Allocator())
      -> vector<_ValT, _Allocator>;
# 2047 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_vector.h" 3
  template<typename _Tp, typename _Alloc>
    [[__nodiscard__]] constexpr
    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())); }
# 2066 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_vector.h" 3
  template<typename _Tp, typename _Alloc>
    [[nodiscard]] constexpr
    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);
    }
# 2119 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_vector.h" 3
  template<typename _Tp, typename _Alloc>
    constexpr
    inline void
    swap(vector<_Tp, _Alloc>& __x, vector<_Tp, _Alloc>& __y)
    noexcept(noexcept(__x.swap(__y)))
    { __x.swap(__y); }




  namespace __detail::__variant
  {
    template<typename> struct _Never_valueless_alt;



    template<typename _Tp, typename _Alloc>
      struct _Never_valueless_alt<std::vector<_Tp, _Alloc>>
      : std::is_nothrow_move_assignable<std::vector<_Tp, _Alloc>>
      { };
  }



}
# 67 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/vector" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_bvector.h" 1 3
# 68 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_bvector.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{


  typedef unsigned long _Bit_type;
  enum { _S_word_bit = int(8 * sizeof(_Bit_type)) };

  __attribute__((__nonnull__))
  constexpr
  void
  __fill_bvector_n(_Bit_type*, size_t, bool) noexcept;



  struct _Bit_reference
  {
    _Bit_type * _M_p;
    _Bit_type _M_mask;

    constexpr
    _Bit_reference(_Bit_type * __x, _Bit_type __y)
    : _M_p(__x), _M_mask(__y) { }

    constexpr
    _Bit_reference() noexcept : _M_p(0), _M_mask(0) { }


    _Bit_reference(const _Bit_reference&) = default;


    [[__nodiscard__]] constexpr
    operator bool() const noexcept
    { return !!(*_M_p & _M_mask); }

    constexpr
    _Bit_reference&
    operator=(bool __x) noexcept
    {
      if (__x)
 *_M_p |= _M_mask;
      else
 *_M_p &= ~_M_mask;
      return *this;
    }


    constexpr const _Bit_reference&
    operator=(bool __x) const noexcept
    {
      if (__x)
 *_M_p |= _M_mask;
      else
 *_M_p &= ~_M_mask;
      return *this;
    }


    constexpr
    _Bit_reference&
    operator=(const _Bit_reference& __x) noexcept
    { return *this = bool(__x); }

    [[__nodiscard__]] constexpr
    bool
    operator==(const _Bit_reference& __x) const
    { return bool(*this) == bool(__x); }

    [[__nodiscard__]] constexpr
    bool
    operator<(const _Bit_reference& __x) const
    { return !bool(*this) && bool(__x); }

    constexpr
    void
    flip() noexcept
    { *_M_p ^= _M_mask; }


    constexpr
    friend void
    swap(_Bit_reference __x, _Bit_reference __y) noexcept
    {
      bool __tmp = __x;
      __x = __y;
      __y = __tmp;
    }

    constexpr
    friend void
    swap(_Bit_reference __x, bool& __y) noexcept
    {
      bool __tmp = __x;
      __x = __y;
      __y = __tmp;
    }

    constexpr
    friend void
    swap(bool& __x, _Bit_reference __y) noexcept
    {
      bool __tmp = __x;
      __x = __y;
      __y = __tmp;
    }

  };


#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
  struct _Bit_iterator_base
  : public std::iterator<std::random_access_iterator_tag, bool>
  {
    _Bit_type * _M_p;
    unsigned int _M_offset;

    constexpr inline __attribute__((__always_inline__))
    void
    _M_assume_normalized() const
    {




    }

    constexpr
    _Bit_iterator_base(_Bit_type * __x, unsigned int __y)
    : _M_p(__x), _M_offset(__y) { }

    constexpr
    void
    _M_bump_up()
    {
      _M_assume_normalized();
      if (_M_offset++ == int(_S_word_bit) - 1)
 {
   _M_offset = 0;
   ++_M_p;
 }
    }

    constexpr
    void
    _M_bump_down()
    {
      _M_assume_normalized();
      if (_M_offset-- == 0)
 {
   _M_offset = int(_S_word_bit) - 1;
   --_M_p;
 }
    }

    constexpr
    void
    _M_incr(ptrdiff_t __i)
    {
      _M_assume_normalized();
      difference_type __n = __i + _M_offset;
      _M_p += __n / int(_S_word_bit);
      __n = __n % int(_S_word_bit);
      if (__n < 0)
 {
   __n += int(_S_word_bit);
   --_M_p;
 }
      _M_offset = static_cast<unsigned int>(__n);
    }

    [[__nodiscard__]]
    friend constexpr bool
    operator==(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
    {
      __x._M_assume_normalized();
      __y._M_assume_normalized();
      return __x._M_p == __y._M_p && __x._M_offset == __y._M_offset;
    }


    [[nodiscard]]
    friend constexpr strong_ordering
    operator<=>(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
    noexcept
    {
      __x._M_assume_normalized();
      __y._M_assume_normalized();
      if (const auto __cmp = __x._M_p <=> __y._M_p; __cmp != 0)
 return __cmp;
      return __x._M_offset <=> __y._M_offset;
    }
# 291 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_bvector.h" 3
    friend constexpr ptrdiff_t
    operator-(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y)
    {
      __x._M_assume_normalized();
      __y._M_assume_normalized();
      return (int(_S_word_bit) * (__x._M_p - __y._M_p)
       + __x._M_offset - __y._M_offset);
    }
  };
#pragma GCC diagnostic pop

  struct _Bit_iterator : public _Bit_iterator_base
  {
    typedef _Bit_reference reference;

    typedef void pointer;



    typedef _Bit_iterator iterator;

    constexpr
    _Bit_iterator() : _Bit_iterator_base(0, 0) { }

    constexpr
    _Bit_iterator(_Bit_type * __x, unsigned int __y)
    : _Bit_iterator_base(__x, __y) { }

    constexpr
    iterator
    _M_const_cast() const
    { return *this; }

    [[__nodiscard__]] constexpr
    reference
    operator*() const
    {
      _M_assume_normalized();
      return reference(_M_p, 1UL << _M_offset);
    }

    constexpr
    iterator&
    operator++()
    {
      _M_bump_up();
      return *this;
    }

    constexpr
    iterator
    operator++(int)
    {
      iterator __tmp = *this;
      _M_bump_up();
      return __tmp;
    }

    constexpr
    iterator&
    operator--()
    {
      _M_bump_down();
      return *this;
    }

    constexpr
    iterator
    operator--(int)
    {
      iterator __tmp = *this;
      _M_bump_down();
      return __tmp;
    }

    constexpr
    iterator&
    operator+=(difference_type __i)
    {
      _M_incr(__i);
      return *this;
    }

    constexpr
    iterator&
    operator-=(difference_type __i)
    {
      *this += -__i;
      return *this;
    }

    [[__nodiscard__]] constexpr
    reference
    operator[](difference_type __i) const
    { return *(*this + __i); }

    [[__nodiscard__]]
    friend constexpr iterator
    operator+(const iterator& __x, difference_type __n)
    {
      iterator __tmp = __x;
      __tmp += __n;
      return __tmp;
    }

    [[__nodiscard__]]
    friend constexpr iterator
    operator+(difference_type __n, const iterator& __x)
    { return __x + __n; }

    [[__nodiscard__]]
    friend constexpr 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;

    constexpr
    _Bit_const_iterator() : _Bit_iterator_base(0, 0) { }

    constexpr
    _Bit_const_iterator(_Bit_type * __x, unsigned int __y)
    : _Bit_iterator_base(__x, __y) { }

    constexpr
    _Bit_const_iterator(const _Bit_iterator& __x)
    : _Bit_iterator_base(__x._M_p, __x._M_offset) { }

    constexpr
    _Bit_iterator
    _M_const_cast() const
    { return _Bit_iterator(_M_p, _M_offset); }

    [[__nodiscard__]] constexpr
    const_reference
    operator*() const
    {
      _M_assume_normalized();
      return _Bit_reference(_M_p, 1UL << _M_offset);
    }

    constexpr
    const_iterator&
    operator++()
    {
      _M_bump_up();
      return *this;
    }

    constexpr
    const_iterator
    operator++(int)
    {
      const_iterator __tmp = *this;
      _M_bump_up();
      return __tmp;
    }

    constexpr
    const_iterator&
    operator--()
    {
      _M_bump_down();
      return *this;
    }

    constexpr
    const_iterator
    operator--(int)
    {
      const_iterator __tmp = *this;
      _M_bump_down();
      return __tmp;
    }

    constexpr
    const_iterator&
    operator+=(difference_type __i)
    {
      _M_incr(__i);
      return *this;
    }

    constexpr
    const_iterator&
    operator-=(difference_type __i)
    {
      *this += -__i;
      return *this;
    }

    [[__nodiscard__]] constexpr
    const_reference
    operator[](difference_type __i) const
    { return *(*this + __i); }

    [[__nodiscard__]]
    friend constexpr const_iterator
    operator+(const const_iterator& __x, difference_type __n)
    {
      const_iterator __tmp = __x;
      __tmp += __n;
      return __tmp;
    }

    [[__nodiscard__]]
    friend constexpr const_iterator
    operator-(const const_iterator& __x, difference_type __n)
    {
      const_iterator __tmp = __x;
      __tmp -= __n;
      return __tmp;
    }

    [[__nodiscard__]]
    friend constexpr const_iterator
    operator+(difference_type __n, const const_iterator& __x)
    { return __x + __n; }
  };

  template<typename _Alloc>
    struct _Bvector_base
    {
      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
        rebind<_Bit_type>::other _Bit_alloc_type;
      typedef typename __gnu_cxx::__alloc_traits<_Bit_alloc_type>
 _Bit_alloc_traits;
      typedef typename _Bit_alloc_traits::pointer _Bit_pointer;

      struct _Bvector_impl_data
      {

 _Bit_iterator _M_start;
# 547 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_bvector.h" 3
 _Bit_iterator _M_finish;
 _Bit_pointer _M_end_of_storage;

 constexpr
 _Bvector_impl_data() noexcept
 : _M_start(), _M_finish(), _M_end_of_storage()
 { }


 _Bvector_impl_data(const _Bvector_impl_data&) = default;

 _Bvector_impl_data&
 operator=(const _Bvector_impl_data&) = default;

 constexpr
 _Bvector_impl_data(_Bvector_impl_data&& __x) noexcept
 : _Bvector_impl_data(__x)
 { __x._M_reset(); }

 constexpr
 void
 _M_move_data(_Bvector_impl_data&& __x) noexcept
 {
   *this = __x;
   __x._M_reset();
 }


 constexpr
 void
 _M_reset() noexcept
 { *this = _Bvector_impl_data(); }

 constexpr
 void
 _M_swap_data(_Bvector_impl_data& __x) noexcept
 {


   std::swap(*this, __x);
 }
      };

      struct _Bvector_impl
 : public _Bit_alloc_type, public _Bvector_impl_data
      {
 constexpr
 _Bvector_impl() noexcept(is_nothrow_default_constructible<_Bit_alloc_type>::value)


 requires is_default_constructible_v<_Bit_alloc_type>

 : _Bit_alloc_type()
 { }

 constexpr
 _Bvector_impl(const _Bit_alloc_type& __a) noexcept
 : _Bit_alloc_type(__a)
 { }




 constexpr
 _Bvector_impl(_Bvector_impl&& __x) noexcept
 : _Bit_alloc_type(std::move(__x)), _Bvector_impl_data(std::move(__x))
 { }

 constexpr
 _Bvector_impl(_Bit_alloc_type&& __a, _Bvector_impl&& __x) noexcept
 : _Bit_alloc_type(std::move(__a)), _Bvector_impl_data(std::move(__x))
 { }


 constexpr
 _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;

      constexpr
      _Bit_alloc_type&
      _M_get_Bit_allocator() noexcept
      { return this->_M_impl; }

      constexpr
      const _Bit_alloc_type&
      _M_get_Bit_allocator() const noexcept
      { return this->_M_impl; }

      constexpr
      allocator_type
      get_allocator() const noexcept
      { return allocator_type(_M_get_Bit_allocator()); }


      _Bvector_base() = default;




      constexpr
      _Bvector_base(const allocator_type& __a)
      : _M_impl(__a) { }


      _Bvector_base(_Bvector_base&&) = default;

      constexpr
      _Bvector_base(_Bvector_base&& __x, const allocator_type& __a) noexcept
      : _M_impl(_Bit_alloc_type(__a), std::move(__x._M_impl))
      { }


      constexpr
      ~_Bvector_base()
      { this->_M_deallocate(); }

    protected:
      _Bvector_impl _M_impl;

      constexpr
      _Bit_pointer
      _M_allocate(size_t __n)
      {
 _Bit_pointer __p = _Bit_alloc_traits::allocate(_M_impl, _S_nword(__n));

 if (std::is_constant_evaluated())
   {
     __n = _S_nword(__n);
     for (size_t __i = 0; __i < __n; ++__i)
       std::construct_at(std::to_address(__p) + __i);
   }

 return __p;
      }

      constexpr
      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();
   }
      }


      constexpr
      void
      _M_move_data(_Bvector_base&& __x) noexcept
      { _M_impl._M_move_data(std::move(__x._M_impl)); }


      constexpr
      static size_t
      _S_nword(size_t __n)
      { return (__n + int(_S_word_bit) - 1) / int(_S_word_bit); }
    };
# 739 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_bvector.h" 3
  template<typename _Alloc>
    class vector<bool, _Alloc> : protected _Bvector_base<_Alloc>
    {
      typedef _Bvector_base<_Alloc> _Base;
      typedef typename _Base::_Bit_pointer _Bit_pointer;
      typedef typename _Base::_Bit_alloc_traits _Bit_alloc_traits;


      friend struct std::hash<vector>;


    public:
      typedef bool value_type;
      typedef size_t size_type;
      typedef ptrdiff_t difference_type;
      typedef _Bit_reference reference;
      typedef bool const_reference;
      typedef _Bit_reference* pointer;
      typedef const bool* const_pointer;
      typedef _Bit_iterator iterator;
      typedef _Bit_const_iterator const_iterator;
      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
      typedef std::reverse_iterator<iterator> reverse_iterator;
      typedef _Alloc allocator_type;

      constexpr
      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;




      constexpr
      explicit
      vector(const allocator_type& __a)
      : _Base(__a) { }


      constexpr
      explicit
      vector(size_type __n, const allocator_type& __a = allocator_type())
      : vector(__n, false, __a)
      { }

      constexpr
      vector(size_type __n, const bool& __value,
      const allocator_type& __a = allocator_type())





      : _Base(__a)
      {
 _M_initialize(__n);
 _M_initialize_value(__value);
      }

      constexpr
      vector(const vector& __x)
      : _Base(_Bit_alloc_traits::_S_select_on_copy(__x._M_get_Bit_allocator()))
      {
 const_iterator __xbegin = __x.begin(), __xend = __x.end();
 _M_initialize(__x.size());
 _M_copy_aligned(__xbegin, __xend, begin());
      }


      vector(vector&&) = default;

    private:
      constexpr
      vector(vector&& __x, const allocator_type& __a, true_type) noexcept
      : _Base(std::move(__x), __a)
      { }

      constexpr
      vector(vector&& __x, const allocator_type& __a, false_type)
      : _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();
   }
      }

    public:
      constexpr
      vector(vector&& __x, const __type_identity_t<allocator_type>& __a)
      noexcept(_Bit_alloc_traits::_S_always_equal())
      : vector(std::move(__x), __a,
        typename _Bit_alloc_traits::is_always_equal{})
      { }

      constexpr
      vector(const vector& __x, const __type_identity_t<allocator_type>& __a)
      : _Base(__a)
      {
 _M_initialize(__x.size());
 _M_copy_aligned(__x.begin(), __x.end(), begin());
      }

      constexpr
      vector(initializer_list<bool> __l,
      const allocator_type& __a = allocator_type())
      : _Base(__a)
      {
 _M_initialize_range(__l.begin(), __l.end(),
       random_access_iterator_tag());
      }



      template<typename _InputIterator,
        typename = std::_RequireInputIter<_InputIterator>>
 constexpr
 vector(_InputIterator __first, _InputIterator __last,
        const allocator_type& __a = allocator_type())
 : _Base(__a)
 {
   _M_initialize_range(__first, __last,
         std::__iterator_category(__first));
 }
# 889 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_bvector.h" 3
      constexpr
      ~vector() noexcept { }

      constexpr
      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;
      }


      constexpr
      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;
      }

      constexpr
      vector&
      operator=(initializer_list<bool> __l)
      {
 this->assign(__l.begin(), __l.end());
 return *this;
      }






      constexpr
      void
      assign(size_type __n, const bool& __x)
      { _M_fill_assign(__n, __x); }


      template<typename _InputIterator,
        typename = std::_RequireInputIter<_InputIterator>>
 constexpr
 void
 assign(_InputIterator __first, _InputIterator __last)
 { _M_assign_aux(__first, __last, std::__iterator_category(__first)); }
# 987 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_bvector.h" 3
      constexpr
      void
      assign(initializer_list<bool> __l)
      { _M_assign_aux(__l.begin(), __l.end(), random_access_iterator_tag()); }


      [[__nodiscard__]] constexpr
      iterator
      begin() noexcept
      { return iterator(this->_M_impl._M_start._M_p, 0); }

      [[__nodiscard__]] constexpr
      const_iterator
      begin() const noexcept
      { return const_iterator(this->_M_impl._M_start._M_p, 0); }

      [[__nodiscard__]] constexpr
      iterator
      end() noexcept
      { return this->_M_impl._M_finish; }

      [[__nodiscard__]] constexpr
      const_iterator
      end() const noexcept
      { return this->_M_impl._M_finish; }

      [[__nodiscard__]] constexpr
      reverse_iterator
      rbegin() noexcept
      { return reverse_iterator(end()); }

      [[__nodiscard__]] constexpr
      const_reverse_iterator
      rbegin() const noexcept
      { return const_reverse_iterator(end()); }

      [[__nodiscard__]] constexpr
      reverse_iterator
      rend() noexcept
      { return reverse_iterator(begin()); }

      [[__nodiscard__]] constexpr
      const_reverse_iterator
      rend() const noexcept
      { return const_reverse_iterator(begin()); }


      [[__nodiscard__]] constexpr
      const_iterator
      cbegin() const noexcept
      { return const_iterator(this->_M_impl._M_start._M_p, 0); }

      [[__nodiscard__]] constexpr
      const_iterator
      cend() const noexcept
      { return this->_M_impl._M_finish; }

      [[__nodiscard__]] constexpr
      const_reverse_iterator
      crbegin() const noexcept
      { return const_reverse_iterator(end()); }

      [[__nodiscard__]] constexpr
      const_reverse_iterator
      crend() const noexcept
      { return const_reverse_iterator(begin()); }


      [[__nodiscard__]] constexpr
      size_type
      size() const noexcept
      { return size_type(end() - begin()); }

      [[__nodiscard__]] constexpr
      size_type
      max_size() const noexcept
      {
 const size_type __isize =
   __gnu_cxx::__numeric_traits<difference_type>::__max
   - int(_S_word_bit) + 1;
 const size_type __asize
   = _Bit_alloc_traits::max_size(_M_get_Bit_allocator());
 return (__asize <= __isize / int(_S_word_bit)
  ? __asize * int(_S_word_bit) : __isize);
      }

      [[__nodiscard__]] constexpr
      size_type
      capacity() const noexcept
      { return size_type(const_iterator(this->_M_impl._M_end_addr(), 0)
    - begin()); }

      [[__nodiscard__]] constexpr
      bool
      empty() const noexcept
      { return begin() == end(); }

      [[__nodiscard__]] constexpr
      reference
      operator[](size_type __n)
      { return begin()[__n]; }

      [[__nodiscard__]] constexpr
      const_reference
      operator[](size_type __n) const
      { return begin()[__n]; }

    protected:
      constexpr
      void
      _M_range_check(size_type __n) const
      {
 if (__n >= this->size())
   __throw_out_of_range_fmt(("vector<bool>::_M_range_check: __n " "(which is %zu) >= this->size() " "(which is %zu)"),


       __n, this->size());
      }

    public:
      [[__nodiscard__]] constexpr
      reference
      at(size_type __n)
      {
 _M_range_check(__n);
 return (*this)[__n];
      }

      [[__nodiscard__]] constexpr
      const_reference
      at(size_type __n) const
      {
 _M_range_check(__n);
 return (*this)[__n];
      }

      constexpr
      void
      reserve(size_type __n)
      {
 if (__n > max_size())
   __throw_length_error(("vector::reserve"));
 if (capacity() < __n)
   _M_reallocate(__n);
      }

      [[__nodiscard__]] constexpr
      reference
      front()
      { return *begin(); }

      [[__nodiscard__]] constexpr
      const_reference
      front() const
      { return *begin(); }

      [[__nodiscard__]] constexpr
      reference
      back()
      { return *(end() - 1); }

      [[__nodiscard__]] constexpr
      const_reference
      back() const
      { return *(end() - 1); }

      constexpr
      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);
      }

      constexpr
      void
      swap(vector& __x) noexcept
      {

 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(_Bit_alloc_traits::propagate_on_container_swap::value || _M_get_Bit_allocator() == __x._M_get_Bit_allocator()), false)) std::__glibcxx_assert_fail(); } while (false);


 this->_M_impl._M_swap_data(__x._M_impl);
 _Bit_alloc_traits::_S_on_swap(_M_get_Bit_allocator(),
          __x._M_get_Bit_allocator());
      }


      constexpr
      static void
      swap(reference __x, reference __y) noexcept
      {
 bool __tmp = __x;
 __x = __y;
 __y = __tmp;
      }

      constexpr
      iterator

      insert(const_iterator __position, const bool& __x)



      {
 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;
      }


      __attribute__ ((__deprecated__ ("use '" "insert(position, false)" "' instead")))
      iterator
      insert(const_iterator __position)
      { return this->insert(__position._M_const_cast(), false); }



      template<typename _InputIterator,
        typename = std::_RequireInputIter<_InputIterator>>
 constexpr
 iterator
 insert(const_iterator __position,
        _InputIterator __first, _InputIterator __last)
 {
   difference_type __offset = __position - cbegin();
   _M_insert_range(__position._M_const_cast(),
     __first, __last,
     std::__iterator_category(__first));
   return begin() + __offset;
 }
# 1237 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_bvector.h" 3
      constexpr
      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;
      }







      constexpr
      iterator
      insert(const_iterator __p, initializer_list<bool> __l)
      { return this->insert(__p, __l.begin(), __l.end()); }


      constexpr
      void
      pop_back()
      { --this->_M_impl._M_finish; }

      constexpr
      iterator

      erase(const_iterator __position)



      { return _M_erase(__position._M_const_cast()); }

      constexpr
      iterator

      erase(const_iterator __first, const_iterator __last)



      { return _M_erase(__first._M_const_cast(), __last._M_const_cast()); }

      constexpr
      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);
      }


      constexpr
      void
      shrink_to_fit()
      { _M_shrink_to_fit(); }


      constexpr
      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;
      }

      constexpr
      void
      clear() noexcept
      { _M_erase_at_end(begin()); }


      template<typename... _Args>

 constexpr
 reference



 emplace_back(_Args&&... __args)
 {
   push_back(bool(__args...));

   return back();

 }

      template<typename... _Args>
 constexpr
 iterator
 emplace(const_iterator __pos, _Args&&... __args)
 { return insert(__pos, bool(__args...)); }


    protected:

      constexpr
      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));
      }

      constexpr
      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);
     iterator __start = iterator(std::__addressof(*__q), 0);
     this->_M_impl._M_start = __start;
     this->_M_impl._M_finish = __start + difference_type(__n);
   }
      }

      constexpr
      void
      _M_initialize_value(bool __x) noexcept
      {
 if (_Bit_type* __p = this->_M_impl._M_start._M_p)
   __fill_bvector_n(__p, this->_M_impl._M_end_addr() - __p, __x);
      }

      constexpr
      void
      _M_reallocate(size_type __n);


      constexpr
      bool
      _M_shrink_to_fit();
# 1398 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_bvector.h" 3
      template<typename _InputIterator>
 constexpr
 void
 _M_initialize_range(_InputIterator __first, _InputIterator __last,
       std::input_iterator_tag)
 {
   for (; __first != __last; ++__first)
     push_back(*__first);
 }

      template<typename _ForwardIterator>
 constexpr
 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, begin());
 }
# 1434 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_bvector.h" 3
      constexpr
      void
      _M_fill_assign(size_t __n, bool __x)
      {
 if (__n > size())
   {
     _M_initialize_value(__x);
     insert(end(), __n - size(), __x);
   }
 else
   {
     _M_erase_at_end(begin() + __n);
     _M_initialize_value(__x);
   }
      }

      template<typename _InputIterator>
 constexpr
 void
 _M_assign_aux(_InputIterator __first, _InputIterator __last,
        std::input_iterator_tag)
 {
   iterator __cur = begin();
   for (; __first != __last && __cur != end(); ++__cur, (void)++__first)
     *__cur = *__first;
   if (__first == __last)
     _M_erase_at_end(__cur);
   else
     insert(end(), __first, __last);
 }

      template<typename _ForwardIterator>
 constexpr
 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);
     }
 }
# 1501 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_bvector.h" 3
      constexpr
      void
      _M_fill_insert(iterator __position, size_type __n, bool __x);

      template<typename _InputIterator>
 constexpr
 void
 _M_insert_range(iterator __pos, _InputIterator __first,
   _InputIterator __last, std::input_iterator_tag)
 {
   for (; __first != __last; ++__first)
     {
       __pos = insert(__pos, *__first);
       ++__pos;
     }
 }

      template<typename _ForwardIterator>
 constexpr
 void
 _M_insert_range(iterator __position, _ForwardIterator __first,
   _ForwardIterator __last, std::forward_iterator_tag);

      constexpr
      void
      _M_insert_aux(iterator __position, bool __x);

      constexpr
      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;
      }

      constexpr
      void
      _M_erase_at_end(iterator __pos)
      { this->_M_impl._M_finish = __pos; }

      constexpr
      iterator
      _M_erase(iterator __pos);

      constexpr
      iterator
      _M_erase(iterator __first, iterator __last);

    protected:






      void data() = delete;



    };




  constexpr
  inline void
  __fill_bvector(_Bit_type* __v, unsigned int __first, unsigned int __last,
   bool __x) noexcept
  {
    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;
  }


  __attribute__((__nonnull__))
  constexpr
  inline void
  __fill_bvector_n(_Bit_type* __p, size_t __n, bool __x) noexcept
  {

    if (std::is_constant_evaluated())
    {
      for (size_t __i = 0; __i < __n; ++__i)
 __p[__i] = __x ? ~0ul : 0ul;
      return;
    }

    __builtin_memset(__p, __x ? ~0 : 0, __n * sizeof(_Bit_type));
  }


  constexpr
  inline void
  __fill_a1(std::_Bit_iterator __first,
     std::_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);

 __fill_bvector_n(__first_p, __last._M_p - __first_p, __x);

 if (__last._M_offset != 0)
   __fill_bvector(__last._M_p, 0, __last._M_offset, __x);
      }
    else if (__first._M_offset != __last._M_offset)
      __fill_bvector(__first._M_p, __first._M_offset, __last._M_offset, __x);
  }




  template<typename _Alloc>
    struct hash<std::vector<bool, _Alloc>>
    : public __hash_base<size_t, std::vector<bool, _Alloc>>
    {
      size_t
      operator()(const std::vector<bool, _Alloc>&) const noexcept;
    };



}
# 68 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/vector" 2 3




# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/vector.tcc" 1 3
# 59 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/vector.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{



  template<typename _Tp, typename _Alloc>
    constexpr
    void
    vector<_Tp, _Alloc>::
    reserve(size_type __n)
    {
      if (__n > this->max_size())
 __throw_length_error(("vector::reserve"));
      if (this->capacity() < __n)
 {
   const size_type __old_size = size();
   pointer __tmp;

   if constexpr (_S_use_relocate())
     {
       __tmp = this->_M_allocate(__n);
       _S_relocate(this->_M_impl._M_start, this->_M_impl._M_finish,
     __tmp, _M_get_Tp_allocator());
     }
   else

     {
       __tmp = _M_allocate_and_copy(__n,
  std::__make_move_if_noexcept_iterator(this->_M_impl._M_start),
  std::__make_move_if_noexcept_iterator(this->_M_impl._M_finish));
       std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
       _M_get_Tp_allocator());
     }
                                ;
   _M_deallocate(this->_M_impl._M_start,
   this->_M_impl._M_end_of_storage
   - this->_M_impl._M_start);
   this->_M_impl._M_start = __tmp;
   this->_M_impl._M_finish = __tmp + __old_size;
   this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n;
 }
    }


  template<typename _Tp, typename _Alloc>
    template<typename... _Args>

      constexpr
      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_append(std::forward<_Args>(__args)...);

 return back();

      }


  template<typename _Tp, typename _Alloc>
    constexpr
    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)
 {
   do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__position != const_iterator()), false)) std::__glibcxx_assert_fail(); } while (false);
   if (!(__position != const_iterator()))
     __builtin_unreachable();

   if (__position == end())
     {
                                     ;
       _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
           __x);
       ++this->_M_impl._M_finish;
                                     ;
     }
   else
     {

       const auto __pos = begin() + (__position - cbegin());


       _Temporary_value __x_copy(this, __x);
       _M_insert_aux(__pos, std::move(__x_copy._M_val()));



     }
 }
      else

 _M_realloc_insert(begin() + (__position - cbegin()), __x);




      return iterator(this->_M_impl._M_start + __n);
    }

  template<typename _Tp, typename _Alloc>
    constexpr
    typename vector<_Tp, _Alloc>::iterator
    vector<_Tp, _Alloc>::
    _M_erase(iterator __position)
    {
      if (__position + 1 != end())
 std::move(__position + 1, end(), __position);
      --this->_M_impl._M_finish;
      _Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish);
                                      ;
      return __position;
    }

  template<typename _Tp, typename _Alloc>
    constexpr
    typename vector<_Tp, _Alloc>::iterator
    vector<_Tp, _Alloc>::
    _M_erase(iterator __first, iterator __last)
    {
      if (__first != __last)
 {
   if (__last != end())
     std::move(__last, end(), __first);
   _M_erase_at_end(__first.base() + (end() - __last));
 }
      return __first;
    }

  template<typename _Tp, typename _Alloc>
    constexpr
    vector<_Tp, _Alloc>&
    vector<_Tp, _Alloc>::
    operator=(const vector<_Tp, _Alloc>& __x)
    {
      if (std::__addressof(__x) != this)
 {
                                ;

   if (_Alloc_traits::_S_propagate_on_copy_assign())
     {
       if (!_Alloc_traits::_S_always_equal()
           && _M_get_Tp_allocator() != __x._M_get_Tp_allocator())
         {

    this->clear();
    _M_deallocate(this->_M_impl._M_start,
    this->_M_impl._M_end_of_storage
    - this->_M_impl._M_start);
    this->_M_impl._M_start = nullptr;
    this->_M_impl._M_finish = nullptr;
    this->_M_impl._M_end_of_storage = nullptr;
  }
       std::__alloc_on_copy(_M_get_Tp_allocator(),
       __x._M_get_Tp_allocator());
     }

   const size_type __xlen = __x.size();
   if (__xlen > capacity())
     {
       pointer __tmp = _M_allocate_and_copy(__xlen, __x.begin(),
         __x.end());
       std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
       _M_get_Tp_allocator());
       _M_deallocate(this->_M_impl._M_start,
       this->_M_impl._M_end_of_storage
       - this->_M_impl._M_start);
       this->_M_impl._M_start = __tmp;
       this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __xlen;
     }
   else if (size() >= __xlen)
     {
       std::_Destroy(std::copy(__x.begin(), __x.end(), begin()),
       end(), _M_get_Tp_allocator());
     }
   else
     {
       std::copy(__x._M_impl._M_start, __x._M_impl._M_start + size(),
   this->_M_impl._M_start);
       std::__uninitialized_copy_a(__x._M_impl._M_start + size(),
       __x._M_impl._M_finish,
       this->_M_impl._M_finish,
       _M_get_Tp_allocator());
     }
   this->_M_impl._M_finish = this->_M_impl._M_start + __xlen;
 }
      return *this;
    }

  template<typename _Tp, typename _Alloc>
    constexpr
    void
    vector<_Tp, _Alloc>::
    _M_fill_assign(size_t __n, const value_type& __val)
    {
      const size_type __sz = size();
      if (__n > capacity())
 {
   if (__n <= __sz)
     __builtin_unreachable();
   vector __tmp(__n, __val, _M_get_Tp_allocator());
   __tmp._M_impl._M_swap_data(this->_M_impl);
 }
      else if (__n > __sz)
 {
   std::fill(begin(), end(), __val);
   const size_type __add = __n - __sz;
                                     ;
   this->_M_impl._M_finish =
     std::__uninitialized_fill_n_a(this->_M_impl._M_finish,
       __add, __val, _M_get_Tp_allocator());
                                     ;
 }
      else
        _M_erase_at_end(std::fill_n(this->_M_impl._M_start, __n, __val));
    }

  template<typename _Tp, typename _Alloc>
    template<typename _InputIterator>
      constexpr
      void
      vector<_Tp, _Alloc>::
      _M_assign_aux(_InputIterator __first, _InputIterator __last,
      std::input_iterator_tag)
      {
 pointer __cur(this->_M_impl._M_start);
 for (; __first != __last && __cur != this->_M_impl._M_finish;
      ++__cur, (void)++__first)
   *__cur = *__first;
 if (__first == __last)
   _M_erase_at_end(__cur);
 else
   _M_range_insert(end(), __first, __last,
     std::__iterator_category(__first));
      }

  template<typename _Tp, typename _Alloc>
    template<typename _ForwardIterator>
      constexpr
      void
      vector<_Tp, _Alloc>::
      _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
      std::forward_iterator_tag)
      {
 const size_type __sz = size();
 const size_type __len = std::distance(__first, __last);

 if (__len > capacity())
   {
     if (__len <= __sz)
       __builtin_unreachable();

     _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 (__sz >= __len)
   _M_erase_at_end(std::copy(__first, __last, this->_M_impl._M_start));
 else
   {
     _ForwardIterator __mid = __first;
     std::advance(__mid, __sz);
     std::copy(__first, __mid, this->_M_impl._M_start);
     const size_type __attribute__((__unused__)) __n = __len - __sz;
                                     ;
     this->_M_impl._M_finish =
       std::__uninitialized_copy_a(__mid, __last,
       this->_M_impl._M_finish,
       _M_get_Tp_allocator());
                                     ;
   }
      }


  template<typename _Tp, typename _Alloc>
    constexpr
    auto
    vector<_Tp, _Alloc>::
    _M_insert_rval(const_iterator __position, value_type&& __v) -> iterator
    {
      const auto __n = __position - cbegin();
      if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
 if (__position == cend())
   {
                                   ;
     _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
         std::move(__v));
     ++this->_M_impl._M_finish;
                                   ;
   }
 else
   _M_insert_aux(begin() + __n, std::move(__v));
      else
 _M_realloc_insert(begin() + __n, std::move(__v));

      return iterator(this->_M_impl._M_start + __n);
    }

  template<typename _Tp, typename _Alloc>
    template<typename... _Args>
      constexpr
      auto
      vector<_Tp, _Alloc>::
      _M_emplace_aux(const_iterator __position, _Args&&... __args)
      -> iterator
      {
 const auto __n = __position - cbegin();
 if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage)
   if (__position == cend())
     {
                                     ;
       _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
           std::forward<_Args>(__args)...);
       ++this->_M_impl._M_finish;
                                     ;
     }
   else
     {



       _Temporary_value __tmp(this, std::forward<_Args>(__args)...);
       _M_insert_aux(begin() + __n, std::move(__tmp._M_val()));
     }
 else
   _M_realloc_insert(begin() + __n, std::forward<_Args>(__args)...);

 return iterator(this->_M_impl._M_start + __n);
      }

  template<typename _Tp, typename _Alloc>
    template<typename _Arg>
      constexpr
      void
      vector<_Tp, _Alloc>::
      _M_insert_aux(iterator __position, _Arg&& __arg)






    {
                                    ;
      _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish,
          std::move(*(this->_M_impl._M_finish - 1)));
      ++this->_M_impl._M_finish;
                                    ;



      std::move_backward(__position.base(), this->_M_impl._M_finish - 2, this->_M_impl._M_finish - 1);





      *__position = std::forward<_Arg>(__arg);

    }


  template<typename _Tp, typename _Alloc>
    template<typename... _Args>
      constexpr
      void
      vector<_Tp, _Alloc>::
      _M_realloc_insert(iterator __position, _Args&&... __args)






    {
      const size_type __len = _M_check_len(1u, "vector::_M_realloc_insert");
      if (__len <= 0)
 __builtin_unreachable ();
      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);


      struct _Guard
      {
 pointer _M_storage;
 size_type _M_len;
 _Tp_alloc_type& _M_alloc;

 constexpr
 _Guard(pointer __s, size_type __l, _Tp_alloc_type& __a)
 : _M_storage(__s), _M_len(__l), _M_alloc(__a)
 { }

 constexpr
 ~_Guard()
 {
   if (_M_storage)
     __gnu_cxx::__alloc_traits<_Tp_alloc_type>::
       deallocate(_M_alloc, _M_storage, _M_len);
 }

      private:
 _Guard(const _Guard&);
      };

      {
 _Guard __guard(__new_start, __len, _M_impl);
# 505 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/vector.tcc" 3
 _Alloc_traits::construct(this->_M_impl,
     std::__to_address(__new_start + __elems_before),
     std::forward<_Args>(__args)...);







 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

   {

     struct _Guard_elts
     {
       pointer _M_first, _M_last;
       _Tp_alloc_type& _M_alloc;

       constexpr
       _Guard_elts(pointer __elt, _Tp_alloc_type& __a)
       : _M_first(__elt), _M_last(__elt + 1), _M_alloc(__a)
       { }

       constexpr
       ~_Guard_elts()
       { std::_Destroy(_M_first, _M_last, _M_alloc); }

     private:
       _Guard_elts(const _Guard_elts&);
     };


     _Guard_elts __guard_elts(__new_start + __elems_before, _M_impl);

     __new_finish = std::__uninitialized_move_if_noexcept_a(
        __old_start, __position.base(),
        __new_start, _M_get_Tp_allocator());

     ++__new_finish;

     __guard_elts._M_first = __new_start;

     __new_finish = std::__uninitialized_move_if_noexcept_a(
         __position.base(), __old_finish,
         __new_finish, _M_get_Tp_allocator());


     __guard_elts._M_first = __old_start;
     __guard_elts._M_last = __old_finish;
   }
 __guard._M_storage = __old_start;
 __guard._M_len = this->_M_impl._M_end_of_storage - __old_start;
      }



      this->_M_impl._M_start = __new_start;
      this->_M_impl._M_finish = __new_finish;
      this->_M_impl._M_end_of_storage = __new_start + __len;
    }


  template<typename _Tp, typename _Alloc>
    template<typename... _Args>
      constexpr
      void
      vector<_Tp, _Alloc>::
      _M_realloc_append(_Args&&... __args)






    {
      const size_type __len = _M_check_len(1u, "vector::_M_realloc_append");
      if (__len <= 0)
 __builtin_unreachable ();
      pointer __old_start = this->_M_impl._M_start;
      pointer __old_finish = this->_M_impl._M_finish;
      const size_type __elems = end() - begin();
      pointer __new_start(this->_M_allocate(__len));
      pointer __new_finish(__new_start);


      struct _Guard
      {
 pointer _M_storage;
 size_type _M_len;
 _Tp_alloc_type& _M_alloc;

 constexpr
 _Guard(pointer __s, size_type __l, _Tp_alloc_type& __a)
 : _M_storage(__s), _M_len(__l), _M_alloc(__a)
 { }

 constexpr
 ~_Guard()
 {
   if (_M_storage)
     __gnu_cxx::__alloc_traits<_Tp_alloc_type>::
       deallocate(_M_alloc, _M_storage, _M_len);
 }

      private:
 _Guard(const _Guard&);
      };

      {
 _Guard __guard(__new_start, __len, _M_impl);
# 634 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/vector.tcc" 3
 _Alloc_traits::construct(this->_M_impl,
     std::__to_address(__new_start + __elems),
     std::forward<_Args>(__args)...);







 if constexpr (_S_use_relocate())
   {

     __new_finish = _S_relocate(__old_start, __old_finish,
           __new_start, _M_get_Tp_allocator());
     ++__new_finish;
   }
 else

   {

     struct _Guard_elts
     {
       pointer _M_first, _M_last;
       _Tp_alloc_type& _M_alloc;

       constexpr
       _Guard_elts(pointer __elt, _Tp_alloc_type& __a)
       : _M_first(__elt), _M_last(__elt + 1), _M_alloc(__a)
       { }

       constexpr
       ~_Guard_elts()
       { std::_Destroy(_M_first, _M_last, _M_alloc); }

     private:
       _Guard_elts(const _Guard_elts&);
     };


     _Guard_elts __guard_elts(__new_start + __elems, _M_impl);

     __new_finish = std::__uninitialized_move_if_noexcept_a(
        __old_start, __old_finish,
        __new_start, _M_get_Tp_allocator());

     ++__new_finish;


     __guard_elts._M_first = __old_start;
     __guard_elts._M_last = __old_finish;
   }
 __guard._M_storage = __old_start;
 __guard._M_len = this->_M_impl._M_end_of_storage - __old_start;
      }



      this->_M_impl._M_start = __new_start;
      this->_M_impl._M_finish = __new_finish;
      this->_M_impl._M_end_of_storage = __new_start + __len;
    }

  template<typename _Tp, typename _Alloc>
    constexpr
    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(__old_finish - __n,
           __old_finish,
           __old_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(__old_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
     {


       pointer __old_start = this->_M_impl._M_start;
       pointer __old_finish = this->_M_impl._M_finish;
       const pointer __pos = __position.base();

       const size_type __len =
  _M_check_len(__n, "vector::_M_fill_insert");
       const size_type __elems_before = __pos - __old_start;
       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
      (__old_start, __pos, __new_start, _M_get_Tp_allocator());

    __new_finish += __n;

    __new_finish
      = std::__uninitialized_move_if_noexcept_a
      (__pos, __old_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(__old_start, __old_finish, _M_get_Tp_allocator());
                                    ;
       _M_deallocate(__old_start,
       this->_M_impl._M_end_of_storage - __old_start);
       this->_M_impl._M_start = __new_start;
       this->_M_impl._M_finish = __new_finish;
       this->_M_impl._M_end_of_storage = __new_start + __len;
     }
 }
    }


  template<typename _Tp, typename _Alloc>
    constexpr
    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
     {


       pointer __old_start = this->_M_impl._M_start;
       pointer __old_finish = this->_M_impl._M_finish;

       const size_type __len =
  _M_check_len(__n, "vector::_M_default_append");
       pointer __new_start(this->_M_allocate(__len));


       struct _Guard
       {
  pointer _M_storage;
  size_type _M_len;
  _Tp_alloc_type& _M_alloc;

  constexpr
  _Guard(pointer __s, size_type __l, _Tp_alloc_type& __a)
  : _M_storage(__s), _M_len(__l), _M_alloc(__a)
  { }

  constexpr
  ~_Guard()
  {
    if (_M_storage)
      __gnu_cxx::__alloc_traits<_Tp_alloc_type>::
        deallocate(_M_alloc, _M_storage, _M_len);
  }

       private:
  _Guard(const _Guard&);
       };

       {
  _Guard __guard(__new_start, __len, _M_impl);

  std::__uninitialized_default_n_a(__new_start + __size, __n,
       _M_get_Tp_allocator());

  if constexpr (_S_use_relocate())
    {
      _S_relocate(__old_start, __old_finish,
    __new_start, _M_get_Tp_allocator());
    }
  else
    {

      struct _Guard_elts
      {
        pointer _M_first, _M_last;
        _Tp_alloc_type& _M_alloc;

        constexpr
        _Guard_elts(pointer __first, size_type __n,
      _Tp_alloc_type& __a)
        : _M_first(__first), _M_last(__first + __n), _M_alloc(__a)
        { }

        constexpr
        ~_Guard_elts()
        { std::_Destroy(_M_first, _M_last, _M_alloc); }

      private:
        _Guard_elts(const _Guard_elts&);
      };
      _Guard_elts __guard_elts(__new_start + __size, __n, _M_impl);

      std::__uninitialized_move_if_noexcept_a(
        __old_start, __old_finish, __new_start,
        _M_get_Tp_allocator());

      __guard_elts._M_first = __old_start;
      __guard_elts._M_last = __old_finish;
    }
                               ;
  __guard._M_storage = __old_start;
  __guard._M_len = this->_M_impl._M_end_of_storage - __old_start;
       }



       this->_M_impl._M_start = __new_start;
       this->_M_impl._M_finish = __new_start + __size + __n;
       this->_M_impl._M_end_of_storage = __new_start + __len;
     }
 }
    }

  template<typename _Tp, typename _Alloc>
    constexpr
    bool
    vector<_Tp, _Alloc>::
    _M_shrink_to_fit()
    {
      if (capacity() == size())
 return false;
                                   ;
      return std::__shrink_to_fit_aux<vector>::_S_do_it(*this);
    }


  template<typename _Tp, typename _Alloc>
    template<typename _InputIterator>
      constexpr
      void
      vector<_Tp, _Alloc>::
      _M_range_insert(iterator __pos, _InputIterator __first,
        _InputIterator __last, std::input_iterator_tag)
      {
 if (__pos == end())
   {
     for (; __first != __last; ++__first)
       insert(end(), *__first);
   }
 else if (__first != __last)
   {
     vector __tmp(__first, __last, _M_get_Tp_allocator());
     insert(__pos,
     std::make_move_iterator(__tmp.begin()),
     std::make_move_iterator(__tmp.end()));
   }
      }

  template<typename _Tp, typename _Alloc>
    template<typename _ForwardIterator>
      constexpr
      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
       {



  pointer __old_start = this->_M_impl._M_start;
  pointer __old_finish = this->_M_impl._M_finish;

  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
        (__old_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(), __old_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(__old_start, __old_finish,
         _M_get_Tp_allocator());
                               ;
  _M_deallocate(__old_start,
         this->_M_impl._M_end_of_storage - __old_start);
  this->_M_impl._M_start = __new_start;
  this->_M_impl._M_finish = __new_finish;
  this->_M_impl._M_end_of_storage = __new_start + __len;
       }
   }
      }



  template<typename _Alloc>
    constexpr
    void
    vector<bool, _Alloc>::
    _M_reallocate(size_type __n)
    {
      _Bit_pointer __q = this->_M_allocate(__n);
      iterator __start(std::__addressof(*__q), 0);
      iterator __finish(_M_copy_aligned(begin(), end(), __start));
      this->_M_deallocate();
      this->_M_impl._M_start = __start;
      this->_M_impl._M_finish = __finish;
      this->_M_impl._M_end_of_storage = __q + _S_nword(__n);
    }

  template<typename _Alloc>
    constexpr
    void
    vector<bool, _Alloc>::
    _M_fill_insert(iterator __position, size_type __n, bool __x)
    {
      if (__n == 0)
 return;
      if (capacity() - size() >= __n)
 {
   std::copy_backward(__position, end(),
        this->_M_impl._M_finish + difference_type(__n));
   std::fill(__position, __position + difference_type(__n), __x);
   this->_M_impl._M_finish += difference_type(__n);
 }
      else
 {
   const size_type __len =
     _M_check_len(__n, "vector<bool>::_M_fill_insert");
   _Bit_pointer __q = this->_M_allocate(__len);
   iterator __start(std::__addressof(*__q), 0);
   iterator __i = _M_copy_aligned(begin(), __position, __start);
   std::fill(__i, __i + difference_type(__n), __x);
   iterator __finish = std::copy(__position, end(),
     __i + difference_type(__n));
   this->_M_deallocate();
   this->_M_impl._M_end_of_storage = __q + _S_nword(__len);
   this->_M_impl._M_start = __start;
   this->_M_impl._M_finish = __finish;
 }
    }

  template<typename _Alloc>
    template<typename _ForwardIterator>
      constexpr
      void
      vector<bool, _Alloc>::
      _M_insert_range(iterator __position, _ForwardIterator __first,
        _ForwardIterator __last, std::forward_iterator_tag)
      {
 if (__first != __last)
   {
     size_type __n = std::distance(__first, __last);
     if (capacity() - size() >= __n)
       {
  std::copy_backward(__position, end(),
       this->_M_impl._M_finish
       + difference_type(__n));
  std::copy(__first, __last, __position);
  this->_M_impl._M_finish += difference_type(__n);
       }
     else
       {
  const size_type __len =
    _M_check_len(__n, "vector<bool>::_M_insert_range");
  const iterator __begin = begin(), __end = end();
  _Bit_pointer __q = this->_M_allocate(__len);
  iterator __start(std::__addressof(*__q), 0);
  iterator __i = _M_copy_aligned(__begin, __position, __start);
  __i = std::copy(__first, __last, __i);
  iterator __finish = std::copy(__position, __end, __i);
  this->_M_deallocate();
  this->_M_impl._M_end_of_storage = __q + _S_nword(__len);
  this->_M_impl._M_start = __start;
  this->_M_impl._M_finish = __finish;
       }
   }
      }

  template<typename _Alloc>
    constexpr
    void
    vector<bool, _Alloc>::
    _M_insert_aux(iterator __position, bool __x)
    {
      if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr())
 {
   std::copy_backward(__position, this->_M_impl._M_finish,
        this->_M_impl._M_finish + 1);
   *__position = __x;
   ++this->_M_impl._M_finish;
 }
      else
 {
   const size_type __len =
     _M_check_len(size_type(1), "vector<bool>::_M_insert_aux");
   _Bit_pointer __q = this->_M_allocate(__len);
   iterator __start(std::__addressof(*__q), 0);
   iterator __i = _M_copy_aligned(begin(), __position, __start);
   *__i++ = __x;
   iterator __finish = std::copy(__position, end(), __i);
   this->_M_deallocate();
   this->_M_impl._M_end_of_storage = __q + _S_nword(__len);
   this->_M_impl._M_start = __start;
   this->_M_impl._M_finish = __finish;
 }
    }

  template<typename _Alloc>
    constexpr
    typename vector<bool, _Alloc>::iterator
    vector<bool, _Alloc>::
    _M_erase(iterator __position)
    {
      if (__position + 1 != end())
        std::copy(__position + 1, end(), __position);
      --this->_M_impl._M_finish;
      return __position;
    }

  template<typename _Alloc>
    constexpr
    typename vector<bool, _Alloc>::iterator
    vector<bool, _Alloc>::
    _M_erase(iterator __first, iterator __last)
    {
      if (__first != __last)
 _M_erase_at_end(std::copy(__last, end(), __first));
      return __first;
    }


  template<typename _Alloc>
    constexpr
    bool
    vector<bool, _Alloc>::
    _M_shrink_to_fit()
    {
      if (capacity() - size() < int(_S_word_bit))
 return false;
      try
 {
   if (size_type __n = size())
     _M_reallocate(__n);
   else
     {
       this->_M_deallocate();
       this->_M_impl._M_reset();
     }
   return true;
 }
      catch(...)
 { return false; }
    }




}



namespace std __attribute__ ((__visibility__ ("default")))
{


  template<typename _Alloc>
    size_t
    hash<std::vector<bool, _Alloc>>::
    operator()(const std::vector<bool, _Alloc>& __b) const noexcept
    {
      size_t __hash = 0;
      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/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/vector" 2 3
# 83 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/vector" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 84 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/vector" 2 3



namespace std __attribute__ ((__visibility__ ("default")))
{

  namespace pmr {
    template<typename _Tp>
      using vector = std::vector<_Tp, polymorphic_allocator<_Tp>>;
  }
# 102 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/vector" 3
}



namespace std __attribute__ ((__visibility__ ("default")))
{


  template<typename _Tp, typename _Alloc, typename _Predicate>
    constexpr
    inline typename vector<_Tp, _Alloc>::size_type
    erase_if(vector<_Tp, _Alloc>& __cont, _Predicate __pred)
    {
      using namespace __gnu_cxx;
      std::vector<_Tp, _Alloc>& __ucont = __cont;
      const auto __osz = __cont.size();
      const auto __end = __ucont.end();
      auto __removed = std::__remove_if(__ucont.begin(), __end,
     __ops::__pred_iter(std::ref(__pred)));
      if (__removed != __end)
 {
   __cont.erase(__niter_wrap(__cont.begin(), __removed),
         __cont.end());
   return __osz - __cont.size();
 }

      return 0;
    }

  template<typename _Tp, typename _Alloc, typename _Up>
    constexpr
    inline typename vector<_Tp, _Alloc>::size_type
    erase(vector<_Tp, _Alloc>& __cont, const _Up& __value)
    {
      using namespace __gnu_cxx;
      std::vector<_Tp, _Alloc>& __ucont = __cont;
      const auto __osz = __cont.size();
      const auto __end = __ucont.end();
      auto __removed = std::__remove_if(__ucont.begin(), __end,
     __ops::__iter_equals_val(__value));
      if (__removed != __end)
 {
   __cont.erase(__niter_wrap(__cont.begin(), __removed),
         __cont.end());
   return __osz - __cont.size();
 }

      return 0;
    }

}
# 65 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/functional" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/array" 1 3
# 33 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/array" 3
# 52 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/array" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 53 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/array" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{


  template<typename _Tp, size_t _Nm>
    struct __array_traits
    {
      using _Type = _Tp[_Nm];
      using _Is_swappable = __is_swappable<_Tp>;
      using _Is_nothrow_swappable = __is_nothrow_swappable<_Tp>;
    };

 template<typename _Tp>
   struct __array_traits<_Tp, 0>
   {

     struct _Type
     {

       __attribute__((__always_inline__,__noreturn__))
       _Tp& operator[](size_t) const noexcept { __builtin_trap(); }


       __attribute__((__always_inline__))
       constexpr explicit operator _Tp*() const noexcept { return nullptr; }
     };

     using _Is_swappable = true_type;
     using _Is_nothrow_swappable = true_type;
   };
# 99 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/array" 3
  template<typename _Tp, std::size_t _Nm>
    struct array
    {
      typedef _Tp value_type;
      typedef value_type* pointer;
      typedef const value_type* const_pointer;
      typedef value_type& reference;
      typedef const value_type& const_reference;
      typedef value_type* iterator;
      typedef const value_type* const_iterator;
      typedef std::size_t size_type;
      typedef std::ptrdiff_t difference_type;
      typedef std::reverse_iterator<iterator> reverse_iterator;
      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;


      typename __array_traits<_Tp, _Nm>::_Type _M_elems;




      constexpr void
      fill(const value_type& __u)
      { std::fill_n(begin(), size(), __u); }

      constexpr void
      swap(array& __other)
      noexcept(__array_traits<_Tp, _Nm>::_Is_nothrow_swappable::value)
      { std::swap_ranges(begin(), end(), __other.begin()); }


      [[__gnu__::__const__, __nodiscard__]]
      constexpr iterator
      begin() noexcept
      { return iterator(data()); }

      [[__nodiscard__]]
      constexpr const_iterator
      begin() const noexcept
      { return const_iterator(data()); }

      [[__gnu__::__const__, __nodiscard__]]
      constexpr iterator
      end() noexcept
      { return iterator(data() + _Nm); }

      [[__nodiscard__]]
      constexpr const_iterator
      end() const noexcept
      { return const_iterator(data() + _Nm); }

      [[__gnu__::__const__, __nodiscard__]]
      constexpr reverse_iterator
      rbegin() noexcept
      { return reverse_iterator(end()); }

      [[__nodiscard__]]
      constexpr const_reverse_iterator
      rbegin() const noexcept
      { return const_reverse_iterator(end()); }

      [[__gnu__::__const__, __nodiscard__]]
      constexpr reverse_iterator
      rend() noexcept
      { return reverse_iterator(begin()); }

      [[__nodiscard__]]
      constexpr const_reverse_iterator
      rend() const noexcept
      { return const_reverse_iterator(begin()); }

      [[__nodiscard__]]
      constexpr const_iterator
      cbegin() const noexcept
      { return const_iterator(data()); }

      [[__nodiscard__]]
      constexpr const_iterator
      cend() const noexcept
      { return const_iterator(data() + _Nm); }

      [[__nodiscard__]]
      constexpr const_reverse_iterator
      crbegin() const noexcept
      { return const_reverse_iterator(end()); }

      [[__nodiscard__]]
      constexpr const_reverse_iterator
      crend() const noexcept
      { return const_reverse_iterator(begin()); }


      [[__nodiscard__, __gnu__::__const__, __gnu__::__always_inline__]]
      constexpr size_type
      size() const noexcept { return _Nm; }

      [[__nodiscard__, __gnu__::__const__, __gnu__::__always_inline__]]
      constexpr size_type
      max_size() const noexcept { return _Nm; }

      [[__nodiscard__, __gnu__::__const__, __gnu__::__always_inline__]]
      constexpr bool
      empty() const noexcept { return size() == 0; }


      [[__nodiscard__]]
      constexpr reference
      operator[](size_type __n) noexcept
      {
                                  ;
 return _M_elems[__n];
      }

      [[__nodiscard__]]
      constexpr const_reference
      operator[](size_type __n) const noexcept
      {

                                  ;

 return _M_elems[__n];
      }

      constexpr reference
      at(size_type __n)
      {
 if (__n >= _Nm)
   std::__throw_out_of_range_fmt(("array::at: __n (which is %zu) " ">= _Nm (which is %zu)"),

     __n, _Nm);
 return _M_elems[__n];
      }

      constexpr const_reference
      at(size_type __n) const
      {


 return __n < _Nm ? _M_elems[__n]
   : (std::__throw_out_of_range_fmt(("array::at: __n (which is %zu) " ">= _Nm (which is %zu)"),

        __n, _Nm),
      _M_elems[__n]);
      }

      [[__nodiscard__]]
      constexpr reference
      front() noexcept
      {
                              ;
 return _M_elems[(size_type)0];
      }

      [[__nodiscard__]]
      constexpr const_reference
      front() const noexcept
      {

                              ;

 return _M_elems[(size_type)0];
      }

      [[__nodiscard__]]
      constexpr reference
      back() noexcept
      {
                              ;
 return _M_elems[_Nm - 1];
      }

      [[__nodiscard__]]
      constexpr const_reference
      back() const noexcept
      {

                              ;

 return _M_elems[_Nm - 1];
      }

      [[__nodiscard__, __gnu__::__const__, __gnu__::__always_inline__]]
      constexpr pointer
      data() noexcept
      { return static_cast<pointer>(_M_elems); }

      [[__nodiscard__]]
      constexpr const_pointer
      data() const noexcept
      { return static_cast<const_pointer>(_M_elems); }
    };


  template<typename _Tp, typename... _Up>
    array(_Tp, _Up...)
      -> array<enable_if_t<(is_same_v<_Tp, _Up> && ...), _Tp>,
        1 + sizeof...(_Up)>;



  template<typename _Tp, std::size_t _Nm>
    [[__nodiscard__]]
    constexpr
    inline bool
    operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
    { return std::equal(__one.begin(), __one.end(), __two.begin()); }


  template<typename _Tp, size_t _Nm>
    [[nodiscard]]
    constexpr __detail::__synth3way_t<_Tp>
    operator<=>(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b)
    {
      if constexpr (_Nm && __is_memcmp_ordered<_Tp>::__value)
 if (!std::__is_constant_evaluated())
   {
     constexpr size_t __n = _Nm * sizeof(_Tp);
     return __builtin_memcmp(__a.data(), __b.data(), __n) <=> 0;
   }

      for (size_t __i = 0; __i < _Nm; ++__i)
 {
   auto __c = __detail::__synth3way(__a[__i], __b[__i]);
   if (__c != 0)
     return __c;
 }
      return strong_ordering::equal;
    }
# 368 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/array" 3
  template<typename _Tp, std::size_t _Nm>
    constexpr
    inline


    __enable_if_t<__array_traits<_Tp, _Nm>::_Is_swappable::value>



    swap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two)
    noexcept(noexcept(__one.swap(__two)))
    { __one.swap(__two); }


  template<typename _Tp, std::size_t _Nm>
    __enable_if_t<!__array_traits<_Tp, _Nm>::_Is_swappable::value>
    swap(array<_Tp, _Nm>&, array<_Tp, _Nm>&) = delete;


  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
    [[__nodiscard__]]
    constexpr _Tp&
    get(array<_Tp, _Nm>& __arr) noexcept
    {
      static_assert(_Int < _Nm, "array index is within bounds");
      return __arr._M_elems[_Int];
    }

  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
    [[__nodiscard__]]
    constexpr _Tp&&
    get(array<_Tp, _Nm>&& __arr) noexcept
    {
      static_assert(_Int < _Nm, "array index is within bounds");
      return std::move(std::get<_Int>(__arr));
    }

  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
    [[__nodiscard__]]
    constexpr const _Tp&
    get(const array<_Tp, _Nm>& __arr) noexcept
    {
      static_assert(_Int < _Nm, "array index is within bounds");
      return __arr._M_elems[_Int];
    }

  template<std::size_t _Int, typename _Tp, std::size_t _Nm>
    [[__nodiscard__]]
    constexpr const _Tp&&
    get(const array<_Tp, _Nm>&& __arr) noexcept
    {
      static_assert(_Int < _Nm, "array index is within bounds");
      return std::move(std::get<_Int>(__arr));
    }


  template<typename _Tp, size_t _Nm>
    [[nodiscard]]
    constexpr array<remove_cv_t<_Tp>, _Nm>
    to_array(_Tp (&__a)[_Nm])
    noexcept(is_nothrow_constructible_v<_Tp, _Tp&>)
    {
      static_assert(!is_array_v<_Tp>);
      static_assert(is_constructible_v<_Tp, _Tp&>);
      if constexpr (is_constructible_v<_Tp, _Tp&>)
 {
   if constexpr (is_trivial_v<_Tp>)
     {
       array<remove_cv_t<_Tp>, _Nm> __arr;
       if (!__is_constant_evaluated() && _Nm != 0)
  __builtin_memcpy((void*)__arr.data(), (void*)__a, sizeof(__a));
       else
  for (size_t __i = 0; __i < _Nm; ++__i)
    __arr._M_elems[__i] = __a[__i];
       return __arr;
     }
   else
     return [&__a]<size_t... _Idx>(index_sequence<_Idx...>) {
       return array<remove_cv_t<_Tp>, _Nm>{{ __a[_Idx]... }};
     }(make_index_sequence<_Nm>{});
 }
      else
 __builtin_unreachable();
    }

  template<typename _Tp, size_t _Nm>
    [[nodiscard]]
    constexpr array<remove_cv_t<_Tp>, _Nm>
    to_array(_Tp (&&__a)[_Nm])
    noexcept(is_nothrow_move_constructible_v<_Tp>)
    {
      static_assert(!is_array_v<_Tp>);
      static_assert(is_move_constructible_v<_Tp>);
      if constexpr (is_move_constructible_v<_Tp>)
 {
   if constexpr (is_trivial_v<_Tp>)
     {
       array<remove_cv_t<_Tp>, _Nm> __arr;
       if (!__is_constant_evaluated() && _Nm != 0)
  __builtin_memcpy((void*)__arr.data(), (void*)__a, sizeof(__a));
       else
  for (size_t __i = 0; __i < _Nm; ++__i)
    __arr._M_elems[__i] = __a[__i];
       return __arr;
     }
   else
     return [&__a]<size_t... _Idx>(index_sequence<_Idx...>) {
       return array<remove_cv_t<_Tp>, _Nm>{{ std::move(__a[_Idx])... }};
     }(make_index_sequence<_Nm>{});
 }
      else
 __builtin_unreachable();
    }





  template<typename _Tp, size_t _Nm>
    struct tuple_size<array<_Tp, _Nm>>
    : public integral_constant<size_t, _Nm> { };


  template<size_t _Ind, typename _Tp, size_t _Nm>
    struct tuple_element<_Ind, array<_Tp, _Nm>>
    {
      static_assert(_Ind < _Nm, "array index is in range");
      using type = _Tp;
    };


  template<typename _Tp, size_t _Nm>
    inline constexpr size_t tuple_size_v<array<_Tp, _Nm>> = _Nm;

  template<typename _Tp, size_t _Nm>
    inline constexpr size_t tuple_size_v<const array<_Tp, _Nm>> = _Nm;


  template<typename _Tp, size_t _Nm>
    struct __is_tuple_like_impl<array<_Tp, _Nm>> : true_type
    { };


}
# 66 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/functional" 2 3








# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/move_only_function.h" 1 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/move_only_function.h" 3

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 36 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/move_only_function.h" 2 3






namespace std __attribute__ ((__visibility__ ("default")))
{


  template<typename... _Signature>
    class move_only_function;


  class _Mofunc_base
  {
  protected:
    _Mofunc_base() noexcept
    : _M_manage(_S_empty)
    { }

    _Mofunc_base(_Mofunc_base&& __x) noexcept
    {
      _M_manage = std::__exchange(__x._M_manage, _S_empty);
      _M_manage(_M_storage, &__x._M_storage);
    }

    template<typename _Tp, typename... _Args>
      static constexpr bool
      _S_nothrow_init() noexcept
      {
 if constexpr (__stored_locally<_Tp>)
   return is_nothrow_constructible_v<_Tp, _Args...>;
 return false;
      }

    template<typename _Tp, typename... _Args>
      void
      _M_init(_Args&&... __args) noexcept(_S_nothrow_init<_Tp, _Args...>())
      {
 if constexpr (__stored_locally<_Tp>)
   ::new (_M_storage._M_addr()) _Tp(std::forward<_Args>(__args)...);
 else
   _M_storage._M_p = new _Tp(std::forward<_Args>(__args)...);

 _M_manage = &_S_manage<_Tp>;
      }

    _Mofunc_base&
    operator=(_Mofunc_base&& __x) noexcept
    {
      _M_manage(_M_storage, nullptr);
      _M_manage = std::__exchange(__x._M_manage, _S_empty);
      _M_manage(_M_storage, &__x._M_storage);
      return *this;
    }

    _Mofunc_base&
    operator=(nullptr_t) noexcept
    {
      _M_manage(_M_storage, nullptr);
      _M_manage = _S_empty;
      return *this;
    }

    ~_Mofunc_base() { _M_manage(_M_storage, nullptr); }

    void
    swap(_Mofunc_base& __x) noexcept
    {

      _Storage __s;
      __x._M_manage(__s, &__x._M_storage);
      _M_manage(__x._M_storage, &_M_storage);
      __x._M_manage(_M_storage, &__s);
      std::swap(_M_manage, __x._M_manage);
    }

    template<typename _Tp, typename _Self>
      static _Tp*
      _S_access(_Self* __self) noexcept
      {
 if constexpr (__stored_locally<remove_const_t<_Tp>>)
   return static_cast<_Tp*>(__self->_M_storage._M_addr());
 else
   return static_cast<_Tp*>(__self->_M_storage._M_p);
      }

  private:
    struct _Storage
    {
      void* _M_addr() noexcept { return &_M_bytes[0]; }
      const void* _M_addr() const noexcept { return &_M_bytes[0]; }


      struct _Delegate { void (_Storage::*__pfm)(); _Storage* __obj; };
      union {
 void* _M_p;
 alignas(_Delegate) alignas(void(*)())
   unsigned char _M_bytes[sizeof(_Delegate)];
      };
    };

    template<typename _Tp>
      static constexpr bool __stored_locally
 = sizeof(_Tp) <= sizeof(_Storage) && alignof(_Tp) <= alignof(_Storage)
     && is_nothrow_move_constructible_v<_Tp>;



    using _Manager = void (*)(_Storage& __target, _Storage* __src) noexcept;


    static void _S_empty(_Storage&, _Storage*) noexcept { }


    template<typename _Tp>
      static void
      _S_manage(_Storage& __target, _Storage* __src) noexcept
      {
 if constexpr (__stored_locally<_Tp>)
   {
     if (__src)
       {
  _Tp* __rval = static_cast<_Tp*>(__src->_M_addr());
  ::new (__target._M_addr()) _Tp(std::move(*__rval));
  __rval->~_Tp();
       }
     else
       static_cast<_Tp*>(__target._M_addr())->~_Tp();
   }
 else
   {
     if (__src)
       __target._M_p = __src->_M_p;
     else
       delete static_cast<_Tp*>(__target._M_p);
   }
      }

    _Storage _M_storage;
    _Manager _M_manage;
  };

  template<typename _Tp>
    inline constexpr bool __is_move_only_function_v = false;
  template<typename _Tp>
    constexpr bool __is_move_only_function_v<move_only_function<_Tp>> = true;


  namespace __detail::__variant
  {
    template<typename> struct _Never_valueless_alt;



    template<typename... _Signature>
      struct _Never_valueless_alt<std::move_only_function<_Signature...>>
      : true_type
      { };
  }


}

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/mofunc_impl.h" 1 3
# 43 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/mofunc_impl.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 62 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/mofunc_impl.h" 3
  template<typename _Res, typename... _ArgTypes, bool _Noex>
    class move_only_function<_Res(_ArgTypes...)
                           noexcept(_Noex)>
    : _Mofunc_base
    {
      template<typename _Tp>
 using __callable
   = __conditional_t<_Noex,
       is_nothrow_invocable_r<_Res, _Tp, _ArgTypes...>,
       is_invocable_r<_Res, _Tp, _ArgTypes...>>;


      template<typename _Vt>
 static constexpr bool __is_callable_from
   = __and_v<__callable<_Vt >,
      __callable<_Vt &>>;

    public:
      using result_type = _Res;


      move_only_function() noexcept { }


      move_only_function(nullptr_t) noexcept { }


      move_only_function(move_only_function&& __x) noexcept
      : _Mofunc_base(static_cast<_Mofunc_base&&>(__x)),
 _M_invoke(std::__exchange(__x._M_invoke, nullptr))
      { }


      template<typename _Fn, typename _Vt = decay_t<_Fn>>
 requires (!is_same_v<_Vt, move_only_function>)
   && (!__is_in_place_type_v<_Vt>) && __is_callable_from<_Vt>
 move_only_function(_Fn&& __f) noexcept(_S_nothrow_init<_Vt, _Fn>())
 {
   if constexpr (is_function_v<remove_pointer_t<_Vt>>
   || is_member_pointer_v<_Vt>
   || __is_move_only_function_v<_Vt>)
     {
       if (__f == nullptr)
  return;
     }
   _M_init<_Vt>(std::forward<_Fn>(__f));
   _M_invoke = &_S_invoke<_Vt>;
 }


      template<typename _Tp, typename... _Args>
 requires is_constructible_v<_Tp, _Args...>
   && __is_callable_from<_Tp>
 explicit
 move_only_function(in_place_type_t<_Tp>, _Args&&... __args)
 noexcept(_S_nothrow_init<_Tp, _Args...>())
 : _M_invoke(&_S_invoke<_Tp>)
 {
   static_assert(is_same_v<decay_t<_Tp>, _Tp>);
   _M_init<_Tp>(std::forward<_Args>(__args)...);
 }


      template<typename _Tp, typename _Up, typename... _Args>
 requires is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>
   && __is_callable_from<_Tp>
 explicit
 move_only_function(in_place_type_t<_Tp>, initializer_list<_Up> __il,
      _Args&&... __args)
 noexcept(_S_nothrow_init<_Tp, initializer_list<_Up>&, _Args...>())
 : _M_invoke(&_S_invoke<_Tp>)
 {
   static_assert(is_same_v<decay_t<_Tp>, _Tp>);
   _M_init<_Tp>(__il, std::forward<_Args>(__args)...);
 }


      move_only_function&
      operator=(move_only_function&& __x) noexcept
      {
 _Mofunc_base::operator=(static_cast<_Mofunc_base&&>(__x));
 _M_invoke = std::__exchange(__x._M_invoke, nullptr);
 return *this;
      }


      move_only_function&
      operator=(nullptr_t) noexcept
      {
 _Mofunc_base::operator=(nullptr);
 _M_invoke = nullptr;
 return *this;
      }


      template<typename _Fn>
 requires is_constructible_v<move_only_function, _Fn>
 move_only_function&
 operator=(_Fn&& __f)
 noexcept(is_nothrow_constructible_v<move_only_function, _Fn>)
 {
   move_only_function(std::forward<_Fn>(__f)).swap(*this);
   return *this;
 }

      ~move_only_function() = default;


      explicit operator bool() const noexcept { return _M_invoke != nullptr; }
# 180 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/mofunc_impl.h" 3
      _Res
      operator()(_ArgTypes... __args) noexcept(_Noex)
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(*this != nullptr), false)) std::__glibcxx_assert_fail(); } while (false);
 return _M_invoke(this, std::forward<_ArgTypes>(__args)...);
      }


      void
      swap(move_only_function& __x) noexcept
      {
 _Mofunc_base::swap(__x);
 std::swap(_M_invoke, __x._M_invoke);
      }


      friend void
      swap(move_only_function& __x, move_only_function& __y) noexcept
      { __x.swap(__y); }


      friend bool
      operator==(const move_only_function& __x, nullptr_t) noexcept
      { return __x._M_invoke == nullptr; }

    private:
      template<typename _Tp>
 using __param_t = __conditional_t<is_scalar_v<_Tp>, _Tp, _Tp&&>;

      using _Invoker = _Res (*)(_Mofunc_base *,
    __param_t<_ArgTypes>...) noexcept(_Noex);

      template<typename _Tp>
 static _Res
 _S_invoke(_Mofunc_base * __self,
    __param_t<_ArgTypes>... __args) noexcept(_Noex)
 {
   using _TpCv = _Tp ;
   using _TpInv = _Tp &;
   return std::__invoke_r<_Res>(
       std::forward<_TpInv>(*_S_access<_TpCv>(__self)),
       std::forward<__param_t<_ArgTypes>>(__args)...);
 }

      _Invoker _M_invoke = nullptr;
    };







}
# 202 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/move_only_function.h" 2 3

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/mofunc_impl.h" 1 3
# 43 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/mofunc_impl.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 62 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/mofunc_impl.h" 3
  template<typename _Res, typename... _ArgTypes, bool _Noex>
    class move_only_function<_Res(_ArgTypes...) const
                           noexcept(_Noex)>
    : _Mofunc_base
    {
      template<typename _Tp>
 using __callable
   = __conditional_t<_Noex,
       is_nothrow_invocable_r<_Res, _Tp, _ArgTypes...>,
       is_invocable_r<_Res, _Tp, _ArgTypes...>>;


      template<typename _Vt>
 static constexpr bool __is_callable_from
   = __and_v<__callable<_Vt const >,
      __callable<_Vt const &>>;

    public:
      using result_type = _Res;


      move_only_function() noexcept { }


      move_only_function(nullptr_t) noexcept { }


      move_only_function(move_only_function&& __x) noexcept
      : _Mofunc_base(static_cast<_Mofunc_base&&>(__x)),
 _M_invoke(std::__exchange(__x._M_invoke, nullptr))
      { }


      template<typename _Fn, typename _Vt = decay_t<_Fn>>
 requires (!is_same_v<_Vt, move_only_function>)
   && (!__is_in_place_type_v<_Vt>) && __is_callable_from<_Vt>
 move_only_function(_Fn&& __f) noexcept(_S_nothrow_init<_Vt, _Fn>())
 {
   if constexpr (is_function_v<remove_pointer_t<_Vt>>
   || is_member_pointer_v<_Vt>
   || __is_move_only_function_v<_Vt>)
     {
       if (__f == nullptr)
  return;
     }
   _M_init<_Vt>(std::forward<_Fn>(__f));
   _M_invoke = &_S_invoke<_Vt>;
 }


      template<typename _Tp, typename... _Args>
 requires is_constructible_v<_Tp, _Args...>
   && __is_callable_from<_Tp>
 explicit
 move_only_function(in_place_type_t<_Tp>, _Args&&... __args)
 noexcept(_S_nothrow_init<_Tp, _Args...>())
 : _M_invoke(&_S_invoke<_Tp>)
 {
   static_assert(is_same_v<decay_t<_Tp>, _Tp>);
   _M_init<_Tp>(std::forward<_Args>(__args)...);
 }


      template<typename _Tp, typename _Up, typename... _Args>
 requires is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>
   && __is_callable_from<_Tp>
 explicit
 move_only_function(in_place_type_t<_Tp>, initializer_list<_Up> __il,
      _Args&&... __args)
 noexcept(_S_nothrow_init<_Tp, initializer_list<_Up>&, _Args...>())
 : _M_invoke(&_S_invoke<_Tp>)
 {
   static_assert(is_same_v<decay_t<_Tp>, _Tp>);
   _M_init<_Tp>(__il, std::forward<_Args>(__args)...);
 }


      move_only_function&
      operator=(move_only_function&& __x) noexcept
      {
 _Mofunc_base::operator=(static_cast<_Mofunc_base&&>(__x));
 _M_invoke = std::__exchange(__x._M_invoke, nullptr);
 return *this;
      }


      move_only_function&
      operator=(nullptr_t) noexcept
      {
 _Mofunc_base::operator=(nullptr);
 _M_invoke = nullptr;
 return *this;
      }


      template<typename _Fn>
 requires is_constructible_v<move_only_function, _Fn>
 move_only_function&
 operator=(_Fn&& __f)
 noexcept(is_nothrow_constructible_v<move_only_function, _Fn>)
 {
   move_only_function(std::forward<_Fn>(__f)).swap(*this);
   return *this;
 }

      ~move_only_function() = default;


      explicit operator bool() const noexcept { return _M_invoke != nullptr; }
# 180 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/mofunc_impl.h" 3
      _Res
      operator()(_ArgTypes... __args) const noexcept(_Noex)
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(*this != nullptr), false)) std::__glibcxx_assert_fail(); } while (false);
 return _M_invoke(this, std::forward<_ArgTypes>(__args)...);
      }


      void
      swap(move_only_function& __x) noexcept
      {
 _Mofunc_base::swap(__x);
 std::swap(_M_invoke, __x._M_invoke);
      }


      friend void
      swap(move_only_function& __x, move_only_function& __y) noexcept
      { __x.swap(__y); }


      friend bool
      operator==(const move_only_function& __x, nullptr_t) noexcept
      { return __x._M_invoke == nullptr; }

    private:
      template<typename _Tp>
 using __param_t = __conditional_t<is_scalar_v<_Tp>, _Tp, _Tp&&>;

      using _Invoker = _Res (*)(_Mofunc_base const*,
    __param_t<_ArgTypes>...) noexcept(_Noex);

      template<typename _Tp>
 static _Res
 _S_invoke(_Mofunc_base const* __self,
    __param_t<_ArgTypes>... __args) noexcept(_Noex)
 {
   using _TpCv = _Tp const;
   using _TpInv = _Tp const &;
   return std::__invoke_r<_Res>(
       std::forward<_TpInv>(*_S_access<_TpCv>(__self)),
       std::forward<__param_t<_ArgTypes>>(__args)...);
 }

      _Invoker _M_invoke = nullptr;
    };







}
# 204 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/move_only_function.h" 2 3

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/mofunc_impl.h" 1 3
# 43 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/mofunc_impl.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 62 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/mofunc_impl.h" 3
  template<typename _Res, typename... _ArgTypes, bool _Noex>
    class move_only_function<_Res(_ArgTypes...)
          & noexcept(_Noex)>
    : _Mofunc_base
    {
      template<typename _Tp>
 using __callable
   = __conditional_t<_Noex,
       is_nothrow_invocable_r<_Res, _Tp, _ArgTypes...>,
       is_invocable_r<_Res, _Tp, _ArgTypes...>>;


      template<typename _Vt>
 static constexpr bool __is_callable_from
   = __and_v<__callable<_Vt &>,
      __callable<_Vt &>>;

    public:
      using result_type = _Res;


      move_only_function() noexcept { }


      move_only_function(nullptr_t) noexcept { }


      move_only_function(move_only_function&& __x) noexcept
      : _Mofunc_base(static_cast<_Mofunc_base&&>(__x)),
 _M_invoke(std::__exchange(__x._M_invoke, nullptr))
      { }


      template<typename _Fn, typename _Vt = decay_t<_Fn>>
 requires (!is_same_v<_Vt, move_only_function>)
   && (!__is_in_place_type_v<_Vt>) && __is_callable_from<_Vt>
 move_only_function(_Fn&& __f) noexcept(_S_nothrow_init<_Vt, _Fn>())
 {
   if constexpr (is_function_v<remove_pointer_t<_Vt>>
   || is_member_pointer_v<_Vt>
   || __is_move_only_function_v<_Vt>)
     {
       if (__f == nullptr)
  return;
     }
   _M_init<_Vt>(std::forward<_Fn>(__f));
   _M_invoke = &_S_invoke<_Vt>;
 }


      template<typename _Tp, typename... _Args>
 requires is_constructible_v<_Tp, _Args...>
   && __is_callable_from<_Tp>
 explicit
 move_only_function(in_place_type_t<_Tp>, _Args&&... __args)
 noexcept(_S_nothrow_init<_Tp, _Args...>())
 : _M_invoke(&_S_invoke<_Tp>)
 {
   static_assert(is_same_v<decay_t<_Tp>, _Tp>);
   _M_init<_Tp>(std::forward<_Args>(__args)...);
 }


      template<typename _Tp, typename _Up, typename... _Args>
 requires is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>
   && __is_callable_from<_Tp>
 explicit
 move_only_function(in_place_type_t<_Tp>, initializer_list<_Up> __il,
      _Args&&... __args)
 noexcept(_S_nothrow_init<_Tp, initializer_list<_Up>&, _Args...>())
 : _M_invoke(&_S_invoke<_Tp>)
 {
   static_assert(is_same_v<decay_t<_Tp>, _Tp>);
   _M_init<_Tp>(__il, std::forward<_Args>(__args)...);
 }


      move_only_function&
      operator=(move_only_function&& __x) noexcept
      {
 _Mofunc_base::operator=(static_cast<_Mofunc_base&&>(__x));
 _M_invoke = std::__exchange(__x._M_invoke, nullptr);
 return *this;
      }


      move_only_function&
      operator=(nullptr_t) noexcept
      {
 _Mofunc_base::operator=(nullptr);
 _M_invoke = nullptr;
 return *this;
      }


      template<typename _Fn>
 requires is_constructible_v<move_only_function, _Fn>
 move_only_function&
 operator=(_Fn&& __f)
 noexcept(is_nothrow_constructible_v<move_only_function, _Fn>)
 {
   move_only_function(std::forward<_Fn>(__f)).swap(*this);
   return *this;
 }

      ~move_only_function() = default;


      explicit operator bool() const noexcept { return _M_invoke != nullptr; }
# 180 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/mofunc_impl.h" 3
      _Res
      operator()(_ArgTypes... __args) & noexcept(_Noex)
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(*this != nullptr), false)) std::__glibcxx_assert_fail(); } while (false);
 return _M_invoke(this, std::forward<_ArgTypes>(__args)...);
      }


      void
      swap(move_only_function& __x) noexcept
      {
 _Mofunc_base::swap(__x);
 std::swap(_M_invoke, __x._M_invoke);
      }


      friend void
      swap(move_only_function& __x, move_only_function& __y) noexcept
      { __x.swap(__y); }


      friend bool
      operator==(const move_only_function& __x, nullptr_t) noexcept
      { return __x._M_invoke == nullptr; }

    private:
      template<typename _Tp>
 using __param_t = __conditional_t<is_scalar_v<_Tp>, _Tp, _Tp&&>;

      using _Invoker = _Res (*)(_Mofunc_base *,
    __param_t<_ArgTypes>...) noexcept(_Noex);

      template<typename _Tp>
 static _Res
 _S_invoke(_Mofunc_base * __self,
    __param_t<_ArgTypes>... __args) noexcept(_Noex)
 {
   using _TpCv = _Tp ;
   using _TpInv = _Tp &;
   return std::__invoke_r<_Res>(
       std::forward<_TpInv>(*_S_access<_TpCv>(__self)),
       std::forward<__param_t<_ArgTypes>>(__args)...);
 }

      _Invoker _M_invoke = nullptr;
    };







}
# 206 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/move_only_function.h" 2 3

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/mofunc_impl.h" 1 3
# 43 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/mofunc_impl.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 62 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/mofunc_impl.h" 3
  template<typename _Res, typename... _ArgTypes, bool _Noex>
    class move_only_function<_Res(_ArgTypes...)
          && noexcept(_Noex)>
    : _Mofunc_base
    {
      template<typename _Tp>
 using __callable
   = __conditional_t<_Noex,
       is_nothrow_invocable_r<_Res, _Tp, _ArgTypes...>,
       is_invocable_r<_Res, _Tp, _ArgTypes...>>;


      template<typename _Vt>
 static constexpr bool __is_callable_from
   = __and_v<__callable<_Vt &&>,
      __callable<_Vt &&>>;

    public:
      using result_type = _Res;


      move_only_function() noexcept { }


      move_only_function(nullptr_t) noexcept { }


      move_only_function(move_only_function&& __x) noexcept
      : _Mofunc_base(static_cast<_Mofunc_base&&>(__x)),
 _M_invoke(std::__exchange(__x._M_invoke, nullptr))
      { }


      template<typename _Fn, typename _Vt = decay_t<_Fn>>
 requires (!is_same_v<_Vt, move_only_function>)
   && (!__is_in_place_type_v<_Vt>) && __is_callable_from<_Vt>
 move_only_function(_Fn&& __f) noexcept(_S_nothrow_init<_Vt, _Fn>())
 {
   if constexpr (is_function_v<remove_pointer_t<_Vt>>
   || is_member_pointer_v<_Vt>
   || __is_move_only_function_v<_Vt>)
     {
       if (__f == nullptr)
  return;
     }
   _M_init<_Vt>(std::forward<_Fn>(__f));
   _M_invoke = &_S_invoke<_Vt>;
 }


      template<typename _Tp, typename... _Args>
 requires is_constructible_v<_Tp, _Args...>
   && __is_callable_from<_Tp>
 explicit
 move_only_function(in_place_type_t<_Tp>, _Args&&... __args)
 noexcept(_S_nothrow_init<_Tp, _Args...>())
 : _M_invoke(&_S_invoke<_Tp>)
 {
   static_assert(is_same_v<decay_t<_Tp>, _Tp>);
   _M_init<_Tp>(std::forward<_Args>(__args)...);
 }


      template<typename _Tp, typename _Up, typename... _Args>
 requires is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>
   && __is_callable_from<_Tp>
 explicit
 move_only_function(in_place_type_t<_Tp>, initializer_list<_Up> __il,
      _Args&&... __args)
 noexcept(_S_nothrow_init<_Tp, initializer_list<_Up>&, _Args...>())
 : _M_invoke(&_S_invoke<_Tp>)
 {
   static_assert(is_same_v<decay_t<_Tp>, _Tp>);
   _M_init<_Tp>(__il, std::forward<_Args>(__args)...);
 }


      move_only_function&
      operator=(move_only_function&& __x) noexcept
      {
 _Mofunc_base::operator=(static_cast<_Mofunc_base&&>(__x));
 _M_invoke = std::__exchange(__x._M_invoke, nullptr);
 return *this;
      }


      move_only_function&
      operator=(nullptr_t) noexcept
      {
 _Mofunc_base::operator=(nullptr);
 _M_invoke = nullptr;
 return *this;
      }


      template<typename _Fn>
 requires is_constructible_v<move_only_function, _Fn>
 move_only_function&
 operator=(_Fn&& __f)
 noexcept(is_nothrow_constructible_v<move_only_function, _Fn>)
 {
   move_only_function(std::forward<_Fn>(__f)).swap(*this);
   return *this;
 }

      ~move_only_function() = default;


      explicit operator bool() const noexcept { return _M_invoke != nullptr; }
# 180 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/mofunc_impl.h" 3
      _Res
      operator()(_ArgTypes... __args) && noexcept(_Noex)
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(*this != nullptr), false)) std::__glibcxx_assert_fail(); } while (false);
 return _M_invoke(this, std::forward<_ArgTypes>(__args)...);
      }


      void
      swap(move_only_function& __x) noexcept
      {
 _Mofunc_base::swap(__x);
 std::swap(_M_invoke, __x._M_invoke);
      }


      friend void
      swap(move_only_function& __x, move_only_function& __y) noexcept
      { __x.swap(__y); }


      friend bool
      operator==(const move_only_function& __x, nullptr_t) noexcept
      { return __x._M_invoke == nullptr; }

    private:
      template<typename _Tp>
 using __param_t = __conditional_t<is_scalar_v<_Tp>, _Tp, _Tp&&>;

      using _Invoker = _Res (*)(_Mofunc_base *,
    __param_t<_ArgTypes>...) noexcept(_Noex);

      template<typename _Tp>
 static _Res
 _S_invoke(_Mofunc_base * __self,
    __param_t<_ArgTypes>... __args) noexcept(_Noex)
 {
   using _TpCv = _Tp ;
   using _TpInv = _Tp &&;
   return std::__invoke_r<_Res>(
       std::forward<_TpInv>(*_S_access<_TpCv>(__self)),
       std::forward<__param_t<_ArgTypes>>(__args)...);
 }

      _Invoker _M_invoke = nullptr;
    };







}
# 208 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/move_only_function.h" 2 3


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/mofunc_impl.h" 1 3
# 43 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/mofunc_impl.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 62 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/mofunc_impl.h" 3
  template<typename _Res, typename... _ArgTypes, bool _Noex>
    class move_only_function<_Res(_ArgTypes...) const
          & noexcept(_Noex)>
    : _Mofunc_base
    {
      template<typename _Tp>
 using __callable
   = __conditional_t<_Noex,
       is_nothrow_invocable_r<_Res, _Tp, _ArgTypes...>,
       is_invocable_r<_Res, _Tp, _ArgTypes...>>;


      template<typename _Vt>
 static constexpr bool __is_callable_from
   = __and_v<__callable<_Vt const &>,
      __callable<_Vt const &>>;

    public:
      using result_type = _Res;


      move_only_function() noexcept { }


      move_only_function(nullptr_t) noexcept { }


      move_only_function(move_only_function&& __x) noexcept
      : _Mofunc_base(static_cast<_Mofunc_base&&>(__x)),
 _M_invoke(std::__exchange(__x._M_invoke, nullptr))
      { }


      template<typename _Fn, typename _Vt = decay_t<_Fn>>
 requires (!is_same_v<_Vt, move_only_function>)
   && (!__is_in_place_type_v<_Vt>) && __is_callable_from<_Vt>
 move_only_function(_Fn&& __f) noexcept(_S_nothrow_init<_Vt, _Fn>())
 {
   if constexpr (is_function_v<remove_pointer_t<_Vt>>
   || is_member_pointer_v<_Vt>
   || __is_move_only_function_v<_Vt>)
     {
       if (__f == nullptr)
  return;
     }
   _M_init<_Vt>(std::forward<_Fn>(__f));
   _M_invoke = &_S_invoke<_Vt>;
 }


      template<typename _Tp, typename... _Args>
 requires is_constructible_v<_Tp, _Args...>
   && __is_callable_from<_Tp>
 explicit
 move_only_function(in_place_type_t<_Tp>, _Args&&... __args)
 noexcept(_S_nothrow_init<_Tp, _Args...>())
 : _M_invoke(&_S_invoke<_Tp>)
 {
   static_assert(is_same_v<decay_t<_Tp>, _Tp>);
   _M_init<_Tp>(std::forward<_Args>(__args)...);
 }


      template<typename _Tp, typename _Up, typename... _Args>
 requires is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>
   && __is_callable_from<_Tp>
 explicit
 move_only_function(in_place_type_t<_Tp>, initializer_list<_Up> __il,
      _Args&&... __args)
 noexcept(_S_nothrow_init<_Tp, initializer_list<_Up>&, _Args...>())
 : _M_invoke(&_S_invoke<_Tp>)
 {
   static_assert(is_same_v<decay_t<_Tp>, _Tp>);
   _M_init<_Tp>(__il, std::forward<_Args>(__args)...);
 }


      move_only_function&
      operator=(move_only_function&& __x) noexcept
      {
 _Mofunc_base::operator=(static_cast<_Mofunc_base&&>(__x));
 _M_invoke = std::__exchange(__x._M_invoke, nullptr);
 return *this;
      }


      move_only_function&
      operator=(nullptr_t) noexcept
      {
 _Mofunc_base::operator=(nullptr);
 _M_invoke = nullptr;
 return *this;
      }


      template<typename _Fn>
 requires is_constructible_v<move_only_function, _Fn>
 move_only_function&
 operator=(_Fn&& __f)
 noexcept(is_nothrow_constructible_v<move_only_function, _Fn>)
 {
   move_only_function(std::forward<_Fn>(__f)).swap(*this);
   return *this;
 }

      ~move_only_function() = default;


      explicit operator bool() const noexcept { return _M_invoke != nullptr; }
# 180 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/mofunc_impl.h" 3
      _Res
      operator()(_ArgTypes... __args) const & noexcept(_Noex)
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(*this != nullptr), false)) std::__glibcxx_assert_fail(); } while (false);
 return _M_invoke(this, std::forward<_ArgTypes>(__args)...);
      }


      void
      swap(move_only_function& __x) noexcept
      {
 _Mofunc_base::swap(__x);
 std::swap(_M_invoke, __x._M_invoke);
      }


      friend void
      swap(move_only_function& __x, move_only_function& __y) noexcept
      { __x.swap(__y); }


      friend bool
      operator==(const move_only_function& __x, nullptr_t) noexcept
      { return __x._M_invoke == nullptr; }

    private:
      template<typename _Tp>
 using __param_t = __conditional_t<is_scalar_v<_Tp>, _Tp, _Tp&&>;

      using _Invoker = _Res (*)(_Mofunc_base const*,
    __param_t<_ArgTypes>...) noexcept(_Noex);

      template<typename _Tp>
 static _Res
 _S_invoke(_Mofunc_base const* __self,
    __param_t<_ArgTypes>... __args) noexcept(_Noex)
 {
   using _TpCv = _Tp const;
   using _TpInv = _Tp const &;
   return std::__invoke_r<_Res>(
       std::forward<_TpInv>(*_S_access<_TpCv>(__self)),
       std::forward<__param_t<_ArgTypes>>(__args)...);
 }

      _Invoker _M_invoke = nullptr;
    };







}
# 211 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/move_only_function.h" 2 3


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/mofunc_impl.h" 1 3
# 43 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/mofunc_impl.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 62 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/mofunc_impl.h" 3
  template<typename _Res, typename... _ArgTypes, bool _Noex>
    class move_only_function<_Res(_ArgTypes...) const
          && noexcept(_Noex)>
    : _Mofunc_base
    {
      template<typename _Tp>
 using __callable
   = __conditional_t<_Noex,
       is_nothrow_invocable_r<_Res, _Tp, _ArgTypes...>,
       is_invocable_r<_Res, _Tp, _ArgTypes...>>;


      template<typename _Vt>
 static constexpr bool __is_callable_from
   = __and_v<__callable<_Vt const &&>,
      __callable<_Vt const &&>>;

    public:
      using result_type = _Res;


      move_only_function() noexcept { }


      move_only_function(nullptr_t) noexcept { }


      move_only_function(move_only_function&& __x) noexcept
      : _Mofunc_base(static_cast<_Mofunc_base&&>(__x)),
 _M_invoke(std::__exchange(__x._M_invoke, nullptr))
      { }


      template<typename _Fn, typename _Vt = decay_t<_Fn>>
 requires (!is_same_v<_Vt, move_only_function>)
   && (!__is_in_place_type_v<_Vt>) && __is_callable_from<_Vt>
 move_only_function(_Fn&& __f) noexcept(_S_nothrow_init<_Vt, _Fn>())
 {
   if constexpr (is_function_v<remove_pointer_t<_Vt>>
   || is_member_pointer_v<_Vt>
   || __is_move_only_function_v<_Vt>)
     {
       if (__f == nullptr)
  return;
     }
   _M_init<_Vt>(std::forward<_Fn>(__f));
   _M_invoke = &_S_invoke<_Vt>;
 }


      template<typename _Tp, typename... _Args>
 requires is_constructible_v<_Tp, _Args...>
   && __is_callable_from<_Tp>
 explicit
 move_only_function(in_place_type_t<_Tp>, _Args&&... __args)
 noexcept(_S_nothrow_init<_Tp, _Args...>())
 : _M_invoke(&_S_invoke<_Tp>)
 {
   static_assert(is_same_v<decay_t<_Tp>, _Tp>);
   _M_init<_Tp>(std::forward<_Args>(__args)...);
 }


      template<typename _Tp, typename _Up, typename... _Args>
 requires is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>
   && __is_callable_from<_Tp>
 explicit
 move_only_function(in_place_type_t<_Tp>, initializer_list<_Up> __il,
      _Args&&... __args)
 noexcept(_S_nothrow_init<_Tp, initializer_list<_Up>&, _Args...>())
 : _M_invoke(&_S_invoke<_Tp>)
 {
   static_assert(is_same_v<decay_t<_Tp>, _Tp>);
   _M_init<_Tp>(__il, std::forward<_Args>(__args)...);
 }


      move_only_function&
      operator=(move_only_function&& __x) noexcept
      {
 _Mofunc_base::operator=(static_cast<_Mofunc_base&&>(__x));
 _M_invoke = std::__exchange(__x._M_invoke, nullptr);
 return *this;
      }


      move_only_function&
      operator=(nullptr_t) noexcept
      {
 _Mofunc_base::operator=(nullptr);
 _M_invoke = nullptr;
 return *this;
      }


      template<typename _Fn>
 requires is_constructible_v<move_only_function, _Fn>
 move_only_function&
 operator=(_Fn&& __f)
 noexcept(is_nothrow_constructible_v<move_only_function, _Fn>)
 {
   move_only_function(std::forward<_Fn>(__f)).swap(*this);
   return *this;
 }

      ~move_only_function() = default;


      explicit operator bool() const noexcept { return _M_invoke != nullptr; }
# 180 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/mofunc_impl.h" 3
      _Res
      operator()(_ArgTypes... __args) const && noexcept(_Noex)
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(*this != nullptr), false)) std::__glibcxx_assert_fail(); } while (false);
 return _M_invoke(this, std::forward<_ArgTypes>(__args)...);
      }


      void
      swap(move_only_function& __x) noexcept
      {
 _Mofunc_base::swap(__x);
 std::swap(_M_invoke, __x._M_invoke);
      }


      friend void
      swap(move_only_function& __x, move_only_function& __y) noexcept
      { __x.swap(__y); }


      friend bool
      operator==(const move_only_function& __x, nullptr_t) noexcept
      { return __x._M_invoke == nullptr; }

    private:
      template<typename _Tp>
 using __param_t = __conditional_t<is_scalar_v<_Tp>, _Tp, _Tp&&>;

      using _Invoker = _Res (*)(_Mofunc_base const*,
    __param_t<_ArgTypes>...) noexcept(_Noex);

      template<typename _Tp>
 static _Res
 _S_invoke(_Mofunc_base const* __self,
    __param_t<_ArgTypes>... __args) noexcept(_Noex)
 {
   using _TpCv = _Tp const;
   using _TpInv = _Tp const &&;
   return std::__invoke_r<_Res>(
       std::forward<_TpInv>(*_S_access<_TpCv>(__self)),
       std::forward<__param_t<_ArgTypes>>(__args)...);
 }

      _Invoker _M_invoke = nullptr;
    };







}
# 214 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/move_only_function.h" 2 3
# 75 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/functional" 2 3
# 88 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/functional" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 89 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/functional" 2 3



namespace std __attribute__ ((__visibility__ ("default")))
{






  template<int _Num> struct _Placeholder { };
# 115 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/functional" 3
  template<typename _Callable, typename... _Args>
    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)...);
    }
# 134 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/functional" 3
  template<typename _Res, typename _Callable, typename... _Args>
    requires is_invocable_r_v<_Res, _Callable, _Args...>
    constexpr _Res
    invoke_r(_Callable&& __fn, _Args&&... __args)
    noexcept(is_nothrow_invocable_r_v<_Res, _Callable, _Args...>)
    {
      return std::__invoke_r<_Res>(std::forward<_Callable>(__fn),
       std::forward<_Args>(__args)...);
    }





  template<typename _MemFunPtr,
    bool __is_mem_fn = is_member_function_pointer<_MemFunPtr>::value>
    class _Mem_fn_base
    : public _Mem_fn_traits<_MemFunPtr>::__maybe_type
    {
      using _Traits = _Mem_fn_traits<_MemFunPtr>;

      using _Arity = typename _Traits::__arity;
      using _Varargs = typename _Traits::__vararg;

      template<typename _Func, typename... _BoundArgs>
 friend struct _Bind_check_arity;

      _MemFunPtr _M_pmf;

    public:

      using result_type = typename _Traits::__result_type;

      explicit constexpr
      _Mem_fn_base(_MemFunPtr __pmf) noexcept : _M_pmf(__pmf) { }

      template<typename... _Args>
 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<typename _MemObjPtr>
    class _Mem_fn_base<_MemObjPtr, false>
    {
      using _Arity = integral_constant<size_t, 0>;
      using _Varargs = false_type;

      template<typename _Func, typename... _BoundArgs>
 friend struct _Bind_check_arity;

      _MemObjPtr _M_pm;

    public:
      explicit constexpr
      _Mem_fn_base(_MemObjPtr __pm) noexcept : _M_pm(__pm) { }

      template<typename _Tp>
 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<typename _MemberPointer>
    struct _Mem_fn;

  template<typename _Res, typename _Class>
    struct _Mem_fn<_Res _Class::*>
    : _Mem_fn_base<_Res _Class::*>
    {
      using _Mem_fn_base<_Res _Class::*>::_Mem_fn_base;
    };
# 241 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/functional" 3
  template<typename _Tp, typename _Class>
    constexpr
    inline _Mem_fn<_Tp _Class::*>
    mem_fn(_Tp _Class::* __pm) noexcept
    {
      return _Mem_fn<_Tp _Class::*>(__pm);
    }
# 260 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/functional" 3
  template<typename _Tp>
    struct is_bind_expression
    : public false_type { };
# 272 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/functional" 3
  template<typename _Tp>
    struct is_placeholder
    : public integral_constant<int, 0>
    { };


  template <typename _Tp> inline constexpr bool is_bind_expression_v
    = is_bind_expression<_Tp>::value;
  template <typename _Tp> inline constexpr int is_placeholder_v
    = is_placeholder<_Tp>::value;







  namespace placeholders
  {
# 301 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/functional" 3
    inline const _Placeholder<1> _1;
    inline const _Placeholder<2> _2;
    inline const _Placeholder<3> _3;
    inline const _Placeholder<4> _4;
    inline const _Placeholder<5> _5;
    inline const _Placeholder<6> _6;
    inline const _Placeholder<7> _7;
    inline const _Placeholder<8> _8;
    inline const _Placeholder<9> _9;
    inline const _Placeholder<10> _10;
    inline const _Placeholder<11> _11;
    inline const _Placeholder<12> _12;
    inline const _Placeholder<13> _13;
    inline const _Placeholder<14> _14;
    inline const _Placeholder<15> _15;
    inline const _Placeholder<16> _16;
    inline const _Placeholder<17> _17;
    inline const _Placeholder<18> _18;
    inline const _Placeholder<19> _19;
    inline const _Placeholder<20> _20;
    inline const _Placeholder<21> _21;
    inline const _Placeholder<22> _22;
    inline const _Placeholder<23> _23;
    inline const _Placeholder<24> _24;
    inline const _Placeholder<25> _25;
    inline const _Placeholder<26> _26;
    inline const _Placeholder<27> _27;
    inline const _Placeholder<28> _28;
    inline const _Placeholder<29> _29;


  }







  template<int _Num>
    struct is_placeholder<_Placeholder<_Num> >
    : public integral_constant<int, _Num>
    { };

  template<int _Num>
    struct is_placeholder<const _Placeholder<_Num> >
    : public integral_constant<int, _Num>
    { };




  template<std::size_t __i, typename _Tuple>
    using _Safe_tuple_element_t
      = typename enable_if<(__i < tuple_size<_Tuple>::value),
      tuple_element<__i, _Tuple>>::type::type;
# 369 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/functional" 3
  template<typename _Arg,
    bool _IsBindExp = is_bind_expression<_Arg>::value,
    bool _IsPlaceholder = (is_placeholder<_Arg>::value > 0)>
    class _Mu;






  template<typename _Tp>
    class _Mu<reference_wrapper<_Tp>, false, false>
    {
    public:




      template<typename _CVRef, typename _Tuple>
 constexpr
 _Tp&
 operator()(_CVRef& __arg, _Tuple&) const volatile
 { return __arg.get(); }
    };







  template<typename _Arg>
    class _Mu<_Arg, true, false>
    {
    public:
      template<typename _CVArg, typename... _Args>
 constexpr
 auto
 operator()(_CVArg& __arg,
     tuple<_Args...>& __tuple) const volatile
 -> decltype(__arg(declval<_Args>()...))
 {

   typedef typename _Build_index_tuple<sizeof...(_Args)>::__type
     _Indexes;
   return this->__call(__arg, __tuple, _Indexes());
 }

    private:


      template<typename _CVArg, typename... _Args, std::size_t... _Indexes>
 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<typename _Arg>
    class _Mu<_Arg, false, true>
    {
    public:
      template<typename _Tuple>
 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<typename _Arg>
    class _Mu<_Arg, false, false>
    {
    public:
      template<typename _CVArg, typename _Tuple>
 constexpr
 _CVArg&&
 operator()(_CVArg&& __arg, _Tuple&) const volatile
 { return std::forward<_CVArg>(__arg); }
    };


  template<std::size_t _Ind, typename... _Tp>
    inline auto
    __volget(volatile tuple<_Tp...>& __tuple)
    -> __tuple_element_t<_Ind, tuple<_Tp...>> volatile&
    { return std::get<_Ind>(const_cast<tuple<_Tp...>&>(__tuple)); }


  template<std::size_t _Ind, typename... _Tp>
    inline auto
    __volget(const volatile tuple<_Tp...>& __tuple)
    -> __tuple_element_t<_Ind, tuple<_Tp...>> const volatile&
    { return std::get<_Ind>(const_cast<const tuple<_Tp...>&>(__tuple)); }
# 494 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/functional" 3
  template<typename _Signature>
    class _Bind;

   template<typename _Functor, typename... _Bound_args>
    class _Bind<_Functor(_Bound_args...)>
    : public _Weak_result_type<_Functor>
    {
      typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type
 _Bound_indexes;

      _Functor _M_f;
      tuple<_Bound_args...> _M_bound_args;


      template<typename _Result, typename... _Args, std::size_t... _Indexes>
 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<typename _Result, typename... _Args, std::size_t... _Indexes>
 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)...
       );
 }
# 553 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/functional" 3
      template<typename _BoundArg, typename _CallArgs>
 using _Mu_type = decltype(
     _Mu<typename remove_cv<_BoundArg>::type>()(
       std::declval<_BoundArg&>(), std::declval<_CallArgs&>()) );

      template<typename _Fn, typename _CallArgs, typename... _BArgs>
 using _Res_type_impl
   = __invoke_result_t<_Fn&, _Mu_type<_BArgs, _CallArgs>&&...>;

      template<typename _CallArgs>
 using _Res_type = _Res_type_impl<_Functor, _CallArgs, _Bound_args...>;

      template<typename _CallArgs>
 using __dependent = typename
   enable_if<bool(tuple_size<_CallArgs>::value+1), _Functor>::type;

      template<typename _CallArgs, template<class> class __cv_quals>
 using _Res_type_cv = _Res_type_impl<
   typename __cv_quals<__dependent<_CallArgs>>::type,
   _CallArgs,
   typename __cv_quals<_Bound_args>::type...>;

     public:
      template<typename... _Args>
 explicit constexpr
 _Bind(const _Functor& __f, _Args&&... __args)
 : _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...)
 { }

      template<typename... _Args>
 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<typename... _Args,
        typename _Result = _Res_type<tuple<_Args...>>>
 constexpr
 _Result
 operator()(_Args&&... __args)
 {
   return this->__call<_Result>(
       std::forward_as_tuple(std::forward<_Args>(__args)...),
       _Bound_indexes());
 }


      template<typename... _Args,
        typename _Result = _Res_type_cv<tuple<_Args...>, add_const>>
 constexpr
 _Result
 operator()(_Args&&... __args) const
 {
   return this->__call_c<_Result>(
       std::forward_as_tuple(std::forward<_Args>(__args)...),
       _Bound_indexes());
 }
# 640 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/functional" 3
    };


  template<typename _Result, typename _Signature>
    class _Bind_result;

  template<typename _Result, typename _Functor, typename... _Bound_args>
    class _Bind_result<_Result, _Functor(_Bound_args...)>
    {
      typedef typename _Build_index_tuple<sizeof...(_Bound_args)>::__type
 _Bound_indexes;

      _Functor _M_f;
      tuple<_Bound_args...> _M_bound_args;


      template<typename _Res, typename... _Args, std::size_t... _Indexes>
 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<typename _Res, typename... _Args, std::size_t... _Indexes>
 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)...);
 }
# 696 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/functional" 3
    public:
      typedef _Result result_type;

      template<typename... _Args>
 explicit constexpr
 _Bind_result(const _Functor& __f, _Args&&... __args)
 : _M_f(__f), _M_bound_args(std::forward<_Args>(__args)...)
 { }

      template<typename... _Args>
 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<typename... _Args>
 constexpr
 result_type
 operator()(_Args&&... __args)
 {
   return this->__call<_Result>(
       std::forward_as_tuple(std::forward<_Args>(__args)...),
       _Bound_indexes());
 }


      template<typename... _Args>
 constexpr
 result_type
 operator()(_Args&&... __args) const
 {
   return this->__call<_Result>(
       std::forward_as_tuple(std::forward<_Args>(__args)...),
       _Bound_indexes());
 }
# 759 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/functional" 3
      template<typename... _Args>
 void operator()(_Args&&...) const volatile = delete;

    };
# 771 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/functional" 3
  template<typename _Signature>
    struct is_bind_expression<_Bind<_Signature> >
    : public true_type { };





  template<typename _Signature>
    struct is_bind_expression<const _Bind<_Signature> >
    : public true_type { };





  template<typename _Signature>
    struct is_bind_expression<volatile _Bind<_Signature> >
    : public true_type { };





  template<typename _Signature>
    struct is_bind_expression<const volatile _Bind<_Signature>>
    : public true_type { };





  template<typename _Result, typename _Signature>
    struct is_bind_expression<_Bind_result<_Result, _Signature>>
    : public true_type { };





  template<typename _Result, typename _Signature>
    struct is_bind_expression<const _Bind_result<_Result, _Signature>>
    : public true_type { };





  template<typename _Result, typename _Signature>
    struct is_bind_expression<volatile _Bind_result<_Result, _Signature>>
    : public true_type { };





  template<typename _Result, typename _Signature>
    struct is_bind_expression<const volatile _Bind_result<_Result, _Signature>>
    : public true_type { };

  template<typename _Func, typename... _BoundArgs>
    struct _Bind_check_arity { };

  template<typename _Ret, typename... _Args, typename... _BoundArgs>
    struct _Bind_check_arity<_Ret (*)(_Args...), _BoundArgs...>
    {
      static_assert(sizeof...(_BoundArgs) == sizeof...(_Args),
                   "Wrong number of arguments for function");
    };

  template<typename _Ret, typename... _Args, typename... _BoundArgs>
    struct _Bind_check_arity<_Ret (*)(_Args......), _BoundArgs...>
    {
      static_assert(sizeof...(_BoundArgs) >= sizeof...(_Args),
                   "Wrong number of arguments for function");
    };

  template<typename _Tp, typename _Class, typename... _BoundArgs>
    struct _Bind_check_arity<_Tp _Class::*, _BoundArgs...>
    {
      using _Arity = typename _Mem_fn<_Tp _Class::*>::_Arity;
      using _Varargs = typename _Mem_fn<_Tp _Class::*>::_Varargs;
      static_assert(_Varargs::value
      ? sizeof...(_BoundArgs) >= _Arity::value + 1
      : sizeof...(_BoundArgs) == _Arity::value + 1,
      "Wrong number of arguments for pointer-to-member");
    };




  template<typename _Tp, typename _Tp2 = typename decay<_Tp>::type>
    using __is_socketlike = __or_<is_integral<_Tp2>, is_enum<_Tp2>>;

  template<bool _SocketLike, typename _Func, typename... _BoundArgs>
    struct _Bind_helper
    : _Bind_check_arity<typename decay<_Func>::type, _BoundArgs...>
    {
      typedef typename decay<_Func>::type __func_type;
      typedef _Bind<__func_type(typename decay<_BoundArgs>::type...)> type;
    };




  template<typename _Func, typename... _BoundArgs>
    struct _Bind_helper<true, _Func, _BoundArgs...>
    { };






  template<typename _Func, typename... _BoundArgs>
    inline constexpr typename
    _Bind_helper<__is_socketlike<_Func>::value, _Func, _BoundArgs...>::type
    bind(_Func&& __f, _BoundArgs&&... __args)
    {
      typedef _Bind_helper<false, _Func, _BoundArgs...> __helper_type;
      return typename __helper_type::type(std::forward<_Func>(__f),
       std::forward<_BoundArgs>(__args)...);
    }

  template<typename _Result, typename _Func, typename... _BoundArgs>
    struct _Bindres_helper
    : _Bind_check_arity<typename decay<_Func>::type, _BoundArgs...>
    {
      typedef typename decay<_Func>::type __functor_type;
      typedef _Bind_result<_Result,
      __functor_type(typename decay<_BoundArgs>::type...)>
 type;
    };






  template<typename _Result, typename _Func, typename... _BoundArgs>
    inline 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<typename _Fd, typename... _BoundArgs>
    struct _Bind_front
    {
      static_assert(is_move_constructible_v<_Fd>);
      static_assert((is_move_constructible_v<_BoundArgs> && ...));



      template<typename _Fn, typename... _Args>
 explicit constexpr
 _Bind_front(int, _Fn&& __fn, _Args&&... __args)
 noexcept(__and_<is_nothrow_constructible<_Fd, _Fn>,
   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)); }
# 951 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/functional" 3
      template<typename... _CallArgs>
 requires true
 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<typename... _CallArgs>
 requires true
 constexpr
 invoke_result_t<const _Fd&, const _BoundArgs&..., _CallArgs...>
 operator()(_CallArgs&&... __call_args) const &
 noexcept(is_nothrow_invocable_v<const _Fd&, const _BoundArgs&...,
     _CallArgs...>)
 {
   return _S_call(*this, _BoundIndices(),
       std::forward<_CallArgs>(__call_args)...);
 }

      template<typename... _CallArgs>
 requires true
 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<typename... _CallArgs>
 requires true
 constexpr
 invoke_result_t<const _Fd, const _BoundArgs..., _CallArgs...>
 operator()(_CallArgs&&... __call_args) const &&
 noexcept(is_nothrow_invocable_v<const _Fd, const _BoundArgs...,
     _CallArgs...>)
 {
   return _S_call(std::move(*this), _BoundIndices(),
       std::forward<_CallArgs>(__call_args)...);
 }

      template<typename... _CallArgs>
 void operator()(_CallArgs&&...) & = delete;

      template<typename... _CallArgs>
 void operator()(_CallArgs&&...) const & = delete;

      template<typename... _CallArgs>
 void operator()(_CallArgs&&...) && = delete;

      template<typename... _CallArgs>
 void operator()(_CallArgs&&...) const && = delete;


    private:
      using _BoundIndices = index_sequence_for<_BoundArgs...>;

      template<typename _Tp, size_t... _Ind, typename... _CallArgs>
 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)...);
 }

      [[no_unique_address]] _Fd _M_fd;
      [[no_unique_address]] std::tuple<_BoundArgs...> _M_bound_args;
    };

  template<typename _Fn, typename... _Args>
    using _Bind_front_t = _Bind_front<decay_t<_Fn>, decay_t<_Args>...>;
# 1039 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/functional" 3
  template<typename _Fn, typename... _Args>
    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)...);
    }
# 1121 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/functional" 3
  template<typename _Fn>
    class _Not_fn
    {
      template<typename _Fn2, typename... _Args>
 using __inv_res_t = typename __invoke_result<_Fn2, _Args...>::type;

      template<typename _Tp>
 static decltype(!std::declval<_Tp>())
 _S_not() noexcept(noexcept(!std::declval<_Tp>()));

    public:
      template<typename _Fn2>
 constexpr
 _Not_fn(_Fn2&& __fn, int)
 : _M_fn(std::forward<_Fn2>(__fn)) { }

      _Not_fn(const _Not_fn& __fn) = default;
      _Not_fn(_Not_fn&& __fn) = default;
      ~_Not_fn() = default;
# 1161 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/functional" 3
      template<typename... _Args, typename = enable_if_t<__is_invocable<_Fn &, _Args...>::value>> 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<typename... _Args, typename = enable_if_t<!__is_invocable<_Fn &, _Args...>::value>> void operator()(_Args&&... __args) & = delete;
      template<typename... _Args, typename = enable_if_t<__is_invocable<_Fn const &, _Args...>::value>> 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<typename... _Args, typename = enable_if_t<!__is_invocable<_Fn const &, _Args...>::value>> void operator()(_Args&&... __args) const & = delete;
      template<typename... _Args, typename = enable_if_t<__is_invocable<_Fn &&, _Args...>::value>> 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<typename... _Args, typename = enable_if_t<!__is_invocable<_Fn &&, _Args...>::value>> void operator()(_Args&&... __args) && = delete;
      template<typename... _Args, typename = enable_if_t<__is_invocable<_Fn const &&, _Args...>::value>> 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<typename... _Args, typename = enable_if_t<!__is_invocable<_Fn const &&, _Args...>::value>> void operator()(_Args&&... __args) const && = delete;


    private:
      _Fn _M_fn;
    };

  template<typename _Tp, typename _Pred>
    struct __is_byte_like : false_type { };

  template<typename _Tp>
    struct __is_byte_like<_Tp, equal_to<_Tp>>
    : __bool_constant<sizeof(_Tp) == 1 && is_integral<_Tp>::value> { };

  template<typename _Tp>
    struct __is_byte_like<_Tp, equal_to<void>>
    : __bool_constant<sizeof(_Tp) == 1 && is_integral<_Tp>::value> { };



  enum class byte : unsigned char;

  template<>
    struct __is_byte_like<byte, equal_to<byte>>
    : true_type { };

  template<>
    struct __is_byte_like<byte, equal_to<void>>
    : true_type { };
# 1209 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/functional" 3
  template<typename _Fn>
    constexpr
    inline auto
    not_fn(_Fn&& __fn)
    noexcept(std::is_nothrow_constructible<std::decay_t<_Fn>, _Fn&&>::value)
    {
      return _Not_fn<std::decay_t<_Fn>>{std::forward<_Fn>(__fn), 0};
    }





  template<typename _ForwardIterator1, typename _BinaryPredicate = equal_to<>>
    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<typename _ForwardIterator2>
 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<typename _Key, typename _Tp, typename _Hash, typename _Pred>
    struct __boyer_moore_map_base
    {
      template<typename _RAIter>
 __boyer_moore_map_base(_RAIter __pat, size_t __patlen,
          _Hash&& __hf, _Pred&& __pred)
 : _M_bad_char{ __patlen, std::move(__hf), std::move(__pred) }
 {
   if (__patlen > 0)
     for (__diff_type __i = 0; __i < __patlen - 1; ++__i)
       _M_bad_char[__pat[__i]] = __patlen - 1 - __i;
 }

      using __diff_type = _Tp;

      __diff_type
      _M_lookup(_Key __key, __diff_type __not_found) const
      {
 auto __iter = _M_bad_char.find(__key);
 if (__iter == _M_bad_char.end())
   return __not_found;
 return __iter->second;
      }

      _Pred
      _M_pred() const { return _M_bad_char.key_eq(); }

      std::unordered_map<_Key, _Tp, _Hash, _Pred> _M_bad_char;
    };

  template<typename _Tp, size_t _Len, typename _Pred>
    struct __boyer_moore_array_base
    {
      template<typename _RAIter, typename _Unused>
 __boyer_moore_array_base(_RAIter __pat, size_t __patlen,
     _Unused&&, _Pred&& __pred)
 : _M_bad_char{ array<_Tp, _Len>{}, std::move(__pred) }
 {
   std::get<0>(_M_bad_char).fill(__patlen);
   if (__patlen > 0)
     for (__diff_type __i = 0; __i < __patlen - 1; ++__i)
       {
  auto __ch = __pat[__i];
  using _UCh = make_unsigned_t<decltype(__ch)>;
  auto __uch = static_cast<_UCh>(__ch);
  std::get<0>(_M_bad_char)[__uch] = __patlen - 1 - __i;
       }
 }

      using __diff_type = _Tp;

      template<typename _Key>
 __diff_type
 _M_lookup(_Key __key, __diff_type __not_found) const
 {
   auto __ukey = static_cast<make_unsigned_t<_Key>>(__key);
   if (__ukey >= _Len)
     return __not_found;
   return std::get<0>(_M_bad_char)[__ukey];
 }

      const _Pred&
      _M_pred() const { return std::get<1>(_M_bad_char); }

      tuple<array<_Tp, _Len>, _Pred> _M_bad_char;
    };



  template<typename _RAIter, typename _Hash, typename _Pred,
           typename _Val = typename iterator_traits<_RAIter>::value_type,
    typename _Diff = typename iterator_traits<_RAIter>::difference_type>
    using __boyer_moore_base_t
      = __conditional_t<__is_byte_like<_Val, _Pred>::value,
   __boyer_moore_array_base<_Diff, 256, _Pred>,
   __boyer_moore_map_base<_Val, _Diff, _Hash, _Pred>>;

  template<typename _RAIter, typename _Hash
      = hash<typename iterator_traits<_RAIter>::value_type>,
    typename _BinaryPredicate = equal_to<>>
    class boyer_moore_searcher
    : __boyer_moore_base_t<_RAIter, _Hash, _BinaryPredicate>
    {
      using _Base = __boyer_moore_base_t<_RAIter, _Hash, _BinaryPredicate>;
      using typename _Base::__diff_type;

    public:
      boyer_moore_searcher(_RAIter __pat_first, _RAIter __pat_last,
      _Hash __hf = _Hash(),
      _BinaryPredicate __pred = _BinaryPredicate());

      template<typename _RandomAccessIterator2>
        pair<_RandomAccessIterator2, _RandomAccessIterator2>
 operator()(_RandomAccessIterator2 __first,
     _RandomAccessIterator2 __last) const;

    private:
      bool
      _M_is_prefix(_RAIter __word, __diff_type __len,
     __diff_type __pos)
      {
 const auto& __pred = this->_M_pred();
 __diff_type __suffixlen = __len - __pos;
 for (__diff_type __i = 0; __i < __suffixlen; ++__i)
   if (!__pred(__word[__i], __word[__pos + __i]))
     return false;
 return true;
      }

      __diff_type
      _M_suffix_length(_RAIter __word, __diff_type __len,
         __diff_type __pos)
      {
 const auto& __pred = this->_M_pred();
 __diff_type __i = 0;
 while (__pred(__word[__pos - __i], __word[__len - 1 - __i])
        && __i < __pos)
   {
     ++__i;
   }
 return __i;
      }

      template<typename _Tp>
 __diff_type
 _M_bad_char_shift(_Tp __c) const
 { return this->_M_lookup(__c, _M_pat_end - _M_pat); }

      _RAIter _M_pat;
      _RAIter _M_pat_end;
      std::vector<__diff_type> _M_good_suffix;
    };

  template<typename _RAIter, typename _Hash
      = hash<typename iterator_traits<_RAIter>::value_type>,
    typename _BinaryPredicate = equal_to<>>
    class boyer_moore_horspool_searcher
    : __boyer_moore_base_t<_RAIter, _Hash, _BinaryPredicate>
    {
      using _Base = __boyer_moore_base_t<_RAIter, _Hash, _BinaryPredicate>;
      using typename _Base::__diff_type;

    public:
      boyer_moore_horspool_searcher(_RAIter __pat,
        _RAIter __pat_end,
        _Hash __hf = _Hash(),
        _BinaryPredicate __pred
        = _BinaryPredicate())
      : _Base(__pat, __pat_end - __pat, std::move(__hf), std::move(__pred)),
 _M_pat(__pat), _M_pat_end(__pat_end)
      { }

      template<typename _RandomAccessIterator2>
        pair<_RandomAccessIterator2, _RandomAccessIterator2>
 operator()(_RandomAccessIterator2 __first,
     _RandomAccessIterator2 __last) const
 {
   const auto& __pred = this->_M_pred();
   auto __patlen = _M_pat_end - _M_pat;
   if (__patlen == 0)
     return std::make_pair(__first, __first);
   auto __len = __last - __first;
   while (__len >= __patlen)
     {
       for (auto __scan = __patlen - 1;
     __pred(__first[__scan], _M_pat[__scan]); --__scan)
  if (__scan == 0)
    return std::make_pair(__first, __first + __patlen);
       auto __shift = _M_bad_char_shift(__first[__patlen - 1]);
       __len -= __shift;
       __first += __shift;
     }
   return std::make_pair(__last, __last);
 }

    private:
      template<typename _Tp>
 __diff_type
 _M_bad_char_shift(_Tp __c) const
 { return this->_M_lookup(__c, _M_pat_end - _M_pat); }

      _RAIter _M_pat;
      _RAIter _M_pat_end;
    };

  template<typename _RAIter, typename _Hash, typename _BinaryPredicate>
    boyer_moore_searcher<_RAIter, _Hash, _BinaryPredicate>::
    boyer_moore_searcher(_RAIter __pat, _RAIter __pat_end,
    _Hash __hf, _BinaryPredicate __pred)
    : _Base(__pat, __pat_end - __pat, std::move(__hf), std::move(__pred)),
      _M_pat(__pat), _M_pat_end(__pat_end), _M_good_suffix(__pat_end - __pat)
    {
      auto __patlen = __pat_end - __pat;
      if (__patlen == 0)
 return;
      __diff_type __last_prefix = __patlen - 1;
      for (__diff_type __p = __patlen - 1; __p >= 0; --__p)
 {
   if (_M_is_prefix(__pat, __patlen, __p + 1))
     __last_prefix = __p + 1;
   _M_good_suffix[__p] = __last_prefix + (__patlen - 1 - __p);
 }
      for (__diff_type __p = 0; __p < __patlen - 1; ++__p)
 {
   auto __slen = _M_suffix_length(__pat, __patlen, __p);
   auto __pos = __patlen - 1 - __slen;
   if (!__pred(__pat[__p - __slen], __pat[__pos]))
     _M_good_suffix[__pos] = __patlen - 1 - __p + __slen;
 }
    }

  template<typename _RAIter, typename _Hash, typename _BinaryPredicate>
  template<typename _RandomAccessIterator2>
    pair<_RandomAccessIterator2, _RandomAccessIterator2>
    boyer_moore_searcher<_RAIter, _Hash, _BinaryPredicate>::
    operator()(_RandomAccessIterator2 __first,
        _RandomAccessIterator2 __last) const
    {
      auto __patlen = _M_pat_end - _M_pat;
      if (__patlen == 0)
 return std::make_pair(__first, __first);
      const auto& __pred = this->_M_pred();
      __diff_type __i = __patlen - 1;
      auto __stringlen = __last - __first;
      while (__i < __stringlen)
 {
   __diff_type __j = __patlen - 1;
   while (__j >= 0 && __pred(__first[__i], _M_pat[__j]))
     {
       --__i;
       --__j;
     }
   if (__j < 0)
     {
       const auto __match = __first + __i + 1;
       return std::make_pair(__match, __match + __patlen);
     }
   __i += std::max(_M_bad_char_shift(__first[__i]),
     _M_good_suffix[__j]);
 }
      return std::make_pair(__last, __last);
    }







}
# 30 "/home/avi/scylla-maint/seastar/include/seastar/core/future.hh" 2
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/memory" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/memory" 3
# 66 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/memory" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_tempbuf.h" 1 3
# 65 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_tempbuf.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{


  namespace __detail
  {
    template<typename _Tp>
      inline void
      __return_temporary_buffer(_Tp* __p,
    size_t __len __attribute__((__unused__)))
      {



 ::operator delete(__p);

      }
  }
# 101 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_tempbuf.h" 3
  template<typename _Tp>
    [[__deprecated__]]
    pair<_Tp*, ptrdiff_t>
    get_temporary_buffer(ptrdiff_t __len) noexcept
    {
      const ptrdiff_t __max =
 __gnu_cxx::__numeric_traits<ptrdiff_t>::__max / sizeof(_Tp);
      if (__len > __max)
 __len = __max;

      while (__len > 0)
 {
   _Tp* __tmp = static_cast<_Tp*>(::operator new(__len * sizeof(_Tp),
       std::nothrow));
   if (__tmp != 0)
     return std::pair<_Tp*, ptrdiff_t>(__tmp, __len);
   __len = __len == 1 ? 0 : ((__len + 1) / 2);
 }
      return std::pair<_Tp*, ptrdiff_t>(static_cast<_Tp*>(0), 0);
    }
# 129 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_tempbuf.h" 3
  template<typename _Tp>
    inline void
    return_temporary_buffer(_Tp* __p)
    { ::operator delete(__p); }






  template<typename _ForwardIterator, typename _Tp>
    class _Temporary_buffer
    {



    public:
      typedef _Tp value_type;
      typedef value_type* pointer;
      typedef pointer iterator;
      typedef ptrdiff_t size_type;

    protected:
      size_type _M_original_len;
      size_type _M_len;
      pointer _M_buffer;

    public:

      size_type
      size() const
      { return _M_len; }


      size_type
      requested_size() const
      { return _M_original_len; }


      iterator
      begin()
      { return _M_buffer; }


      iterator
      end()
      { return _M_buffer + _M_len; }





      _Temporary_buffer(_ForwardIterator __seed, size_type __original_len);

      ~_Temporary_buffer()
      {
 std::_Destroy(_M_buffer, _M_buffer + _M_len);
 std::__detail::__return_temporary_buffer(_M_buffer, _M_len);
      }

    private:

      _Temporary_buffer(const _Temporary_buffer&);

      void
      operator=(const _Temporary_buffer&);
    };


  template<bool>
    struct __uninitialized_construct_buf_dispatch
    {
      template<typename _Pointer, typename _ForwardIterator>
        static void
        __ucr(_Pointer __first, _Pointer __last,
       _ForwardIterator __seed)
        {
   if (__first == __last)
     return;

   _Pointer __cur = __first;
   try
     {
       std::_Construct(std::__addressof(*__first),
         std::move(*__seed));
       _Pointer __prev = __cur;
       ++__cur;
       for(; __cur != __last; ++__cur, ++__prev)
  std::_Construct(std::__addressof(*__cur),
    std::move(*__prev));
       *__seed = std::move(*__prev);
     }
   catch(...)
     {
       std::_Destroy(__first, __cur);
       throw;
     }
 }
    };

  template<>
    struct __uninitialized_construct_buf_dispatch<true>
    {
      template<typename _Pointer, typename _ForwardIterator>
        static void
        __ucr(_Pointer, _Pointer, _ForwardIterator) { }
    };
# 247 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_tempbuf.h" 3
  template<typename _Pointer, typename _ForwardIterator>
    inline void
    __uninitialized_construct_buf(_Pointer __first, _Pointer __last,
      _ForwardIterator __seed)
    {
      typedef typename std::iterator_traits<_Pointer>::value_type
 _ValueType;

      std::__uninitialized_construct_buf_dispatch<
        __has_trivial_constructor(_ValueType)>::
   __ucr(__first, __last, __seed);
    }

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
  template<typename _ForwardIterator, typename _Tp>
    _Temporary_buffer<_ForwardIterator, _Tp>::
    _Temporary_buffer(_ForwardIterator __seed, size_type __original_len)
    : _M_original_len(__original_len), _M_len(0), _M_buffer(0)
    {
      std::pair<pointer, size_type> __p(
  std::get_temporary_buffer<value_type>(_M_original_len));

      if (__p.first)
 {
   try
     {
       std::__uninitialized_construct_buf(__p.first, __p.first + __p.second,
       __seed);
       _M_buffer = __p.first;
       _M_len = __p.second;
     }
   catch(...)
     {
       std::__detail::__return_temporary_buffer(__p.first, __p.second);
       throw;
     }
 }
    }
#pragma GCC diagnostic pop


}
# 67 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/memory" 2 3



# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_raw_storage_iter.h" 1 3
# 59 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_raw_storage_iter.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"





  template <class _OutputIterator, class _Tp>
    class [[__deprecated__]] raw_storage_iterator
    : public iterator<output_iterator_tag, void, void, void, void>
    {
    protected:
      _OutputIterator _M_iter;

    public:
      explicit
      raw_storage_iterator(_OutputIterator __x)
      : _M_iter(__x) {}

      raw_storage_iterator&
      operator*() { return *this; }

      raw_storage_iterator&
      operator=(const _Tp& __element)
      {
 std::_Construct(std::__addressof(*_M_iter), __element);
 return *this;
      }




      raw_storage_iterator&
      operator=(_Tp&& __element)
      {
 std::_Construct(std::__addressof(*_M_iter), std::move(__element));
 return *this;
      }


      raw_storage_iterator&
      operator++()
      {
 ++_M_iter;
 return *this;
      }

      raw_storage_iterator
      operator++(int)
      {
 raw_storage_iterator __tmp = *this;
 ++_M_iter;
 return __tmp;
      }



      _OutputIterator base() const { return _M_iter; }
    };
#pragma GCC diagnostic pop


}
# 71 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/memory" 2 3



# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/align.h" 1 3
# 36 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/align.h" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 37 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/align.h" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{
# 60 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/align.h" 3
inline void*
align(size_t __align, size_t __size, void*& __ptr, size_t& __space) noexcept
{
  if (__space < __size)
    return nullptr;
  const auto __intptr = reinterpret_cast<uintptr_t>(__ptr);
  const auto __aligned = (__intptr - 1u + __align) & -__align;
  const auto __diff = __aligned - __intptr;
  if (__diff > (__space - __size))
    return nullptr;
  else
    {
      __space -= __diff;
      return __ptr = reinterpret_cast<void*>(__aligned);
    }
}
# 88 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/align.h" 3
  template<size_t _Align, class _Tp>
    [[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));
 }
    }



}
# 75 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/memory" 2 3



# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unique_ptr.h" 1 3
# 43 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unique_ptr.h" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ostream" 1 3
# 37 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ostream" 3



# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ios" 1 3
# 37 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ios" 3
# 46 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ios" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_ios.h" 1 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_ios.h" 3



# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 1 3
# 38 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cwctype" 1 3
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cwctype" 3
# 50 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cwctype" 3
# 1 "/usr/include/wctype.h" 1 3 4
# 38 "/usr/include/wctype.h" 3 4
# 1 "/usr/include/bits/wctype-wchar.h" 1 3 4
# 38 "/usr/include/bits/wctype-wchar.h" 3 4
typedef unsigned long int wctype_t;
# 56 "/usr/include/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) noexcept (true);





extern int iswalpha (wint_t __wc) noexcept (true);


extern int iswcntrl (wint_t __wc) noexcept (true);



extern int iswdigit (wint_t __wc) noexcept (true);



extern int iswgraph (wint_t __wc) noexcept (true);




extern int iswlower (wint_t __wc) noexcept (true);


extern int iswprint (wint_t __wc) noexcept (true);




extern int iswpunct (wint_t __wc) noexcept (true);




extern int iswspace (wint_t __wc) noexcept (true);




extern int iswupper (wint_t __wc) noexcept (true);




extern int iswxdigit (wint_t __wc) noexcept (true);





extern int iswblank (wint_t __wc) noexcept (true);
# 155 "/usr/include/bits/wctype-wchar.h" 3 4
extern wctype_t wctype (const char *__property) noexcept (true);



extern int iswctype (wint_t __wc, wctype_t __desc) noexcept (true);






extern wint_t towlower (wint_t __wc) noexcept (true);


extern wint_t towupper (wint_t __wc) noexcept (true);

}
# 39 "/usr/include/wctype.h" 2 3 4





extern "C" {



typedef const __int32_t *wctrans_t;



extern wctrans_t wctrans (const char *__property) noexcept (true);


extern wint_t towctrans (wint_t __wc, wctrans_t __desc) noexcept (true);







extern int iswalnum_l (wint_t __wc, locale_t __locale) noexcept (true);





extern int iswalpha_l (wint_t __wc, locale_t __locale) noexcept (true);


extern int iswcntrl_l (wint_t __wc, locale_t __locale) noexcept (true);



extern int iswdigit_l (wint_t __wc, locale_t __locale) noexcept (true);



extern int iswgraph_l (wint_t __wc, locale_t __locale) noexcept (true);




extern int iswlower_l (wint_t __wc, locale_t __locale) noexcept (true);


extern int iswprint_l (wint_t __wc, locale_t __locale) noexcept (true);




extern int iswpunct_l (wint_t __wc, locale_t __locale) noexcept (true);




extern int iswspace_l (wint_t __wc, locale_t __locale) noexcept (true);




extern int iswupper_l (wint_t __wc, locale_t __locale) noexcept (true);




extern int iswxdigit_l (wint_t __wc, locale_t __locale) noexcept (true);




extern int iswblank_l (wint_t __wc, locale_t __locale) noexcept (true);



extern wctype_t wctype_l (const char *__property, locale_t __locale)
     noexcept (true);



extern int iswctype_l (wint_t __wc, wctype_t __desc, locale_t __locale)
     noexcept (true);






extern wint_t towlower_l (wint_t __wc, locale_t __locale) noexcept (true);


extern wint_t towupper_l (wint_t __wc, locale_t __locale) noexcept (true);



extern wctrans_t wctrans_l (const char *__property, locale_t __locale)
     noexcept (true);


extern wint_t towctrans_l (wint_t __wc, wctrans_t __desc,
      locale_t __locale) noexcept (true);



}
# 51 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cwctype" 2 3
# 80 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cctype" 1 3
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cctype" 3
# 41 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/ctype_base.h" 1 3
# 36 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/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/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 2 3








namespace std __attribute__ ((__visibility__ ("default")))
{
# 74 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
  template<typename _Tp>
    void
    __convert_to_v(const char*, _Tp&, ios_base::iostate&,
     const __c_locale&) throw();


  template<>
    void
    __convert_to_v(const char*, float&, ios_base::iostate&,
     const __c_locale&) throw();

  template<>
    void
    __convert_to_v(const char*, double&, ios_base::iostate&,
     const __c_locale&) throw();

  template<>
    void
    __convert_to_v(const char*, long double&, ios_base::iostate&,
     const __c_locale&) throw();



  template<typename _CharT, typename _Traits>
    struct __pad
    {
      static void
      _S_pad(ios_base& __io, _CharT __fill, _CharT* __news,
      const _CharT* __olds, streamsize __newlen, streamsize __oldlen);
    };






  template<typename _CharT>
    _CharT*
    __add_grouping(_CharT* __s, _CharT __sep,
     const char* __gbeg, size_t __gsize,
     const _CharT* __first, const _CharT* __last);




  template<typename _CharT>
    inline
    ostreambuf_iterator<_CharT>
    __write(ostreambuf_iterator<_CharT> __s, const _CharT* __ws, int __len)
    {
      __s._M_put(__ws, __len);
      return __s;
    }


  template<typename _CharT, typename _OutIter>
    inline
    _OutIter
    __write(_OutIter __s, const _CharT* __ws, int __len)
    {
      for (int __j = 0; __j < __len; __j++, ++__s)
 *__s = __ws[__j];
      return __s;
    }
# 152 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
  template<typename _CharT>
    class __ctype_abstract_base : public locale::facet, public ctype_base
    {
    public:


      typedef _CharT char_type;
# 171 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      bool
      is(mask __m, char_type __c) const
      { return this->do_is(__m, __c); }
# 188 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      const char_type*
      is(const char_type *__lo, const char_type *__hi, mask *__vec) const
      { return this->do_is(__lo, __hi, __vec); }
# 204 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      const char_type*
      scan_is(mask __m, const char_type* __lo, const char_type* __hi) const
      { return this->do_scan_is(__m, __lo, __hi); }
# 220 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      const char_type*
      scan_not(mask __m, const char_type* __lo, const char_type* __hi) const
      { return this->do_scan_not(__m, __lo, __hi); }
# 234 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      char_type
      toupper(char_type __c) const
      { return this->do_toupper(__c); }
# 249 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      const char_type*
      toupper(char_type *__lo, const char_type* __hi) const
      { return this->do_toupper(__lo, __hi); }
# 263 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      char_type
      tolower(char_type __c) const
      { return this->do_tolower(__c); }
# 278 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      const char_type*
      tolower(char_type* __lo, const char_type* __hi) const
      { return this->do_tolower(__lo, __hi); }
# 295 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      char_type
      widen(char __c) const
      { return this->do_widen(__c); }
# 314 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      const char*
      widen(const char* __lo, const char* __hi, char_type* __to) const
      { return this->do_widen(__lo, __hi, __to); }
# 333 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      char
      narrow(char_type __c, char __dfault) const
      { return this->do_narrow(__c, __dfault); }
# 355 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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() { }
# 380 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      virtual bool
      do_is(mask __m, char_type __c) const = 0;
# 399 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      virtual const char_type*
      do_is(const char_type* __lo, const char_type* __hi,
     mask* __vec) const = 0;
# 418 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      virtual const char_type*
      do_scan_is(mask __m, const char_type* __lo,
   const char_type* __hi) const = 0;
# 437 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      virtual const char_type*
      do_scan_not(mask __m, const char_type* __lo,
    const char_type* __hi) const = 0;
# 455 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      virtual char_type
      do_toupper(char_type __c) const = 0;
# 472 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      virtual const char_type*
      do_toupper(char_type* __lo, const char_type* __hi) const = 0;
# 488 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      virtual char_type
      do_tolower(char_type __c) const = 0;
# 505 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      virtual const char_type*
      do_tolower(char_type* __lo, const char_type* __hi) const = 0;
# 524 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      virtual char_type
      do_widen(char __c) const = 0;
# 545 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      virtual const char*
      do_widen(const char* __lo, const char* __hi, char_type* __to) const = 0;
# 566 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      virtual char
      do_narrow(char_type __c, char __dfault) const = 0;
# 591 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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;
    };
# 614 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
  template<typename _CharT>
    class ctype : public __ctype_abstract_base<_CharT>
    {
    public:

      typedef _CharT char_type;
      typedef typename __ctype_abstract_base<_CharT>::mask mask;


      static locale::id id;

      explicit
      ctype(size_t __refs = 0) : __ctype_abstract_base<_CharT>(__refs) { }

   protected:
      virtual
      ~ctype();

      virtual bool
      do_is(mask __m, char_type __c) const;

      virtual const char_type*
      do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;

      virtual const char_type*
      do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;

      virtual const char_type*
      do_scan_not(mask __m, const char_type* __lo,
    const char_type* __hi) const;

      virtual char_type
      do_toupper(char_type __c) const;

      virtual const char_type*
      do_toupper(char_type* __lo, const char_type* __hi) const;

      virtual char_type
      do_tolower(char_type __c) const;

      virtual const char_type*
      do_tolower(char_type* __lo, const char_type* __hi) const;

      virtual char_type
      do_widen(char __c) const;

      virtual const char*
      do_widen(const char* __lo, const char* __hi, char_type* __dest) const;

      virtual char
      do_narrow(char_type, char __dfault) const;

      virtual const char_type*
      do_narrow(const char_type* __lo, const char_type* __hi,
  char __dfault, char* __to) const;
    };

  template<typename _CharT>
    locale::id ctype<_CharT>::id;



  template<typename _CharT, typename _Traits, typename _Alloc>
    class ctype<basic_string<_CharT, _Traits, _Alloc> >;
# 688 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
  template<>
    class ctype<char> : public locale::facet, public ctype_base
    {
    public:


      typedef char char_type;

    protected:

      __c_locale _M_c_locale_ctype;
      bool _M_del;
      __to_type _M_toupper;
      __to_type _M_tolower;
      const mask* _M_table;
      mutable char _M_widen_ok;
      mutable char _M_widen[1 + static_cast<unsigned char>(-1)];
      mutable char _M_narrow[1 + static_cast<unsigned char>(-1)];
      mutable char _M_narrow_ok;


    public:

      static locale::id id;

      static const size_t table_size = 1 + static_cast<unsigned char>(-1);
# 725 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      explicit
      ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0);
# 738 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      explicit
      ctype(__c_locale __cloc, const mask* __table = 0, bool __del = false,
     size_t __refs = 0);
# 751 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      inline bool
      is(mask __m, char __c) const;
# 766 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      inline const char*
      is(const char* __lo, const char* __hi, mask* __vec) const;
# 780 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      inline const char*
      scan_is(mask __m, const char* __lo, const char* __hi) const;
# 794 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      inline const char*
      scan_not(mask __m, const char* __lo, const char* __hi) const;
# 809 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      char_type
      toupper(char_type __c) const
      { return this->do_toupper(__c); }
# 826 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      const char_type*
      toupper(char_type *__lo, const char_type* __hi) const
      { return this->do_toupper(__lo, __hi); }
# 842 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      char_type
      tolower(char_type __c) const
      { return this->do_tolower(__c); }
# 859 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      const char_type*
      tolower(char_type* __lo, const char_type* __hi) const
      { return this->do_tolower(__lo, __hi); }
# 879 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      char_type
      widen(char __c) const
      {
 if (_M_widen_ok)
   return _M_widen[static_cast<unsigned char>(__c)];
 this->_M_widen_init();
 return this->do_widen(__c);
      }
# 906 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      const char*
      widen(const char* __lo, const char* __hi, char_type* __to) const
      {
 if (_M_widen_ok == 1)
   {
     if (__builtin_expect(__hi != __lo, true))
       __builtin_memcpy(__to, __lo, __hi - __lo);
     return __hi;
   }
 if (!_M_widen_ok)
   _M_widen_init();
 return this->do_widen(__lo, __hi, __to);
      }
# 938 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      char
      narrow(char_type __c, char __dfault) const
      {
 if (_M_narrow[static_cast<unsigned char>(__c)])
   return _M_narrow[static_cast<unsigned char>(__c)];
 const char __t = do_narrow(__c, __dfault);
 if (__t != __dfault)
   _M_narrow[static_cast<unsigned char>(__c)] = __t;
 return __t;
      }
# 971 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      const char_type*
      narrow(const char_type* __lo, const char_type* __hi,
      char __dfault, char* __to) const
      {
 if (__builtin_expect(_M_narrow_ok == 1, true))
   {
     if (__builtin_expect(__hi != __lo, true))
       __builtin_memcpy(__to, __lo, __hi - __lo);
     return __hi;
   }
 if (!_M_narrow_ok)
   _M_narrow_init();
 return this->do_narrow(__lo, __hi, __dfault, __to);
      }





      const mask*
      table() const throw()
      { return _M_table; }


      static const mask*
      classic_table() throw();
    protected:







      virtual
      ~ctype();
# 1021 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      virtual char_type
      do_toupper(char_type __c) const;
# 1038 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      virtual const char_type*
      do_toupper(char_type* __lo, const char_type* __hi) const;
# 1054 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      virtual char_type
      do_tolower(char_type __c) const;
# 1071 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      virtual const char_type*
      do_tolower(char_type* __lo, const char_type* __hi) const;
# 1091 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      virtual char_type
      do_widen(char __c) const
      { return __c; }
# 1114 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      virtual const char*
      do_widen(const char* __lo, const char* __hi, char_type* __to) const
      {
 if (__builtin_expect(__hi != __lo, true))
   __builtin_memcpy(__to, __lo, __hi - __lo);
 return __hi;
      }
# 1141 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      virtual char
      do_narrow(char_type __c, char __dfault __attribute__((__unused__))) const
      { return __c; }
# 1167 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      virtual const char_type*
      do_narrow(const char_type* __lo, const char_type* __hi,
  char __dfault __attribute__((__unused__)), char* __to) const
      {
 if (__builtin_expect(__hi != __lo, true))
   __builtin_memcpy(__to, __lo, __hi - __lo);
 return __hi;
      }

    private:
      void _M_narrow_init() const;
      void _M_widen_init() const;
    };
# 1193 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
  template<>
    class ctype<wchar_t> : public __ctype_abstract_base<wchar_t>
    {
    public:


      typedef wchar_t char_type;
      typedef wctype_t __wmask_type;

    protected:
      __c_locale _M_c_locale_ctype;


      bool _M_narrow_ok;
      char _M_narrow[128];
      wint_t _M_widen[1 + static_cast<unsigned char>(-1)];


      mask _M_bit[16];
      __wmask_type _M_wmask[16];

    public:


      static locale::id id;
# 1226 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      explicit
      ctype(size_t __refs = 0);
# 1237 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      explicit
      ctype(__c_locale __cloc, size_t __refs = 0);

    protected:
      __wmask_type
      _M_convert_to_wmask(const mask __m) const throw();


      virtual
      ~ctype();
# 1261 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      virtual bool
      do_is(mask __m, char_type __c) const;
# 1280 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      virtual const char_type*
      do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const;
# 1298 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      virtual const char_type*
      do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const;
# 1316 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      virtual const char_type*
      do_scan_not(mask __m, const char_type* __lo,
    const char_type* __hi) const;
# 1333 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      virtual char_type
      do_toupper(char_type __c) const;
# 1350 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      virtual const char_type*
      do_toupper(char_type* __lo, const char_type* __hi) const;
# 1366 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      virtual char_type
      do_tolower(char_type __c) const;
# 1383 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      virtual const char_type*
      do_tolower(char_type* __lo, const char_type* __hi) const;
# 1403 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      virtual char_type
      do_widen(char __c) const;
# 1425 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      virtual const char*
      do_widen(const char* __lo, const char* __hi, char_type* __to) const;
# 1448 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      virtual char
      do_narrow(char_type __c, char __dfault) const;
# 1474 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      virtual const char_type*
      do_narrow(const char_type* __lo, const char_type* __hi,
  char __dfault, char* __to) const;


      void
      _M_initialize_ctype() throw();
    };



  template<typename _CharT>
    class ctype_byname : public ctype<_CharT>
    {
    public:
      typedef typename ctype<_CharT>::mask mask;

      explicit
      ctype_byname(const char* __s, size_t __refs = 0);


      explicit
      ctype_byname(const string& __s, size_t __refs = 0)
      : ctype_byname(__s.c_str(), __refs) { }


    protected:
      virtual
      ~ctype_byname() { }
    };


  template<>
    class ctype_byname<char> : public ctype<char>
    {
    public:
      explicit
      ctype_byname(const char* __s, size_t __refs = 0);


      explicit
      ctype_byname(const string& __s, size_t __refs = 0);


    protected:
      virtual
      ~ctype_byname();
    };


  template<>
    class ctype_byname<wchar_t> : public ctype<wchar_t>
    {
    public:
      explicit
      ctype_byname(const char* __s, size_t __refs = 0);


      explicit
      ctype_byname(const string& __s, size_t __refs = 0);


    protected:
      virtual
      ~ctype_byname();
    };



}


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/ctype_inline.h" 1 3
# 37 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/ctype_inline.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{


  bool
  ctype<char>::
  is(mask __m, char __c) const
  { return _M_table[static_cast<unsigned char>(__c)] & __m; }

  const char*
  ctype<char>::
  is(const char* __low, const char* __high, mask* __vec) const
  {
    while (__low < __high)
      *__vec++ = _M_table[static_cast<unsigned char>(*__low++)];
    return __high;
  }

  const char*
  ctype<char>::
  scan_is(mask __m, const char* __low, const char* __high) const
  {
    while (__low < __high
    && !(_M_table[static_cast<unsigned char>(*__low)] & __m))
      ++__low;
    return __low;
  }

  const char*
  ctype<char>::
  scan_not(mask __m, const char* __low, const char* __high) const
  {
    while (__low < __high
    && (_M_table[static_cast<unsigned char>(*__low)] & __m) != 0)
      ++__low;
    return __low;
  }


}
# 1547 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{



  class __num_base
  {
  public:


    enum
      {
 _S_ominus,
 _S_oplus,
 _S_ox,
 _S_oX,
 _S_odigits,
 _S_odigits_end = _S_odigits + 16,
 _S_oudigits = _S_odigits_end,
 _S_oudigits_end = _S_oudigits + 16,
 _S_oe = _S_odigits + 14,
 _S_oE = _S_oudigits + 14,
 _S_oend = _S_oudigits_end
      };






    static const char* _S_atoms_out;



    static const char* _S_atoms_in;

    enum
    {
      _S_iminus,
      _S_iplus,
      _S_ix,
      _S_iX,
      _S_izero,
      _S_ie = _S_izero + 14,
      _S_iE = _S_izero + 20,
      _S_iend = 26
    };



    static void
    _S_format_float(const ios_base& __io, char* __fptr, char __mod) throw();
  };

  template<typename _CharT>
    struct __numpunct_cache : public locale::facet
    {
      const char* _M_grouping;
      size_t _M_grouping_size;
      bool _M_use_grouping;
      const _CharT* _M_truename;
      size_t _M_truename_size;
      const _CharT* _M_falsename;
      size_t _M_falsename_size;
      _CharT _M_decimal_point;
      _CharT _M_thousands_sep;





      _CharT _M_atoms_out[__num_base::_S_oend];





      _CharT _M_atoms_in[__num_base::_S_iend];

      bool _M_allocated;

      __numpunct_cache(size_t __refs = 0)
      : facet(__refs), _M_grouping(0), _M_grouping_size(0),
 _M_use_grouping(false),
 _M_truename(0), _M_truename_size(0), _M_falsename(0),
 _M_falsename_size(0), _M_decimal_point(_CharT()),
 _M_thousands_sep(_CharT()), _M_allocated(false)
 { }

      ~__numpunct_cache();

      void
      _M_cache(const locale& __loc);

    private:
      __numpunct_cache&
      operator=(const __numpunct_cache&);

      explicit
      __numpunct_cache(const __numpunct_cache&);
    };

  template<typename _CharT>
    __numpunct_cache<_CharT>::~__numpunct_cache()
    {
      if (_M_allocated)
 {
   delete [] _M_grouping;
   delete [] _M_truename;
   delete [] _M_falsename;
 }
    }

namespace __cxx11 {
# 1677 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
  template<typename _CharT>
    class numpunct : public locale::facet
    {
    public:



      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;

      typedef __numpunct_cache<_CharT> __cache_type;

    protected:
      __cache_type* _M_data;

    public:

      static locale::id id;






      explicit
      numpunct(size_t __refs = 0)
      : facet(__refs), _M_data(0)
      { _M_initialize_numpunct(); }
# 1715 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      explicit
      numpunct(__cache_type* __cache, size_t __refs = 0)
      : facet(__refs), _M_data(__cache)
      { _M_initialize_numpunct(); }
# 1729 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      explicit
      numpunct(__c_locale __cloc, size_t __refs = 0)
      : facet(__refs), _M_data(0)
      { _M_initialize_numpunct(__cloc); }
# 1743 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      char_type
      decimal_point() const
      { return this->do_decimal_point(); }
# 1756 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      char_type
      thousands_sep() const
      { return this->do_thousands_sep(); }
# 1787 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      string
      grouping() const
      { return this->do_grouping(); }
# 1800 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      string_type
      truename() const
      { return this->do_truename(); }
# 1813 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      string_type
      falsename() const
      { return this->do_falsename(); }

    protected:

      virtual
      ~numpunct();
# 1830 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      virtual char_type
      do_decimal_point() const
      { return _M_data->_M_decimal_point; }
# 1842 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      virtual char_type
      do_thousands_sep() const
      { return _M_data->_M_thousands_sep; }
# 1855 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      virtual string
      do_grouping() const
      { return _M_data->_M_grouping; }
# 1868 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      virtual string_type
      do_truename() const
      { return _M_data->_M_truename; }
# 1881 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      virtual string_type
      do_falsename() const
      { return _M_data->_M_falsename; }


      void
      _M_initialize_numpunct(__c_locale __cloc = 0);
    };

  template<typename _CharT>
    locale::id numpunct<_CharT>::id;

  template<>
    numpunct<char>::~numpunct();

  template<>
    void
    numpunct<char>::_M_initialize_numpunct(__c_locale __cloc);


  template<>
    numpunct<wchar_t>::~numpunct();

  template<>
    void
    numpunct<wchar_t>::_M_initialize_numpunct(__c_locale __cloc);



  template<typename _CharT>
    class numpunct_byname : public numpunct<_CharT>
    {
    public:
      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;

      explicit
      numpunct_byname(const char* __s, size_t __refs = 0)
      : numpunct<_CharT>(__refs)
      {
 if (__builtin_strcmp(__s, "C") != 0
     && __builtin_strcmp(__s, "POSIX") != 0)
   {
     __c_locale __tmp;
     this->_S_create_c_locale(__tmp, __s);
     this->_M_initialize_numpunct(__tmp);
     this->_S_destroy_c_locale(__tmp);
   }
      }


      explicit
      numpunct_byname(const string& __s, size_t __refs = 0)
      : numpunct_byname(__s.c_str(), __refs) { }


    protected:
      virtual
      ~numpunct_byname() { }
    };

}
# 1959 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
  template<typename _CharT, typename _InIter>
    class num_get : public locale::facet
    {
    public:



      typedef _CharT char_type;
      typedef _InIter iter_type;



      static locale::id id;
# 1980 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      explicit
      num_get(size_t __refs = 0) : facet(__refs) { }
# 2006 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
   ios_base::iostate& __err, bool& __v) const
      { return this->do_get(__in, __end, __io, __err, __v); }
# 2043 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
   ios_base::iostate& __err, long& __v) const
      { return this->do_get(__in, __end, __io, __err, __v); }

      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
   ios_base::iostate& __err, unsigned short& __v) const
      { return this->do_get(__in, __end, __io, __err, __v); }

      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
   ios_base::iostate& __err, unsigned int& __v) const
      { return this->do_get(__in, __end, __io, __err, __v); }

      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
   ios_base::iostate& __err, unsigned long& __v) const
      { return this->do_get(__in, __end, __io, __err, __v); }


      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
   ios_base::iostate& __err, long long& __v) const
      { return this->do_get(__in, __end, __io, __err, __v); }

      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
   ios_base::iostate& __err, unsigned long long& __v) const
      { return this->do_get(__in, __end, __io, __err, __v); }
# 2103 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
   ios_base::iostate& __err, float& __v) const
      { return this->do_get(__in, __end, __io, __err, __v); }

      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
   ios_base::iostate& __err, double& __v) const
      { return this->do_get(__in, __end, __io, __err, __v); }

      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
   ios_base::iostate& __err, long double& __v) const
      { return this->do_get(__in, __end, __io, __err, __v); }
# 2146 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      iter_type
      get(iter_type __in, iter_type __end, ios_base& __io,
   ios_base::iostate& __err, void*& __v) const
      { return this->do_get(__in, __end, __io, __err, __v); }

    protected:

      virtual ~num_get() { }

      __attribute ((__abi_tag__ ("cxx11")))
      iter_type
      _M_extract_float(iter_type, iter_type, ios_base&, ios_base::iostate&,
         string&) const;

      template<typename _ValueT>
 __attribute ((__abi_tag__ ("cxx11")))
 iter_type
 _M_extract_int(iter_type, iter_type, ios_base&, ios_base::iostate&,
         _ValueT&) const;

      template<typename _CharT2>
      typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, int>::__type
 _M_find(const _CharT2*, size_t __len, _CharT2 __c) const
 {
   int __ret = -1;
   if (__len <= 10)
     {
       if (__c >= _CharT2('0') && __c < _CharT2(_CharT2('0') + __len))
  __ret = __c - _CharT2('0');
     }
   else
     {
       if (__c >= _CharT2('0') && __c <= _CharT2('9'))
  __ret = __c - _CharT2('0');
       else if (__c >= _CharT2('a') && __c <= _CharT2('f'))
  __ret = 10 + (__c - _CharT2('a'));
       else if (__c >= _CharT2('A') && __c <= _CharT2('F'))
  __ret = 10 + (__c - _CharT2('A'));
     }
   return __ret;
 }

      template<typename _CharT2>
      typename __gnu_cxx::__enable_if<!__is_char<_CharT2>::__value,
          int>::__type
 _M_find(const _CharT2* __zero, size_t __len, _CharT2 __c) const
 {
   int __ret = -1;
   const char_type* __q = char_traits<_CharT2>::find(__zero, __len, __c);
   if (__q)
     {
       __ret = __q - __zero;
       if (__ret > 15)
  __ret -= 6;
     }
   return __ret;
 }
# 2219 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      virtual iter_type
      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, bool&) const;

      virtual iter_type
      do_get(iter_type __beg, iter_type __end, ios_base& __io,
      ios_base::iostate& __err, long& __v) const
      { return _M_extract_int(__beg, __end, __io, __err, __v); }

      virtual iter_type
      do_get(iter_type __beg, iter_type __end, ios_base& __io,
      ios_base::iostate& __err, unsigned short& __v) const
      { return _M_extract_int(__beg, __end, __io, __err, __v); }

      virtual iter_type
      do_get(iter_type __beg, iter_type __end, ios_base& __io,
      ios_base::iostate& __err, unsigned int& __v) const
      { return _M_extract_int(__beg, __end, __io, __err, __v); }

      virtual iter_type
      do_get(iter_type __beg, iter_type __end, ios_base& __io,
      ios_base::iostate& __err, unsigned long& __v) const
      { return _M_extract_int(__beg, __end, __io, __err, __v); }


      virtual iter_type
      do_get(iter_type __beg, iter_type __end, ios_base& __io,
      ios_base::iostate& __err, long long& __v) const
      { return _M_extract_int(__beg, __end, __io, __err, __v); }

      virtual iter_type
      do_get(iter_type __beg, iter_type __end, ios_base& __io,
      ios_base::iostate& __err, unsigned long long& __v) const
      { return _M_extract_int(__beg, __end, __io, __err, __v); }


      virtual iter_type
      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, float&) const;

      virtual iter_type
      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
      double&) const;
# 2271 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      virtual iter_type
      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&,
      long double&) const;


      virtual iter_type
      do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, void*&) const;
# 2299 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
    };

  template<typename _CharT, typename _InIter>
    locale::id num_get<_CharT, _InIter>::id;
# 2317 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
  template<typename _CharT, typename _OutIter>
    class num_put : public locale::facet
    {
    public:



      typedef _CharT char_type;
      typedef _OutIter iter_type;



      static locale::id id;
# 2338 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      explicit
      num_put(size_t __refs = 0) : facet(__refs) { }
# 2356 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      iter_type
      put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
      { return this->do_put(__s, __io, __fill, __v); }
# 2398 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      iter_type
      put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
      { return this->do_put(__s, __io, __fill, __v); }

      iter_type
      put(iter_type __s, ios_base& __io, char_type __fill,
   unsigned long __v) const
      { return this->do_put(__s, __io, __fill, __v); }


      iter_type
      put(iter_type __s, ios_base& __io, char_type __fill, long long __v) const
      { return this->do_put(__s, __io, __fill, __v); }

      iter_type
      put(iter_type __s, ios_base& __io, char_type __fill,
   unsigned long long __v) const
      { return this->do_put(__s, __io, __fill, __v); }
# 2461 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      iter_type
      put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
      { return this->do_put(__s, __io, __fill, __v); }

      iter_type
      put(iter_type __s, ios_base& __io, char_type __fill,
   long double __v) const
      { return this->do_put(__s, __io, __fill, __v); }
# 2486 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      iter_type
      put(iter_type __s, ios_base& __io, char_type __fill,
   const void* __v) const
      { return this->do_put(__s, __io, __fill, __v); }

    protected:
      template<typename _ValueT>
 iter_type
 _M_insert_float(iter_type, ios_base& __io, char_type __fill,
   char __mod, _ValueT __v) const;

      void
      _M_group_float(const char* __grouping, size_t __grouping_size,
       char_type __sep, const char_type* __p, char_type* __new,
       char_type* __cs, int& __len) const;

      template<typename _ValueT>
 iter_type
 _M_insert_int(iter_type, ios_base& __io, char_type __fill,
        _ValueT __v) const;

      void
      _M_group_int(const char* __grouping, size_t __grouping_size,
     char_type __sep, ios_base& __io, char_type* __new,
     char_type* __cs, int& __len) const;

      void
      _M_pad(char_type __fill, streamsize __w, ios_base& __io,
      char_type* __new, const char_type* __cs, int& __len) const;


      virtual
      ~num_put() { }
# 2534 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
      virtual iter_type
      do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const;

      virtual iter_type
      do_put(iter_type __s, ios_base& __io, char_type __fill, long __v) const
      { return _M_insert_int(__s, __io, __fill, __v); }

      virtual iter_type
      do_put(iter_type __s, ios_base& __io, char_type __fill,
      unsigned long __v) const
      { return _M_insert_int(__s, __io, __fill, __v); }


      virtual iter_type
      do_put(iter_type __s, ios_base& __io, char_type __fill,
      long long __v) const
      { return _M_insert_int(__s, __io, __fill, __v); }

      virtual iter_type
      do_put(iter_type __s, ios_base& __io, char_type __fill,
      unsigned long long __v) const
      { return _M_insert_int(__s, __io, __fill, __v); }


      virtual iter_type
      do_put(iter_type, ios_base&, char_type, double) const;






      virtual iter_type
      do_put(iter_type, ios_base&, char_type, long double) const;


      virtual iter_type
      do_put(iter_type, ios_base&, char_type, const void*) const;
# 2586 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
    };

  template <typename _CharT, typename _OutIter>
    locale::id num_put<_CharT, _OutIter>::id;
# 2599 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 3
  template<typename _CharT>
    inline bool
    isspace(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::space, __c); }


  template<typename _CharT>
    inline bool
    isprint(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::print, __c); }


  template<typename _CharT>
    inline bool
    iscntrl(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::cntrl, __c); }


  template<typename _CharT>
    inline bool
    isupper(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::upper, __c); }


  template<typename _CharT>
    inline bool
    islower(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::lower, __c); }


  template<typename _CharT>
    inline bool
    isalpha(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alpha, __c); }


  template<typename _CharT>
    inline bool
    isdigit(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::digit, __c); }


  template<typename _CharT>
    inline bool
    ispunct(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::punct, __c); }


  template<typename _CharT>
    inline bool
    isxdigit(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::xdigit, __c); }


  template<typename _CharT>
    inline bool
    isalnum(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alnum, __c); }


  template<typename _CharT>
    inline bool
    isgraph(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::graph, __c); }



  template<typename _CharT>
    inline bool
    isblank(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::blank, __c); }



  template<typename _CharT>
    inline _CharT
    toupper(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).toupper(__c); }


  template<typename _CharT>
    inline _CharT
    tolower(_CharT __c, const locale& __loc)
    { return use_facet<ctype<_CharT> >(__loc).tolower(__c); }


}

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.tcc" 1 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.tcc" 3

namespace std __attribute__ ((__visibility__ ("default")))
{




  template<typename _Facet>
    struct __use_cache
    {
      const _Facet*
      operator() (const locale& __loc) const;
    };


  template<typename _CharT>
    struct __use_cache<__numpunct_cache<_CharT> >
    {
      const __numpunct_cache<_CharT>*
      operator() (const locale& __loc) const
      {
 const size_t __i = numpunct<_CharT>::id._M_id();
 const locale::facet** __caches = __loc._M_impl->_M_caches;
 if (!__caches[__i])
   {
     __numpunct_cache<_CharT>* __tmp = 0;
     try
       {
  __tmp = new __numpunct_cache<_CharT>;
  __tmp->_M_cache(__loc);
       }
     catch(...)
       {
  delete __tmp;
  throw;
       }
     __loc._M_impl->_M_install_cache(__tmp, __i);
   }
 return static_cast<const __numpunct_cache<_CharT>*>(__caches[__i]);
      }
    };

  template<typename _CharT>
    void
    __numpunct_cache<_CharT>::_M_cache(const locale& __loc)
    {
      const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);

      char* __grouping = 0;
      _CharT* __truename = 0;
      _CharT* __falsename = 0;
      try
 {
   const string& __g = __np.grouping();
   _M_grouping_size = __g.size();
   __grouping = new char[_M_grouping_size];
   __g.copy(__grouping, _M_grouping_size);
   _M_use_grouping = (_M_grouping_size
        && static_cast<signed char>(__grouping[0]) > 0
        && (__grouping[0]
     != __gnu_cxx::__numeric_traits<char>::__max));

   const basic_string<_CharT>& __tn = __np.truename();
   _M_truename_size = __tn.size();
   __truename = new _CharT[_M_truename_size];
   __tn.copy(__truename, _M_truename_size);

   const basic_string<_CharT>& __fn = __np.falsename();
   _M_falsename_size = __fn.size();
   __falsename = new _CharT[_M_falsename_size];
   __fn.copy(__falsename, _M_falsename_size);

   _M_decimal_point = __np.decimal_point();
   _M_thousands_sep = __np.thousands_sep();

   const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);
   __ct.widen(__num_base::_S_atoms_out,
       __num_base::_S_atoms_out
       + __num_base::_S_oend, _M_atoms_out);
   __ct.widen(__num_base::_S_atoms_in,
       __num_base::_S_atoms_in
       + __num_base::_S_iend, _M_atoms_in);

   _M_grouping = __grouping;
   _M_truename = __truename;
   _M_falsename = __falsename;
   _M_allocated = true;
 }
      catch(...)
 {
   delete [] __grouping;
   delete [] __truename;
   delete [] __falsename;
   throw;
 }
    }
# 139 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.tcc" 3
  __attribute__ ((__pure__)) bool
  __verify_grouping(const char* __grouping, size_t __grouping_size,
      const string& __grouping_tmp) throw ();



  template<typename _CharT, typename _InIter>
    __attribute ((__abi_tag__ ("cxx11")))
    _InIter
    num_get<_CharT, _InIter>::
    _M_extract_float(_InIter __beg, _InIter __end, ios_base& __io,
       ios_base::iostate& __err, string& __xtrc) const
    {
      typedef char_traits<_CharT> __traits_type;
      typedef __numpunct_cache<_CharT> __cache_type;
      __use_cache<__cache_type> __uc;
      const locale& __loc = __io._M_getloc();
      const __cache_type* __lc = __uc(__loc);
      const _CharT* __lit = __lc->_M_atoms_in;
      char_type __c = char_type();


      bool __testeof = __beg == __end;


      if (!__testeof)
 {
   __c = *__beg;
   const bool __plus = __c == __lit[__num_base::_S_iplus];
   if ((__plus || __c == __lit[__num_base::_S_iminus])
       && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
       && !(__c == __lc->_M_decimal_point))
     {
       __xtrc += __plus ? '+' : '-';
       if (++__beg != __end)
  __c = *__beg;
       else
  __testeof = true;
     }
 }


      bool __found_mantissa = false;
      int __sep_pos = 0;
      while (!__testeof)
 {
   if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
       || __c == __lc->_M_decimal_point)
     break;
   else if (__c == __lit[__num_base::_S_izero])
     {
       if (!__found_mantissa)
  {
    __xtrc += '0';
    __found_mantissa = true;
  }
       ++__sep_pos;

       if (++__beg != __end)
  __c = *__beg;
       else
  __testeof = true;
     }
   else
     break;
 }


      bool __found_dec = false;
      bool __found_sci = false;
      string __found_grouping;
      if (__lc->_M_use_grouping)
 __found_grouping.reserve(32);
      const char_type* __lit_zero = __lit + __num_base::_S_izero;

      if (!__lc->_M_allocated)

 while (!__testeof)
   {
     const int __digit = _M_find(__lit_zero, 10, __c);
     if (__digit != -1)
       {
  __xtrc += '0' + __digit;
  __found_mantissa = true;
       }
     else if (__c == __lc->_M_decimal_point
       && !__found_dec && !__found_sci)
       {
  __xtrc += '.';
  __found_dec = true;
       }
     else if ((__c == __lit[__num_base::_S_ie]
        || __c == __lit[__num_base::_S_iE])
       && !__found_sci && __found_mantissa)
       {

  __xtrc += 'e';
  __found_sci = true;


  if (++__beg != __end)
    {
      __c = *__beg;
      const bool __plus = __c == __lit[__num_base::_S_iplus];
      if (__plus || __c == __lit[__num_base::_S_iminus])
        __xtrc += __plus ? '+' : '-';
      else
        continue;
    }
  else
    {
      __testeof = true;
      break;
    }
       }
     else
       break;

     if (++__beg != __end)
       __c = *__beg;
     else
       __testeof = true;
   }
      else
 while (!__testeof)
   {


     if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
       {
  if (!__found_dec && !__found_sci)
    {


      if (__sep_pos)
        {
   __found_grouping += static_cast<char>(__sep_pos);
   __sep_pos = 0;
        }
      else
        {


   __xtrc.clear();
   break;
        }
    }
  else
    break;
       }
     else if (__c == __lc->_M_decimal_point)
       {
  if (!__found_dec && !__found_sci)
    {



      if (__found_grouping.size())
        __found_grouping += static_cast<char>(__sep_pos);
      __xtrc += '.';
      __found_dec = true;
    }
  else
    break;
       }
     else
       {
  const char_type* __q =
    __traits_type::find(__lit_zero, 10, __c);
  if (__q)
    {
      __xtrc += '0' + (__q - __lit_zero);
      __found_mantissa = true;
      ++__sep_pos;
    }
  else if ((__c == __lit[__num_base::_S_ie]
     || __c == __lit[__num_base::_S_iE])
    && !__found_sci && __found_mantissa)
    {

      if (__found_grouping.size() && !__found_dec)
        __found_grouping += static_cast<char>(__sep_pos);
      __xtrc += 'e';
      __found_sci = true;


      if (++__beg != __end)
        {
   __c = *__beg;
   const bool __plus = __c == __lit[__num_base::_S_iplus];
   if ((__plus || __c == __lit[__num_base::_S_iminus])
       && !(__lc->_M_use_grouping
     && __c == __lc->_M_thousands_sep)
       && !(__c == __lc->_M_decimal_point))
        __xtrc += __plus ? '+' : '-';
   else
     continue;
        }
      else
        {
   __testeof = true;
   break;
        }
    }
  else
    break;
       }

     if (++__beg != __end)
       __c = *__beg;
     else
       __testeof = true;
   }



      if (__found_grouping.size())
        {

   if (!__found_dec && !__found_sci)
     __found_grouping += static_cast<char>(__sep_pos);

          if (!std::__verify_grouping(__lc->_M_grouping,
          __lc->_M_grouping_size,
          __found_grouping))
     __err = ios_base::failbit;
        }

      return __beg;
    }

  template<typename _CharT, typename _InIter>
    template<typename _ValueT>
      __attribute ((__abi_tag__ ("cxx11")))
      _InIter
      num_get<_CharT, _InIter>::
      _M_extract_int(_InIter __beg, _InIter __end, ios_base& __io,
       ios_base::iostate& __err, _ValueT& __v) const
      {
        typedef char_traits<_CharT> __traits_type;
 using __gnu_cxx::__add_unsigned;
 typedef typename __add_unsigned<_ValueT>::__type __unsigned_type;
 typedef __numpunct_cache<_CharT> __cache_type;
 __use_cache<__cache_type> __uc;
 const locale& __loc = __io._M_getloc();
 const __cache_type* __lc = __uc(__loc);
 const _CharT* __lit = __lc->_M_atoms_in;
 char_type __c = char_type();


 const ios_base::fmtflags __basefield = __io.flags()
                                        & ios_base::basefield;
 const bool __oct = __basefield == ios_base::oct;
 int __base = __oct ? 8 : (__basefield == ios_base::hex ? 16 : 10);


 bool __testeof = __beg == __end;


 bool __negative = false;
 if (!__testeof)
   {
     __c = *__beg;
     __negative = __c == __lit[__num_base::_S_iminus];
     if ((__negative || __c == __lit[__num_base::_S_iplus])
  && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
  && !(__c == __lc->_M_decimal_point))
       {
  if (++__beg != __end)
    __c = *__beg;
  else
    __testeof = true;
       }
   }



 bool __found_zero = false;
 int __sep_pos = 0;
 while (!__testeof)
   {
     if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
  || __c == __lc->_M_decimal_point)
       break;
     else if (__c == __lit[__num_base::_S_izero]
       && (!__found_zero || __base == 10))
       {
  __found_zero = true;
  ++__sep_pos;
  if (__basefield == 0)
    __base = 8;
  if (__base == 8)
    __sep_pos = 0;
       }
     else if (__found_zero
       && (__c == __lit[__num_base::_S_ix]
    || __c == __lit[__num_base::_S_iX]))
       {
  if (__basefield == 0)
    __base = 16;
  if (__base == 16)
    {
      __found_zero = false;
      __sep_pos = 0;
    }
  else
    break;
       }
     else
       break;

     if (++__beg != __end)
       {
  __c = *__beg;
  if (!__found_zero)
    break;
       }
     else
       __testeof = true;
   }



 const size_t __len = (__base == 16 ? __num_base::_S_iend
         - __num_base::_S_izero : __base);


 typedef __gnu_cxx::__numeric_traits<_ValueT> __num_traits;
 string __found_grouping;
 if (__lc->_M_use_grouping)
   __found_grouping.reserve(32);
 bool __testfail = false;
 bool __testoverflow = false;
 const __unsigned_type __max =
   (__negative && __num_traits::__is_signed)
   ? -static_cast<__unsigned_type>(__num_traits::__min)
   : __num_traits::__max;
 const __unsigned_type __smax = __max / __base;
 __unsigned_type __result = 0;
 int __digit = 0;
 const char_type* __lit_zero = __lit + __num_base::_S_izero;

 if (!__lc->_M_allocated)

   while (!__testeof)
     {
       __digit = _M_find(__lit_zero, __len, __c);
       if (__digit == -1)
  break;

       if (__result > __smax)
  __testoverflow = true;
       else
  {
    __result *= __base;
    __testoverflow |= __result > __max - __digit;
    __result += __digit;
    ++__sep_pos;
  }

       if (++__beg != __end)
  __c = *__beg;
       else
  __testeof = true;
     }
 else
   while (!__testeof)
     {


       if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep)
  {


    if (__sep_pos)
      {
        __found_grouping += static_cast<char>(__sep_pos);
        __sep_pos = 0;
      }
    else
      {
        __testfail = true;
        break;
      }
  }
       else if (__c == __lc->_M_decimal_point)
  break;
       else
  {
    const char_type* __q =
      __traits_type::find(__lit_zero, __len, __c);
    if (!__q)
      break;

    __digit = __q - __lit_zero;
    if (__digit > 15)
      __digit -= 6;
    if (__result > __smax)
      __testoverflow = true;
    else
      {
        __result *= __base;
        __testoverflow |= __result > __max - __digit;
        __result += __digit;
        ++__sep_pos;
      }
  }

       if (++__beg != __end)
  __c = *__beg;
       else
  __testeof = true;
     }



 if (__found_grouping.size())
   {

     __found_grouping += static_cast<char>(__sep_pos);

     if (!std::__verify_grouping(__lc->_M_grouping,
     __lc->_M_grouping_size,
     __found_grouping))
       __err = ios_base::failbit;
   }



 if ((!__sep_pos && !__found_zero && !__found_grouping.size())
     || __testfail)
   {
     __v = 0;
     __err = ios_base::failbit;
   }
 else if (__testoverflow)
   {
     if (__negative && __num_traits::__is_signed)
       __v = __num_traits::__min;
     else
       __v = __num_traits::__max;
     __err = ios_base::failbit;
   }
 else
   __v = __negative ? -__result : __result;

 if (__testeof)
   __err |= ios_base::eofbit;
 return __beg;
      }



  template<typename _CharT, typename _InIter>
    _InIter
    num_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, ios_base& __io,
           ios_base::iostate& __err, bool& __v) const
    {
      if (!(__io.flags() & ios_base::boolalpha))
        {



   long __l = -1;
          __beg = _M_extract_int(__beg, __end, __io, __err, __l);
   if (__l == 0 || __l == 1)
     __v = bool(__l);
   else
     {


       __v = true;
       __err = ios_base::failbit;
       if (__beg == __end)
  __err |= ios_base::eofbit;
     }
        }
      else
        {

   typedef __numpunct_cache<_CharT> __cache_type;
   __use_cache<__cache_type> __uc;
   const locale& __loc = __io._M_getloc();
   const __cache_type* __lc = __uc(__loc);

   bool __testf = true;
   bool __testt = true;
   bool __donef = __lc->_M_falsename_size == 0;
   bool __donet = __lc->_M_truename_size == 0;
   bool __testeof = false;
   size_t __n = 0;
   while (!__donef || !__donet)
     {
       if (__beg == __end)
  {
    __testeof = true;
    break;
  }

       const char_type __c = *__beg;

       if (!__donef)
  __testf = __c == __lc->_M_falsename[__n];

       if (!__testf && __donet)
  break;

       if (!__donet)
  __testt = __c == __lc->_M_truename[__n];

       if (!__testt && __donef)
  break;

       if (!__testt && !__testf)
  break;

       ++__n;
       ++__beg;

       __donef = !__testf || __n >= __lc->_M_falsename_size;
       __donet = !__testt || __n >= __lc->_M_truename_size;
     }
   if (__testf && __n == __lc->_M_falsename_size && __n)
     {
       __v = false;
       if (__testt && __n == __lc->_M_truename_size)
  __err = ios_base::failbit;
       else
  __err = __testeof ? ios_base::eofbit : ios_base::goodbit;
     }
   else if (__testt && __n == __lc->_M_truename_size && __n)
     {
       __v = true;
       __err = __testeof ? ios_base::eofbit : ios_base::goodbit;
     }
   else
     {


       __v = false;
       __err = ios_base::failbit;
       if (__testeof)
  __err |= ios_base::eofbit;
     }
 }
      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    num_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, ios_base& __io,
    ios_base::iostate& __err, float& __v) const
    {
      string __xtrc;
      __xtrc.reserve(32);
      __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
      std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
      if (__beg == __end)
 __err |= ios_base::eofbit;
      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    num_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, ios_base& __io,
           ios_base::iostate& __err, double& __v) const
    {
      string __xtrc;
      __xtrc.reserve(32);
      __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
      std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
      if (__beg == __end)
 __err |= ios_base::eofbit;
      return __beg;
    }
# 735 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.tcc" 3
  template<typename _CharT, typename _InIter>
    _InIter
    num_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, ios_base& __io,
           ios_base::iostate& __err, long double& __v) const
    {
      string __xtrc;
      __xtrc.reserve(32);
      __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc);
      std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale());
      if (__beg == __end)
 __err |= ios_base::eofbit;
      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    num_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, ios_base& __io,
           ios_base::iostate& __err, void*& __v) const
    {

      typedef ios_base::fmtflags fmtflags;
      const fmtflags __fmt = __io.flags();
      __io.flags((__fmt & ~ios_base::basefield) | ios_base::hex);

      typedef __gnu_cxx::__conditional_type<(sizeof(void*)
          <= sizeof(unsigned long)),
 unsigned long, unsigned long long>::__type _UIntPtrType;

      _UIntPtrType __ul;
      __beg = _M_extract_int(__beg, __end, __io, __err, __ul);


      __io.flags(__fmt);

      __v = reinterpret_cast<void*>(__ul);
      return __beg;
    }
# 795 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.tcc" 3
  template<typename _CharT, typename _OutIter>
    void
    num_put<_CharT, _OutIter>::
    _M_pad(_CharT __fill, streamsize __w, ios_base& __io,
    _CharT* __new, const _CharT* __cs, int& __len) const
    {


      __pad<_CharT, char_traits<_CharT> >::_S_pad(__io, __fill, __new,
        __cs, __w, __len);
      __len = static_cast<int>(__w);
    }



  template<typename _CharT, typename _ValueT>
    int
    __int_to_char(_CharT* __bufend, _ValueT __v, const _CharT* __lit,
    ios_base::fmtflags __flags, bool __dec)
    {
      _CharT* __buf = __bufend;
      if (__builtin_expect(__dec, true))
 {

   do
     {
       *--__buf = __lit[(__v % 10) + __num_base::_S_odigits];
       __v /= 10;
     }
   while (__v != 0);
 }
      else if ((__flags & ios_base::basefield) == ios_base::oct)
 {

   do
     {
       *--__buf = __lit[(__v & 0x7) + __num_base::_S_odigits];
       __v >>= 3;
     }
   while (__v != 0);
 }
      else
 {

   const bool __uppercase = __flags & ios_base::uppercase;
   const int __case_offset = __uppercase ? __num_base::_S_oudigits
                                         : __num_base::_S_odigits;
   do
     {
       *--__buf = __lit[(__v & 0xf) + __case_offset];
       __v >>= 4;
     }
   while (__v != 0);
 }
      return __bufend - __buf;
    }



  template<typename _CharT, typename _OutIter>
    void
    num_put<_CharT, _OutIter>::
    _M_group_int(const char* __grouping, size_t __grouping_size, _CharT __sep,
   ios_base&, _CharT* __new, _CharT* __cs, int& __len) const
    {
      _CharT* __p = std::__add_grouping(__new, __sep, __grouping,
     __grouping_size, __cs, __cs + __len);
      __len = __p - __new;
    }

  template<typename _CharT, typename _OutIter>
    template<typename _ValueT>
      _OutIter
      num_put<_CharT, _OutIter>::
      _M_insert_int(_OutIter __s, ios_base& __io, _CharT __fill,
      _ValueT __v) const
      {
 using __gnu_cxx::__add_unsigned;
 typedef typename __add_unsigned<_ValueT>::__type __unsigned_type;
 typedef __numpunct_cache<_CharT> __cache_type;
 __use_cache<__cache_type> __uc;
 const locale& __loc = __io._M_getloc();
 const __cache_type* __lc = __uc(__loc);
 const _CharT* __lit = __lc->_M_atoms_out;
 const ios_base::fmtflags __flags = __io.flags();


 const int __ilen = 5 * sizeof(_ValueT);
 _CharT* __cs = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
            * __ilen));



 const ios_base::fmtflags __basefield = __flags & ios_base::basefield;
 const bool __dec = (__basefield != ios_base::oct
       && __basefield != ios_base::hex);
 const __unsigned_type __u = ((__v > 0 || !__dec)
         ? __unsigned_type(__v)
         : -__unsigned_type(__v));
  int __len = __int_to_char(__cs + __ilen, __u, __lit, __flags, __dec);
 __cs += __ilen - __len;


 if (__lc->_M_use_grouping)
   {


     _CharT* __cs2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
          * (__len + 1)
          * 2));
     _M_group_int(__lc->_M_grouping, __lc->_M_grouping_size,
    __lc->_M_thousands_sep, __io, __cs2 + 2, __cs, __len);
     __cs = __cs2 + 2;
   }


 if (__builtin_expect(__dec, true))
   {

     if (__v >= 0)
       {
  if (bool(__flags & ios_base::showpos)
      && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed)
    *--__cs = __lit[__num_base::_S_oplus], ++__len;
       }
     else
       *--__cs = __lit[__num_base::_S_ominus], ++__len;
   }
 else if (bool(__flags & ios_base::showbase) && __v)
   {
     if (__basefield == ios_base::oct)
       *--__cs = __lit[__num_base::_S_odigits], ++__len;
     else
       {

  const bool __uppercase = __flags & ios_base::uppercase;
  *--__cs = __lit[__num_base::_S_ox + __uppercase];

  *--__cs = __lit[__num_base::_S_odigits];
  __len += 2;
       }
   }


 const streamsize __w = __io.width();
 if (__w > static_cast<streamsize>(__len))
   {
     _CharT* __cs3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
          * __w));
     _M_pad(__fill, __w, __io, __cs3, __cs, __len);
     __cs = __cs3;
   }
 __io.width(0);



 return std::__write(__s, __cs, __len);
      }

  template<typename _CharT, typename _OutIter>
    void
    num_put<_CharT, _OutIter>::
    _M_group_float(const char* __grouping, size_t __grouping_size,
     _CharT __sep, const _CharT* __p, _CharT* __new,
     _CharT* __cs, int& __len) const
    {



      const int __declen = __p ? __p - __cs : __len;
      _CharT* __p2 = std::__add_grouping(__new, __sep, __grouping,
      __grouping_size,
      __cs, __cs + __declen);


      int __newlen = __p2 - __new;
      if (__p)
 {
   char_traits<_CharT>::copy(__p2, __p, __len - __declen);
   __newlen += __len - __declen;
 }
      __len = __newlen;
    }
# 989 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.tcc" 3
  template<typename _CharT, typename _OutIter>
    template<typename _ValueT>
      _OutIter
      num_put<_CharT, _OutIter>::
      _M_insert_float(_OutIter __s, ios_base& __io, _CharT __fill, char __mod,
         _ValueT __v) const
      {
 typedef __numpunct_cache<_CharT> __cache_type;
 __use_cache<__cache_type> __uc;
 const locale& __loc = __io._M_getloc();
 const __cache_type* __lc = __uc(__loc);


 const streamsize __prec = __io.precision() < 0 ? 6 : __io.precision();

 const int __max_digits =
   __gnu_cxx::__numeric_traits<_ValueT>::__digits10;


 int __len;

 char __fbuf[16];
 __num_base::_S_format_float(__io, __fbuf, __mod);



 const bool __use_prec =
   (__io.flags() & ios_base::floatfield) != ios_base::floatfield;



 int __cs_size = __max_digits * 3;
 char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));
 if (__use_prec)
   __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
     __fbuf, __prec, __v);
 else
   __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
     __fbuf, __v);


 if (__len >= __cs_size)
   {
     __cs_size = __len + 1;
     __cs = static_cast<char*>(__builtin_alloca(__cs_size));
     if (__use_prec)
       __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
         __fbuf, __prec, __v);
     else
       __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
         __fbuf, __v);
   }
# 1062 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.tcc" 3
 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

 _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
            * __len));
 __ctype.widen(__cs, __cs + __len, __ws);


 _CharT* __wp = 0;
 const char* __p = char_traits<char>::find(__cs, __len, '.');
 if (__p)
   {
     __wp = __ws + (__p - __cs);
     *__wp = __lc->_M_decimal_point;
   }




 if (__lc->_M_use_grouping
     && (__wp || __len < 3 || (__cs[1] <= '9' && __cs[2] <= '9'
          && __cs[1] >= '0' && __cs[2] >= '0')))
   {


     _CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
          * __len * 2));

     streamsize __off = 0;
     if (__cs[0] == '-' || __cs[0] == '+')
       {
  __off = 1;
  __ws2[0] = __ws[0];
  __len -= 1;
       }

     _M_group_float(__lc->_M_grouping, __lc->_M_grouping_size,
      __lc->_M_thousands_sep, __wp, __ws2 + __off,
      __ws + __off, __len);
     __len += __off;

     __ws = __ws2;
   }


 const streamsize __w = __io.width();
 if (__w > static_cast<streamsize>(__len))
   {
     _CharT* __ws3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
          * __w));
     _M_pad(__fill, __w, __io, __ws3, __ws, __len);
     __ws = __ws3;
   }
 __io.width(0);



 return std::__write(__s, __ws, __len);
      }

  template<typename _CharT, typename _OutIter>
    _OutIter
    num_put<_CharT, _OutIter>::
    do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const
    {
      const ios_base::fmtflags __flags = __io.flags();
      if ((__flags & ios_base::boolalpha) == 0)
        {
          const long __l = __v;
          __s = _M_insert_int(__s, __io, __fill, __l);
        }
      else
        {
   typedef __numpunct_cache<_CharT> __cache_type;
   __use_cache<__cache_type> __uc;
   const locale& __loc = __io._M_getloc();
   const __cache_type* __lc = __uc(__loc);

   const _CharT* __name = __v ? __lc->_M_truename
                              : __lc->_M_falsename;
   int __len = __v ? __lc->_M_truename_size
                   : __lc->_M_falsename_size;

   const streamsize __w = __io.width();
   if (__w > static_cast<streamsize>(__len))
     {
       const streamsize __plen = __w - __len;
       _CharT* __ps
  = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT)
       * __plen));

       char_traits<_CharT>::assign(__ps, __plen, __fill);
       __io.width(0);

       if ((__flags & ios_base::adjustfield) == ios_base::left)
  {
    __s = std::__write(__s, __name, __len);
    __s = std::__write(__s, __ps, __plen);
  }
       else
  {
    __s = std::__write(__s, __ps, __plen);
    __s = std::__write(__s, __name, __len);
  }
       return __s;
     }
   __io.width(0);
   __s = std::__write(__s, __name, __len);
 }
      return __s;
    }

  template<typename _CharT, typename _OutIter>
    _OutIter
    num_put<_CharT, _OutIter>::
    do_put(iter_type __s, ios_base& __io, char_type __fill, double __v) const
    { return _M_insert_float(__s, __io, __fill, char(), __v); }
# 1187 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.tcc" 3
  template<typename _CharT, typename _OutIter>
    _OutIter
    num_put<_CharT, _OutIter>::
    do_put(iter_type __s, ios_base& __io, char_type __fill,
    long double __v) const
    { return _M_insert_float(__s, __io, __fill, 'L', __v); }

  template<typename _CharT, typename _OutIter>
    _OutIter
    num_put<_CharT, _OutIter>::
    do_put(iter_type __s, ios_base& __io, char_type __fill,
           const void* __v) const
    {
      const ios_base::fmtflags __flags = __io.flags();
      const ios_base::fmtflags __fmt = ~(ios_base::basefield
      | ios_base::uppercase);
      __io.flags((__flags & __fmt) | (ios_base::hex | ios_base::showbase));

      typedef __gnu_cxx::__conditional_type<(sizeof(const void*)
          <= sizeof(unsigned long)),
 unsigned long, unsigned long long>::__type _UIntPtrType;

      __s = _M_insert_int(__s, __io, __fill,
     reinterpret_cast<_UIntPtrType>(__v));
      __io.flags(__flags);
      return __s;
    }
# 1233 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.tcc" 3
  template<typename _CharT, typename _Traits>
    void
    __pad<_CharT, _Traits>::_S_pad(ios_base& __io, _CharT __fill,
       _CharT* __news, const _CharT* __olds,
       streamsize __newlen, streamsize __oldlen)
    {
      const size_t __plen = static_cast<size_t>(__newlen - __oldlen);
      const ios_base::fmtflags __adjust = __io.flags() & ios_base::adjustfield;


      if (__adjust == ios_base::left)
 {
   _Traits::copy(__news, __olds, __oldlen);
   _Traits::assign(__news + __oldlen, __plen, __fill);
   return;
 }

      size_t __mod = 0;
      if (__adjust == ios_base::internal)
 {



          const locale& __loc = __io._M_getloc();
   const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

   if (__ctype.widen('-') == __olds[0]
       || __ctype.widen('+') == __olds[0])
     {
       __news[0] = __olds[0];
       __mod = 1;
       ++__news;
     }
   else if (__ctype.widen('0') == __olds[0]
     && __oldlen > 1
     && (__ctype.widen('x') == __olds[1]
         || __ctype.widen('X') == __olds[1]))
     {
       __news[0] = __olds[0];
       __news[1] = __olds[1];
       __mod = 2;
       __news += 2;
     }

 }
      _Traits::assign(__news, __plen, __fill);
      _Traits::copy(__news + __plen, __olds + __mod, __oldlen - __mod);
    }

  template<typename _CharT>
    _CharT*
    __add_grouping(_CharT* __s, _CharT __sep,
     const char* __gbeg, size_t __gsize,
     const _CharT* __first, const _CharT* __last)
    {
      size_t __idx = 0;
      size_t __ctr = 0;

      while (__last - __first > __gbeg[__idx]
      && static_cast<signed char>(__gbeg[__idx]) > 0
      && __gbeg[__idx] != __gnu_cxx::__numeric_traits<char>::__max)
 {
   __last -= __gbeg[__idx];
   __idx < __gsize - 1 ? ++__idx : ++__ctr;
 }

      while (__first != __last)
 *__s++ = *__first++;

      while (__ctr--)
 {
   *__s++ = __sep;
   for (char __i = __gbeg[__idx]; __i > 0; --__i)
     *__s++ = *__first++;
 }

      while (__idx--)
 {
   *__s++ = __sep;
   for (char __i = __gbeg[__idx]; __i > 0; --__i)
     *__s++ = *__first++;
 }

      return __s;
    }




  extern template class __cxx11:: numpunct<char>;
  extern template class __cxx11:: numpunct_byname<char>;
  extern template class num_get<char>;
  extern template class num_put<char>;
  extern template class ctype_byname<char>;

  extern template
    const ctype<char>*
    __try_use_facet<ctype<char> >(const locale&) noexcept;

  extern template
    const numpunct<char>*
    __try_use_facet<numpunct<char> >(const locale&) noexcept;

  extern template
    const num_put<char>*
    __try_use_facet<num_put<char> >(const locale&) noexcept;

  extern template
    const num_get<char>*
    __try_use_facet<num_get<char> >(const locale&) noexcept;

  extern template
    const ctype<char>&
    use_facet<ctype<char> >(const locale&);

  extern template
    const numpunct<char>&
    use_facet<numpunct<char> >(const locale&);

  extern template
    const num_put<char>&
    use_facet<num_put<char> >(const locale&);

  extern template
    const num_get<char>&
    use_facet<num_get<char> >(const locale&);

  extern template
    bool
    has_facet<ctype<char> >(const locale&);

  extern template
    bool
    has_facet<numpunct<char> >(const locale&);

  extern template
    bool
    has_facet<num_put<char> >(const locale&);

  extern template
    bool
    has_facet<num_get<char> >(const locale&);


  extern template class __cxx11:: numpunct<wchar_t>;
  extern template class __cxx11:: numpunct_byname<wchar_t>;
  extern template class num_get<wchar_t>;
  extern template class num_put<wchar_t>;
  extern template class ctype_byname<wchar_t>;

  extern template
    const ctype<wchar_t>*
    __try_use_facet<ctype<wchar_t> >(const locale&) noexcept;

  extern template
    const numpunct<wchar_t>*
    __try_use_facet<numpunct<wchar_t> >(const locale&) noexcept;

  extern template
    const num_put<wchar_t>*
    __try_use_facet<num_put<wchar_t> >(const locale&) noexcept;

  extern template
    const num_get<wchar_t>*
    __try_use_facet<num_get<wchar_t> >(const locale&) noexcept;

  extern template
    const ctype<wchar_t>&
    use_facet<ctype<wchar_t> >(const locale&);

  extern template
    const numpunct<wchar_t>&
    use_facet<numpunct<wchar_t> >(const locale&);

  extern template
    const num_put<wchar_t>&
    use_facet<num_put<wchar_t> >(const locale&);

  extern template
    const num_get<wchar_t>&
    use_facet<num_get<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<ctype<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<numpunct<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<num_put<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<num_get<wchar_t> >(const locale&);




}
# 2688 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets.h" 2 3
# 38 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_ios.h" 2 3



namespace std __attribute__ ((__visibility__ ("default")))
{


  template<typename _Facet>
    inline const _Facet&
    __check_facet(const _Facet* __f)
    {
      if (!__f)
 __throw_bad_cast();
      return *__f;
    }
# 66 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_ios.h" 3
  template<typename _CharT, typename _Traits>
    class basic_ios : public ios_base
    {

      static_assert(is_same_v<_CharT, typename _Traits::char_type>);


    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:
# 121 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_ios.h" 3
      explicit operator bool() const
      { return !this->fail(); }





      bool
      operator!() const
      { return this->fail(); }
# 140 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_ios.h" 3
      iostate
      rdstate() const
      { return _M_streambuf_state; }
# 151 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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; }
# 204 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_ios.h" 3
      bool
      fail() const
      { return (this->rdstate() & (badbit | failbit)) != 0; }







      bool
      bad() const
      { return (this->rdstate() & badbit) != 0; }
# 225 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_ios.h" 3
      iostate
      exceptions() const
      { return _M_exception; }
# 260 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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() { }
# 298 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_ios.h" 3
      basic_ostream<_CharT, _Traits>*
      tie() const
      { return _M_tie; }
# 310 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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; }
# 350 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_ios.h" 3
      basic_streambuf<_CharT, _Traits>*
      rdbuf(basic_streambuf<_CharT, _Traits>* __sb);
# 364 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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;
      }
# 393 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_ios.h" 3
      char_type
      fill(char_type __ch)
      {
 char_type __old = this->fill();
 _M_fill = __ch;
 return __old;
      }
# 413 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_ios.h" 3
      locale
      imbue(const locale& __loc);
# 433 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_ios.h" 3
      char
      narrow(char_type __c, char __dfault) const
      { return __check_facet(_M_ctype).narrow(__c, __dfault); }
# 452 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_ios.tcc" 1 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_ios.tcc" 3

namespace std __attribute__ ((__visibility__ ("default")))
{


  template<typename _CharT, typename _Traits>
    void
    basic_ios<_CharT, _Traits>::clear(iostate __state)
    {
      if (this->rdbuf())
 _M_streambuf_state = __state;
      else
 _M_streambuf_state = __state | badbit;
      if (this->exceptions() & this->rdstate())
 __throw_ios_failure(("basic_ios::clear"));
    }

  template<typename _CharT, typename _Traits>
    basic_streambuf<_CharT, _Traits>*
    basic_ios<_CharT, _Traits>::rdbuf(basic_streambuf<_CharT, _Traits>* __sb)
    {
      basic_streambuf<_CharT, _Traits>* __old = _M_streambuf;
      _M_streambuf = __sb;
      this->clear();
      return __old;
    }

  template<typename _CharT, typename _Traits>
    basic_ios<_CharT, _Traits>&
    basic_ios<_CharT, _Traits>::copyfmt(const basic_ios& __rhs)
    {


      if (this != std::__addressof(__rhs))
 {




   _Words* __words = (__rhs._M_word_size <= _S_local_word_size) ?
                      _M_local_word : new _Words[__rhs._M_word_size];


   _Callback_list* __cb = __rhs._M_callbacks;
   if (__cb)
     __cb->_M_add_reference();
   _M_call_callbacks(erase_event);
   if (_M_word != _M_local_word)
     {
       delete [] _M_word;
       _M_word = 0;
     }
   _M_dispose_callbacks();


   _M_callbacks = __cb;
   for (int __i = 0; __i < __rhs._M_word_size; ++__i)
     __words[__i] = __rhs._M_word[__i];
   _M_word = __words;
   _M_word_size = __rhs._M_word_size;

   this->flags(__rhs.flags());
   this->width(__rhs.width());
   this->precision(__rhs.precision());
   this->tie(__rhs.tie());
   this->fill(__rhs.fill());
   _M_ios_locale = __rhs.getloc();
   _M_cache_locale(_M_ios_locale);

   _M_call_callbacks(copyfmt_event);


   this->exceptions(__rhs.exceptions());
 }
      return *this;
    }


  template<typename _CharT, typename _Traits>
    locale
    basic_ios<_CharT, _Traits>::imbue(const locale& __loc)
    {
      locale __old(this->getloc());
      ios_base::imbue(__loc);
      _M_cache_locale(__loc);
      if (this->rdbuf() != 0)
 this->rdbuf()->pubimbue(__loc);
      return __old;
    }

  template<typename _CharT, typename _Traits>
    void
    basic_ios<_CharT, _Traits>::init(basic_streambuf<_CharT, _Traits>* __sb)
    {

      ios_base::_M_init();


      _M_cache_locale(_M_ios_locale);
# 146 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_ios.tcc" 3
      _M_fill = _CharT();
      _M_fill_init = false;

      _M_tie = 0;
      _M_exception = goodbit;
      _M_streambuf = __sb;
      _M_streambuf_state = __sb ? goodbit : badbit;
    }

  template<typename _CharT, typename _Traits>
    void
    basic_ios<_CharT, _Traits>::_M_cache_locale(const locale& __loc)
    {
      _M_ctype = std::__try_use_facet<__ctype_type>(__loc);
      _M_num_put = std::__try_use_facet<__num_put_type>(__loc);
      _M_num_get = std::__try_use_facet<__num_get_type>(__loc);
    }




  extern template class basic_ios<char>;


  extern template class basic_ios<wchar_t>;




}
# 521 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/basic_ios.h" 2 3
# 47 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ios" 2 3


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 50 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ios" 2 3
# 41 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ostream" 2 3


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/format" 1 3
# 33 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/format" 3






# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/format" 2 3




# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/charconv" 1 3
# 33 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/charconv" 3
# 50 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/charconv" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 51 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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<typename _Tp>
    struct __to_chars_unsigned_type : __make_unsigned_selector_base
    {
      using _UInts = _List<unsigned int, unsigned long, unsigned long long

 , unsigned __int128

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

  template<typename _Tp>
    using __unsigned_least_t = typename __to_chars_unsigned_type<_Tp>::type;



  template<typename _Tp>
    constexpr unsigned
    __to_chars_len(_Tp __value, int __base ) noexcept;

  template<typename _Tp>
    constexpr unsigned
    __to_chars_len_2(_Tp __value) noexcept
    { return std::__bit_width(__value); }


  template<typename _Tp>
    constexpr to_chars_result
    __to_chars(char* __first, char* __last, _Tp __val, int __base) noexcept
    {
      static_assert(__integer_to_chars_is_unsigned<_Tp>, "implementation bug");

      to_chars_result __res;

      const unsigned __len = __to_chars_len(__val, __base);

      if (__builtin_expect((__last - __first) < __len, 0))
 {
   __res.ptr = __last;
   __res.ec = errc::value_too_large;
   return __res;
 }

      unsigned __pos = __len - 1;

      constexpr char __digits[] = {
 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
 'u', 'v', 'w', 'x', 'y', 'z'
      };

      while (__val >= (unsigned)__base)
 {
   auto const __quo = __val / __base;
   auto const __rem = __val % __base;
   __first[__pos--] = __digits[__rem];
   __val = __quo;
 }
      *__first = __digits[__val];

      __res.ptr = __first + __len;
      __res.ec = {};
      return __res;
    }

  template<typename _Tp>
    constexpr to_chars_result
    __to_chars_16(char* __first, char* __last, _Tp __val) noexcept
    {
      static_assert(__integer_to_chars_is_unsigned<_Tp>, "implementation bug");

      to_chars_result __res;

      const unsigned __len = (__to_chars_len_2(__val) + 3) / 4;

      if (__builtin_expect((__last - __first) < __len, 0))
 {
   __res.ptr = __last;
   __res.ec = errc::value_too_large;
   return __res;
 }

      constexpr char __digits[] = {
 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
 'a', 'b', 'c', 'd', 'e', 'f'
      };
      unsigned __pos = __len - 1;
      while (__val >= 0x100)
 {
   auto __num = __val & 0xF;
   __val >>= 4;
   __first[__pos] = __digits[__num];
   __num = __val & 0xF;
   __val >>= 4;
   __first[__pos - 1] = __digits[__num];
   __pos -= 2;
 }
      if (__val >= 0x10)
 {
   const auto __num = __val & 0xF;
   __val >>= 4;
   __first[1] = __digits[__num];
   __first[0] = __digits[__val];
 }
      else
 __first[0] = __digits[__val];
      __res.ptr = __first + __len;
      __res.ec = {};
      return __res;
    }

  template<typename _Tp>
    constexpr to_chars_result
    __to_chars_10(char* __first, char* __last, _Tp __val) noexcept
    {
      static_assert(__integer_to_chars_is_unsigned<_Tp>, "implementation bug");

      to_chars_result __res;

      const unsigned __len = __to_chars_len(__val, 10);

      if (__builtin_expect((__last - __first) < __len, 0))
 {
   __res.ptr = __last;
   __res.ec = errc::value_too_large;
   return __res;
 }

      __detail::__to_chars_10_impl(__first, __len, __val);
      __res.ptr = __first + __len;
      __res.ec = {};
      return __res;
    }

  template<typename _Tp>
    constexpr to_chars_result
    __to_chars_8(char* __first, char* __last, _Tp __val) noexcept
    {
      static_assert(__integer_to_chars_is_unsigned<_Tp>, "implementation bug");

      to_chars_result __res;
      unsigned __len = 0;

      if constexpr (__gnu_cxx::__int_traits<_Tp>::__digits <= 16)
 {
   __len = __val > 077777u ? 6u
     : __val > 07777u ? 5u
     : __val > 0777u ? 4u
     : __val > 077u ? 3u
     : __val > 07u ? 2u
     : 1u;
 }
      else
 __len = (__to_chars_len_2(__val) + 2) / 3;

      if (__builtin_expect((__last - __first) < __len, 0))
 {
   __res.ptr = __last;
   __res.ec = errc::value_too_large;
   return __res;
 }

      unsigned __pos = __len - 1;
      while (__val >= 0100)
 {
   auto __num = __val & 7;
   __val >>= 3;
   __first[__pos] = '0' + __num;
   __num = __val & 7;
   __val >>= 3;
   __first[__pos - 1] = '0' + __num;
   __pos -= 2;
 }
      if (__val >= 010)
 {
   auto const __num = __val & 7;
   __val >>= 3;
   __first[1] = '0' + __num;
   __first[0] = '0' + __val;
 }
      else
 __first[0] = '0' + __val;
      __res.ptr = __first + __len;
      __res.ec = {};
      return __res;
    }

  template<typename _Tp>
    constexpr to_chars_result
    __to_chars_2(char* __first, char* __last, _Tp __val) noexcept
    {
      static_assert(__integer_to_chars_is_unsigned<_Tp>, "implementation bug");

      to_chars_result __res;

      const unsigned __len = __to_chars_len_2(__val);

      if (__builtin_expect((__last - __first) < __len, 0))
 {
   __res.ptr = __last;
   __res.ec = errc::value_too_large;
   return __res;
 }

      unsigned __pos = __len - 1;

      while (__pos)
 {
   __first[__pos--] = '0' + (__val & 1);
   __val >>= 1;
 }



      __first[0] = '1';

      __res.ptr = __first + __len;
      __res.ec = {};
      return __res;
    }

}

  template<typename _Tp>
    constexpr to_chars_result
    __to_chars_i(char* __first, char* __last, _Tp __value, int __base = 10)
    {
      do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(2 <= __base && __base <= 36), false)) std::__glibcxx_assert_fail(); } while (false);

      using _Up = __detail::__unsigned_least_t<_Tp>;
      _Up __unsigned_val = __value;

      if (__first == __last) [[__unlikely__]]
 return { __last, errc::value_too_large };

      if (__value == 0)
 {
   *__first = '0';
   return { __first + 1, errc{} };
 }
      else if constexpr (std::is_signed<_Tp>::value)
 if (__value < 0)
   {
     *__first++ = '-';
     __unsigned_val = _Up(~__value) + _Up(1);
   }

      switch (__base)
      {
      case 16:
 return __detail::__to_chars_16(__first, __last, __unsigned_val);
      case 10:
 return __detail::__to_chars_10(__first, __last, __unsigned_val);
      case 8:
 return __detail::__to_chars_8(__first, __last, __unsigned_val);
      case 2:
 return __detail::__to_chars_2(__first, __last, __unsigned_val);
      default:
 return __detail::__to_chars(__first, __last, __unsigned_val, __base);
      }
    }





constexpr inline to_chars_result to_chars(char* __first, char* __last, char __value, int __base = 10) { return std::__to_chars_i<char>(__first, __last, __value, __base); }
constexpr inline to_chars_result to_chars(char* __first, char* __last, signed char __value, int __base = 10) { return std::__to_chars_i<signed char>(__first, __last, __value, __base); }
constexpr inline to_chars_result to_chars(char* __first, char* __last, unsigned char __value, int __base = 10) { return std::__to_chars_i<unsigned char>(__first, __last, __value, __base); }
constexpr inline to_chars_result to_chars(char* __first, char* __last, signed short __value, int __base = 10) { return std::__to_chars_i<signed short>(__first, __last, __value, __base); }
constexpr inline to_chars_result to_chars(char* __first, char* __last, unsigned short __value, int __base = 10) { return std::__to_chars_i<unsigned short>(__first, __last, __value, __base); }
constexpr inline to_chars_result to_chars(char* __first, char* __last, signed int __value, int __base = 10) { return std::__to_chars_i<signed int>(__first, __last, __value, __base); }
constexpr inline to_chars_result to_chars(char* __first, char* __last, unsigned int __value, int __base = 10) { return std::__to_chars_i<unsigned int>(__first, __last, __value, __base); }
constexpr inline to_chars_result to_chars(char* __first, char* __last, signed long __value, int __base = 10) { return std::__to_chars_i<signed long>(__first, __last, __value, __base); }
constexpr inline to_chars_result to_chars(char* __first, char* __last, unsigned long __value, int __base = 10) { return std::__to_chars_i<unsigned long>(__first, __last, __value, __base); }
constexpr inline to_chars_result to_chars(char* __first, char* __last, signed long long __value, int __base = 10) { return std::__to_chars_i<signed long long>(__first, __last, __value, __base); }
constexpr inline to_chars_result to_chars(char* __first, char* __last, unsigned long long __value, int __base = 10) { return std::__to_chars_i<unsigned long long>(__first, __last, __value, __base); }

constexpr inline to_chars_result to_chars(char* __first, char* __last, signed __int128 __value, int __base = 10) { return std::__to_chars_i<signed __int128>(__first, __last, __value, __base); }
constexpr inline to_chars_result to_chars(char* __first, char* __last, unsigned __int128 __value, int __base = 10) { return std::__to_chars_i<unsigned __int128>(__first, __last, __value, __base); }
# 391 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/charconv" 3
  to_chars_result to_chars(char*, char*, bool, int = 10) = delete;

namespace __detail
{
  template<typename _Tp>
    constexpr bool
    __raise_and_add(_Tp& __val, int __base, unsigned char __c)
    {
      if (__builtin_mul_overflow(__val, __base, &__val)
   || __builtin_add_overflow(__val, __c, &__val))
 return false;
      return true;
    }

  template<bool _DecOnly>
    struct __from_chars_alnum_to_val_table
    {
      struct type { unsigned char __data[1u << 8] = {}; };



      static constexpr type
      _S_make_table()
      {
 constexpr unsigned char __lower_letters[27] = "abcdefghijklmnopqrstuvwxyz";
 constexpr unsigned char __upper_letters[27] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
 type __table;
 for (auto& __entry : __table.__data)
   __entry = 127;
 for (int __i = 0; __i < 10; ++__i)
   __table.__data['0' + __i] = __i;
 for (int __i = 0; __i < 26; ++__i)
   {
     __table.__data[__lower_letters[__i]] = 10 + __i;
     __table.__data[__upper_letters[__i]] = 10 + __i;
   }
 return __table;
      }




      static constexpr type value = (_DecOnly, _S_make_table());
    };
# 446 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/charconv" 3
  template<bool _DecOnly = false>
    constexpr unsigned char
    __from_chars_alnum_to_val(unsigned char __c)
    {
      if constexpr (_DecOnly)
 return static_cast<unsigned char>(__c - '0');
      else
 return __from_chars_alnum_to_val_table<_DecOnly>::value.__data[__c];
    }



  template<bool _DecOnly, typename _Tp>
    constexpr bool
    __from_chars_pow2_base(const char*& __first, const char* __last, _Tp& __val,
      int __base)
    {
      static_assert(is_integral<_Tp>::value, "implementation bug");
      static_assert(is_unsigned<_Tp>::value, "implementation bug");



      const int __log2_base = __countr_zero(unsigned(__base & 0x3f));

      const ptrdiff_t __len = __last - __first;
      ptrdiff_t __i = 0;
      while (__i < __len && __first[__i] == '0')
 ++__i;
      const ptrdiff_t __leading_zeroes = __i;
      if (__i >= __len) [[__unlikely__]]
 {
   __first += __i;
   return true;
 }


      unsigned char __leading_c = 0;
      if (__base != 2)
 {
   __leading_c = __from_chars_alnum_to_val<_DecOnly>(__first[__i]);

   if (__leading_c >= __base) [[__unlikely__]]
     {
       __first += __i;
       return true;
     }
   __val = __leading_c;
   ++__i;
 }

      for (; __i < __len; ++__i)
 {
   const unsigned char __c = __from_chars_alnum_to_val<_DecOnly>(__first[__i]);
   if (__c >= __base)
     break;
   __val = (__val << __log2_base) | __c;
 }
      __first += __i;
      auto __significant_bits = (__i - __leading_zeroes) * __log2_base;
      if (__base != 2)


 __significant_bits -= __log2_base - __bit_width(__leading_c);

      return __significant_bits <= __gnu_cxx::__int_traits<_Tp>::__digits;
    }



  template<bool _DecOnly, typename _Tp>
    constexpr bool
    __from_chars_alnum(const char*& __first, const char* __last, _Tp& __val,
         int __base)
    {


      const int __bits_per_digit = __bit_width(unsigned(__base & 0x3f));
      int __unused_bits_lower_bound = __gnu_cxx::__int_traits<_Tp>::__digits;
      for (; __first != __last; ++__first)
 {
   const unsigned char __c = __from_chars_alnum_to_val<_DecOnly>(*__first);
   if (__c >= __base)
     return true;

   __unused_bits_lower_bound -= __bits_per_digit;
   if (__unused_bits_lower_bound >= 0) [[__likely__]]

     __val = __val * __base + __c;
   else if (!__raise_and_add(__val, __base, __c)) [[__unlikely__]]
     {
       while (++__first != __last
       && __from_chars_alnum_to_val<_DecOnly>(*__first) < __base)
  ;
       return false;
     }
 }
      return true;
    }

}


  template<typename _Tp,
    enable_if_t<__or_<__is_standard_integer<_Tp>,
        is_same<char, remove_cv_t<_Tp>>>::value, int> = 0>
    constexpr from_chars_result
    from_chars(const char* __first, const char* __last, _Tp& __value,
        int __base = 10)
    {
      do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(2 <= __base && __base <= 36), false)) std::__glibcxx_assert_fail(); } while (false);

      from_chars_result __res{__first, {}};

      int __sign = 1;
      if constexpr (std::is_signed<_Tp>::value)
 if (__first != __last && *__first == '-')
   {
     __sign = -1;
     ++__first;
   }

      using _Up = __detail::__unsigned_least_t<_Tp>;
      _Up __val = 0;

      const auto __start = __first;
      bool __valid;
      if ((__base & (__base - 1)) == 0)
 {
   if (__base <= 8)
     __valid = __detail::__from_chars_pow2_base<true>(__first, __last, __val, __base);
   else
     __valid = __detail::__from_chars_pow2_base<false>(__first, __last, __val, __base);
 }
      else if (__base <= 10)
 __valid = __detail::__from_chars_alnum<true>(__first, __last, __val, __base);
      else
 __valid = __detail::__from_chars_alnum<false>(__first, __last, __val, __base);

      if (__builtin_expect(__first == __start, 0))
 __res.ec = errc::invalid_argument;
      else
 {
   __res.ptr = __first;
   if (!__valid)
     __res.ec = errc::result_out_of_range;
   else
     {
       if constexpr (std::is_signed<_Tp>::value)
  {
    _Tp __tmp;
    if (__builtin_mul_overflow(__val, __sign, &__tmp))
      __res.ec = errc::result_out_of_range;
    else
      __value = __tmp;
  }
       else
  {
    if constexpr (__gnu_cxx::__int_traits<_Up>::__max
        > __gnu_cxx::__int_traits<_Tp>::__max)
      {
        if (__val > __gnu_cxx::__int_traits<_Tp>::__max)
   __res.ec = errc::result_out_of_range;
        else
   __value = __val;
      }
    else
      __value = __val;
  }
     }
 }
      return __res;
    }


  enum class chars_format
  {
    scientific = 1, fixed = 2, hex = 4, general = fixed | scientific
  };

  [[nodiscard]]
  constexpr chars_format
  operator|(chars_format __lhs, chars_format __rhs) noexcept
  { return (chars_format)((unsigned)__lhs | (unsigned)__rhs); }

  [[nodiscard]]
  constexpr chars_format
  operator&(chars_format __lhs, chars_format __rhs) noexcept
  { return (chars_format)((unsigned)__lhs & (unsigned)__rhs); }

  [[nodiscard]]
  constexpr chars_format
  operator^(chars_format __lhs, chars_format __rhs) noexcept
  { return (chars_format)((unsigned)__lhs ^ (unsigned)__rhs); }

  [[nodiscard]]
  constexpr chars_format
  operator~(chars_format __fmt) noexcept
  { return (chars_format)~(unsigned)__fmt; }

  constexpr chars_format&
  operator|=(chars_format& __lhs, chars_format __rhs) noexcept
  { return __lhs = __lhs | __rhs; }

  constexpr chars_format&
  operator&=(chars_format& __lhs, chars_format __rhs) noexcept
  { return __lhs = __lhs & __rhs; }

  constexpr chars_format&
  operator^=(chars_format& __lhs, chars_format __rhs) noexcept
  { return __lhs = __lhs ^ __rhs; }


  from_chars_result
  from_chars(const char* __first, const char* __last, float& __value,
      chars_format __fmt = chars_format::general) noexcept;

  from_chars_result
  from_chars(const char* __first, const char* __last, double& __value,
      chars_format __fmt = chars_format::general) noexcept;

  from_chars_result
  from_chars(const char* __first, const char* __last, long double& __value,
      chars_format __fmt = chars_format::general) noexcept;



  from_chars_result
  __from_chars_float16_t(const char* __first, const char* __last,
    float& __value,
    chars_format __fmt = chars_format::general) noexcept;
  from_chars_result
  __from_chars_bfloat16_t(const char* __first, const char* __last,
     float& __value,
     chars_format __fmt = chars_format::general) noexcept;
# 777 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/charconv" 3
  to_chars_result to_chars(char* __first, char* __last, float __value) noexcept;
  to_chars_result to_chars(char* __first, char* __last, float __value,
      chars_format __fmt) noexcept;
  to_chars_result to_chars(char* __first, char* __last, float __value,
      chars_format __fmt, int __precision) noexcept;


  to_chars_result to_chars(char* __first, char* __last, double __value) noexcept;
  to_chars_result to_chars(char* __first, char* __last, double __value,
      chars_format __fmt) noexcept;
  to_chars_result to_chars(char* __first, char* __last, double __value,
      chars_format __fmt, int __precision) noexcept;


  to_chars_result to_chars(char* __first, char* __last, long double __value)
    noexcept;
  to_chars_result to_chars(char* __first, char* __last, long double __value,
      chars_format __fmt) noexcept;
  to_chars_result to_chars(char* __first, char* __last, long double __value,
      chars_format __fmt, int __precision) noexcept;



  to_chars_result __to_chars_float16_t(char* __first, char* __last,
           float __value,
           chars_format __fmt) noexcept;
  to_chars_result __to_chars_bfloat16_t(char* __first, char* __last,
     float __value,
     chars_format __fmt) noexcept;
# 933 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/charconv" 3
}
# 45 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/format" 2 3

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/limits" 1 3
# 41 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/limits" 3
# 158 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/limits" 3
  template<typename _Tp>
    struct numeric_limits : public __numeric_limits_base
    {


      static constexpr _Tp
      min() noexcept { return _Tp(); }


      static constexpr _Tp
      max() noexcept { return _Tp(); }




      static constexpr _Tp
      lowest() noexcept { return _Tp(); }




      static constexpr _Tp
      epsilon() noexcept { return _Tp(); }


      static constexpr _Tp
      round_error() noexcept { return _Tp(); }


      static constexpr _Tp
      infinity() noexcept { return _Tp(); }



      static constexpr _Tp
      quiet_NaN() noexcept { return _Tp(); }



      static constexpr _Tp
      signaling_NaN() noexcept { return _Tp(); }




      static constexpr _Tp
      denorm_min() noexcept { return _Tp(); }
    };




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

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

  template<typename _Tp>
    struct numeric_limits<const volatile _Tp>
    : public numeric_limits<_Tp> { };
# 383 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/limits" 3
  template<>
    struct numeric_limits<bool>
    {
      static constexpr bool is_specialized = true;

      static constexpr bool
      min() noexcept { return false; }

      static constexpr bool
      max() noexcept { return true; }


      static constexpr bool
      lowest() noexcept { return min(); }

      static constexpr int digits = 1;
      static constexpr int digits10 = 0;

      static constexpr int max_digits10 = 0;

      static constexpr bool is_signed = false;
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr bool
      epsilon() noexcept { return false; }

      static constexpr bool
      round_error() noexcept { return false; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm
       = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr bool
      infinity() noexcept { return false; }

      static constexpr bool
      quiet_NaN() noexcept { return false; }

      static constexpr bool
      signaling_NaN() noexcept { return false; }

      static constexpr bool
      denorm_min() noexcept { return false; }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = false;




      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
       = round_toward_zero;
    };


  template<>
    struct numeric_limits<char>
    {
      static constexpr bool is_specialized = true;

      static constexpr char
      min() noexcept { return (((char)(-1) < 0) ? -(((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0) - 1 : (char)0); }

      static constexpr char
      max() noexcept { return (((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0); }


      static constexpr char
      lowest() noexcept { return min(); }


      static constexpr int digits = (sizeof(char) * 8 - ((char)(-1) < 0));
      static constexpr int digits10 = ((sizeof(char) * 8 - ((char)(-1) < 0)) * 643L / 2136);

      static constexpr int max_digits10 = 0;

      static constexpr bool is_signed = ((char)(-1) < 0);
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr char
      epsilon() noexcept { return 0; }

      static constexpr char
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm
       = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr
      char infinity() noexcept { return char(); }

      static constexpr char
      quiet_NaN() noexcept { return char(); }

      static constexpr char
      signaling_NaN() noexcept { return char(); }

      static constexpr char
      denorm_min() noexcept { return static_cast<char>(0); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = !is_signed;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
       = round_toward_zero;
    };


  template<>
    struct numeric_limits<signed char>
    {
      static constexpr bool is_specialized = true;

      static constexpr signed char
      min() noexcept { return -127 - 1; }

      static constexpr signed char
      max() noexcept { return 127; }


      static constexpr signed char
      lowest() noexcept { return min(); }


      static constexpr int digits = (sizeof(signed char) * 8 - ((signed char)(-1) < 0));
      static constexpr int digits10
       = ((sizeof(signed char) * 8 - ((signed char)(-1) < 0)) * 643L / 2136);

      static constexpr int max_digits10 = 0;

      static constexpr bool is_signed = true;
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr signed char
      epsilon() noexcept { return 0; }

      static constexpr signed char
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm
       = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr signed char
      infinity() noexcept { return static_cast<signed char>(0); }

      static constexpr signed char
      quiet_NaN() noexcept { return static_cast<signed char>(0); }

      static constexpr signed char
      signaling_NaN() noexcept
      { return static_cast<signed char>(0); }

      static constexpr signed char
      denorm_min() noexcept
      { return static_cast<signed char>(0); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = false;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
       = round_toward_zero;
    };


  template<>
    struct numeric_limits<unsigned char>
    {
      static constexpr bool is_specialized = true;

      static constexpr unsigned char
      min() noexcept { return 0; }

      static constexpr unsigned char
      max() noexcept { return 127 * 2U + 1; }


      static constexpr unsigned char
      lowest() noexcept { return min(); }


      static constexpr int digits
       = (sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0));
      static constexpr int digits10
       = ((sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0)) * 643L / 2136);

      static constexpr int max_digits10 = 0;

      static constexpr bool is_signed = false;
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr unsigned char
      epsilon() noexcept { return 0; }

      static constexpr unsigned char
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm
       = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr unsigned char
      infinity() noexcept
      { return static_cast<unsigned char>(0); }

      static constexpr unsigned char
      quiet_NaN() noexcept
      { return static_cast<unsigned char>(0); }

      static constexpr unsigned char
      signaling_NaN() noexcept
      { return static_cast<unsigned char>(0); }

      static constexpr unsigned char
      denorm_min() noexcept
      { return static_cast<unsigned char>(0); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = true;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
       = round_toward_zero;
    };


  template<>
    struct numeric_limits<wchar_t>
    {
      static constexpr bool is_specialized = true;

      static constexpr wchar_t
      min() noexcept { return (((wchar_t)(-1) < 0) ? -(((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0) - 1 : (wchar_t)0); }

      static constexpr wchar_t
      max() noexcept { return (((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0); }


      static constexpr wchar_t
      lowest() noexcept { return min(); }


      static constexpr int digits = (sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0));
      static constexpr int digits10
       = ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) * 643L / 2136);

      static constexpr int max_digits10 = 0;

      static constexpr bool is_signed = ((wchar_t)(-1) < 0);
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr wchar_t
      epsilon() noexcept { return 0; }

      static constexpr wchar_t
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm
       = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr wchar_t
      infinity() noexcept { return wchar_t(); }

      static constexpr wchar_t
      quiet_NaN() noexcept { return wchar_t(); }

      static constexpr wchar_t
      signaling_NaN() noexcept { return wchar_t(); }

      static constexpr wchar_t
      denorm_min() noexcept { return wchar_t(); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = !is_signed;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
       = round_toward_zero;
    };



  template<>
    struct numeric_limits<char8_t>
    {
      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<char16_t>
    {
      static constexpr bool is_specialized = true;

      static constexpr char16_t
      min() noexcept { return (((char16_t)(-1) < 0) ? -(((char16_t)(-1) < 0) ? (((((char16_t)1 << ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char16_t)0) - 1 : (char16_t)0); }

      static constexpr char16_t
      max() noexcept { return (((char16_t)(-1) < 0) ? (((((char16_t)1 << ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char16_t)0); }

      static constexpr char16_t
      lowest() noexcept { return min(); }

      static constexpr int digits = (sizeof(char16_t) * 8 - ((char16_t)(-1) < 0));
      static constexpr int digits10 = ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) * 643L / 2136);
      static constexpr int max_digits10 = 0;
      static constexpr bool is_signed = ((char16_t)(-1) < 0);
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr char16_t
      epsilon() noexcept { return 0; }

      static constexpr char16_t
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr char16_t
      infinity() noexcept { return char16_t(); }

      static constexpr char16_t
      quiet_NaN() noexcept { return char16_t(); }

      static constexpr char16_t
      signaling_NaN() noexcept { return char16_t(); }

      static constexpr char16_t
      denorm_min() noexcept { return char16_t(); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = !is_signed;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style = round_toward_zero;
    };


  template<>
    struct numeric_limits<char32_t>
    {
      static constexpr bool is_specialized = true;

      static constexpr char32_t
      min() noexcept { return (((char32_t)(-1) < 0) ? -(((char32_t)(-1) < 0) ? (((((char32_t)1 << ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char32_t)0) - 1 : (char32_t)0); }

      static constexpr char32_t
      max() noexcept { return (((char32_t)(-1) < 0) ? (((((char32_t)1 << ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char32_t)0); }

      static constexpr char32_t
      lowest() noexcept { return min(); }

      static constexpr int digits = (sizeof(char32_t) * 8 - ((char32_t)(-1) < 0));
      static constexpr int digits10 = ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) * 643L / 2136);
      static constexpr int max_digits10 = 0;
      static constexpr bool is_signed = ((char32_t)(-1) < 0);
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr char32_t
      epsilon() noexcept { return 0; }

      static constexpr char32_t
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr char32_t
      infinity() noexcept { return char32_t(); }

      static constexpr char32_t
      quiet_NaN() noexcept { return char32_t(); }

      static constexpr char32_t
      signaling_NaN() noexcept { return char32_t(); }

      static constexpr char32_t
      denorm_min() noexcept { return char32_t(); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = !is_signed;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style = round_toward_zero;
    };



  template<>
    struct numeric_limits<short>
    {
      static constexpr bool is_specialized = true;

      static constexpr short
      min() noexcept { return -32767 - 1; }

      static constexpr short
      max() noexcept { return 32767; }


      static constexpr short
      lowest() noexcept { return min(); }


      static constexpr int digits = (sizeof(short) * 8 - ((short)(-1) < 0));
      static constexpr int digits10 = ((sizeof(short) * 8 - ((short)(-1) < 0)) * 643L / 2136);

      static constexpr int max_digits10 = 0;

      static constexpr bool is_signed = true;
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr short
      epsilon() noexcept { return 0; }

      static constexpr short
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm
       = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr short
      infinity() noexcept { return short(); }

      static constexpr short
      quiet_NaN() noexcept { return short(); }

      static constexpr short
      signaling_NaN() noexcept { return short(); }

      static constexpr short
      denorm_min() noexcept { return short(); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = false;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
       = round_toward_zero;
    };


  template<>
    struct numeric_limits<unsigned short>
    {
      static constexpr bool is_specialized = true;

      static constexpr unsigned short
      min() noexcept { return 0; }

      static constexpr unsigned short
      max() noexcept { return 32767 * 2U + 1; }


      static constexpr unsigned short
      lowest() noexcept { return min(); }


      static constexpr int digits
       = (sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0));
      static constexpr int digits10
       = ((sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0)) * 643L / 2136);

      static constexpr int max_digits10 = 0;

      static constexpr bool is_signed = false;
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr unsigned short
      epsilon() noexcept { return 0; }

      static constexpr unsigned short
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm
       = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr unsigned short
      infinity() noexcept
      { return static_cast<unsigned short>(0); }

      static constexpr unsigned short
      quiet_NaN() noexcept
      { return static_cast<unsigned short>(0); }

      static constexpr unsigned short
      signaling_NaN() noexcept
      { return static_cast<unsigned short>(0); }

      static constexpr unsigned short
      denorm_min() noexcept
      { return static_cast<unsigned short>(0); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = true;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
       = round_toward_zero;
    };


  template<>
    struct numeric_limits<int>
    {
      static constexpr bool is_specialized = true;

      static constexpr int
      min() noexcept { return -2147483647 - 1; }

      static constexpr int
      max() noexcept { return 2147483647; }


      static constexpr int
      lowest() noexcept { return min(); }


      static constexpr int digits = (sizeof(int) * 8 - ((int)(-1) < 0));
      static constexpr int digits10 = ((sizeof(int) * 8 - ((int)(-1) < 0)) * 643L / 2136);

      static constexpr int max_digits10 = 0;

      static constexpr bool is_signed = true;
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr int
      epsilon() noexcept { return 0; }

      static constexpr int
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm
       = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr int
      infinity() noexcept { return static_cast<int>(0); }

      static constexpr int
      quiet_NaN() noexcept { return static_cast<int>(0); }

      static constexpr int
      signaling_NaN() noexcept { return static_cast<int>(0); }

      static constexpr int
      denorm_min() noexcept { return static_cast<int>(0); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = false;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
       = round_toward_zero;
    };


  template<>
    struct numeric_limits<unsigned int>
    {
      static constexpr bool is_specialized = true;

      static constexpr unsigned int
      min() noexcept { return 0; }

      static constexpr unsigned int
      max() noexcept { return 2147483647 * 2U + 1; }


      static constexpr unsigned int
      lowest() noexcept { return min(); }


      static constexpr int digits
       = (sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0));
      static constexpr int digits10
       = ((sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0)) * 643L / 2136);

      static constexpr int max_digits10 = 0;

      static constexpr bool is_signed = false;
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr unsigned int
      epsilon() noexcept { return 0; }

      static constexpr unsigned int
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm
       = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr unsigned int
      infinity() noexcept { return static_cast<unsigned int>(0); }

      static constexpr unsigned int
      quiet_NaN() noexcept
      { return static_cast<unsigned int>(0); }

      static constexpr unsigned int
      signaling_NaN() noexcept
      { return static_cast<unsigned int>(0); }

      static constexpr unsigned int
      denorm_min() noexcept
      { return static_cast<unsigned int>(0); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = true;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
       = round_toward_zero;
    };


  template<>
    struct numeric_limits<long>
    {
      static constexpr bool is_specialized = true;

      static constexpr long
      min() noexcept { return -9223372036854775807L - 1; }

      static constexpr long
      max() noexcept { return 9223372036854775807L; }


      static constexpr long
      lowest() noexcept { return min(); }


      static constexpr int digits = (sizeof(long) * 8 - ((long)(-1) < 0));
      static constexpr int digits10 = ((sizeof(long) * 8 - ((long)(-1) < 0)) * 643L / 2136);

      static constexpr int max_digits10 = 0;

      static constexpr bool is_signed = true;
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr long
      epsilon() noexcept { return 0; }

      static constexpr long
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm
       = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr long
      infinity() noexcept { return static_cast<long>(0); }

      static constexpr long
      quiet_NaN() noexcept { return static_cast<long>(0); }

      static constexpr long
      signaling_NaN() noexcept { return static_cast<long>(0); }

      static constexpr long
      denorm_min() noexcept { return static_cast<long>(0); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = false;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
       = round_toward_zero;
    };


  template<>
    struct numeric_limits<unsigned long>
    {
      static constexpr bool is_specialized = true;

      static constexpr unsigned long
      min() noexcept { return 0; }

      static constexpr unsigned long
      max() noexcept { return 9223372036854775807L * 2UL + 1; }


      static constexpr unsigned long
      lowest() noexcept { return min(); }


      static constexpr int digits
       = (sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0));
      static constexpr int digits10
       = ((sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0)) * 643L / 2136);

      static constexpr int max_digits10 = 0;

      static constexpr bool is_signed = false;
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr unsigned long
      epsilon() noexcept { return 0; }

      static constexpr unsigned long
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm
       = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr unsigned long
      infinity() noexcept
      { return static_cast<unsigned long>(0); }

      static constexpr unsigned long
      quiet_NaN() noexcept
      { return static_cast<unsigned long>(0); }

      static constexpr unsigned long
      signaling_NaN() noexcept
      { return static_cast<unsigned long>(0); }

      static constexpr unsigned long
      denorm_min() noexcept
      { return static_cast<unsigned long>(0); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = true;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
       = round_toward_zero;
    };


  template<>
    struct numeric_limits<long long>
    {
      static constexpr bool is_specialized = true;

      static constexpr long long
      min() noexcept { return -9223372036854775807LL - 1; }

      static constexpr long long
      max() noexcept { return 9223372036854775807LL; }


      static constexpr long long
      lowest() noexcept { return min(); }


      static constexpr int digits
       = (sizeof(long long) * 8 - ((long long)(-1) < 0));
      static constexpr int digits10
       = ((sizeof(long long) * 8 - ((long long)(-1) < 0)) * 643L / 2136);

      static constexpr int max_digits10 = 0;

      static constexpr bool is_signed = true;
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr long long
      epsilon() noexcept { return 0; }

      static constexpr long long
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm
       = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr long long
      infinity() noexcept { return static_cast<long long>(0); }

      static constexpr long long
      quiet_NaN() noexcept { return static_cast<long long>(0); }

      static constexpr long long
      signaling_NaN() noexcept
      { return static_cast<long long>(0); }

      static constexpr long long
      denorm_min() noexcept { return static_cast<long long>(0); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = false;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
       = round_toward_zero;
    };


  template<>
    struct numeric_limits<unsigned long long>
    {
      static constexpr bool is_specialized = true;

      static constexpr unsigned long long
      min() noexcept { return 0; }

      static constexpr unsigned long long
      max() noexcept { return 9223372036854775807LL * 2ULL + 1; }


      static constexpr unsigned long long
      lowest() noexcept { return min(); }


      static constexpr int digits
       = (sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0));
      static constexpr int digits10
       = ((sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0)) * 643L / 2136);

      static constexpr int max_digits10 = 0;

      static constexpr bool is_signed = false;
      static constexpr bool is_integer = true;
      static constexpr bool is_exact = true;
      static constexpr int radix = 2;

      static constexpr unsigned long long
      epsilon() noexcept { return 0; }

      static constexpr unsigned long long
      round_error() noexcept { return 0; }

      static constexpr int min_exponent = 0;
      static constexpr int min_exponent10 = 0;
      static constexpr int max_exponent = 0;
      static constexpr int max_exponent10 = 0;

      static constexpr bool has_infinity = false;
      static constexpr bool has_quiet_NaN = false;
      static constexpr bool has_signaling_NaN = false;
      static constexpr float_denorm_style has_denorm
       = denorm_absent;
      static constexpr bool has_denorm_loss = false;

      static constexpr unsigned long long
      infinity() noexcept
      { return static_cast<unsigned long long>(0); }

      static constexpr unsigned long long
      quiet_NaN() noexcept
      { return static_cast<unsigned long long>(0); }

      static constexpr unsigned long long
      signaling_NaN() noexcept
      { return static_cast<unsigned long long>(0); }

      static constexpr unsigned long long
      denorm_min() noexcept
      { return static_cast<unsigned long long>(0); }

      static constexpr bool is_iec559 = false;
      static constexpr bool is_bounded = true;
      static constexpr bool is_modulo = true;

      static constexpr bool traps = true;
      static constexpr bool tinyness_before = false;
      static constexpr float_round_style round_style
       = round_toward_zero;
    };
# 1637 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/limits" 3
  __extension__ 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; }; __extension__ template<> struct numeric_limits<unsigned __int128> { 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<unsigned __int128>(0); } static constexpr unsigned __int128 quiet_NaN() noexcept { return static_cast<unsigned __int128>(0); } static constexpr unsigned __int128 signaling_NaN() noexcept { return static_cast<unsigned __int128>(0); } static constexpr unsigned __int128 denorm_min() noexcept { return static_cast<unsigned __int128>(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; };
# 1669 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/limits" 3
  template<>
    struct numeric_limits<float>
    {
      static constexpr bool is_specialized = true;

      static constexpr float
      min() noexcept { return 1.17549435e-38F; }

      static constexpr float
      max() noexcept { return 3.40282347e+38F; }


      static constexpr float
      lowest() noexcept { return -3.40282347e+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.19209290e-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.40129846e-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<double>
    {
      static constexpr bool is_specialized = true;

      static constexpr double
      min() noexcept { return 2.2250738585072014e-308; }

      static constexpr double
      max() noexcept { return 1.7976931348623157e+308; }


      static constexpr double
      lowest() noexcept { return -1.7976931348623157e+308; }


      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 2.2204460492503131e-16; }

      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 4.9406564584124654e-324; }

      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<long double>
    {
      static constexpr bool is_specialized = true;

      static constexpr long double
      min() noexcept { return 3.36210314311209350626e-4932L; }

      static constexpr long double
      max() noexcept { return 1.18973149535723176502e+4932L; }


      static constexpr long double
      lowest() noexcept { return -1.18973149535723176502e+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.08420217248550443401e-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.64519953188247460253e-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;
    };
# 2087 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/limits" 3
  __extension__
  template<>
    struct numeric_limits<__float128>
    {
      static constexpr bool is_specialized = true;

      static constexpr __float128
      min() noexcept
      {




 return __extension__ 0x1.0p-16382Q;

      }

      static constexpr __float128
      max() noexcept
      {







 return __extension__ 0x1.ffffffffffffffffffffffffffffp+16383Q;

      }

      static constexpr __float128
      lowest() noexcept
      { return -max(); }

      static constexpr int digits = 113;
      static constexpr int digits10 = 33;

      static constexpr int max_digits10 = 35;

      static constexpr bool is_signed = true;
      static constexpr bool is_integer = false;
      static constexpr bool is_exact = false;
      static constexpr int radix = 2;

      static constexpr __float128
      epsilon() noexcept
      { return double(1.9259299443872359e-34); }

      static constexpr __float128
      round_error() noexcept { return 0.5; }

      static constexpr int min_exponent = -16381;
      static constexpr int min_exponent10 = -4931;
      static constexpr int max_exponent = 16384;
      static constexpr int max_exponent10 = 4932;

      static constexpr bool has_infinity = 1;
      static constexpr bool has_quiet_NaN = 1;


      static constexpr bool has_signaling_NaN = true;



      static constexpr float_denorm_style has_denorm
 = denorm_present;
      static constexpr bool has_denorm_loss = false;

      static constexpr __float128
      infinity() noexcept
      { return __builtin_huge_val(); }

      static constexpr __float128
      quiet_NaN() noexcept
      { return __builtin_nan(""); }

      static constexpr __float128
      signaling_NaN() noexcept
      {



 return __builtin_bit_cast(__float128, __builtin_nansf128(""));



      }

      static constexpr __float128
      denorm_min() noexcept
      {




 return __extension__ 0x1.0p-16494Q;

      }

      static constexpr bool is_iec559 = has_signaling_NaN;
      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;
# 2218 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/limits" 3
    };




}
# 47 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/format" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/locale" 1 3
# 37 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/locale" 3






# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 1 3
# 38 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ctime" 1 3
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ctime" 3
# 58 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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;
}
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{
# 52 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
  class time_base
  {
  public:
    enum dateorder { no_order, dmy, mdy, ymd, ydm };
  };

  template<typename _CharT>
    struct __timepunct_cache : public locale::facet
    {

      static const _CharT* _S_timezones[14];

      const _CharT* _M_date_format;
      const _CharT* _M_date_era_format;
      const _CharT* _M_time_format;
      const _CharT* _M_time_era_format;
      const _CharT* _M_date_time_format;
      const _CharT* _M_date_time_era_format;
      const _CharT* _M_am;
      const _CharT* _M_pm;
      const _CharT* _M_am_pm_format;


      const _CharT* _M_day1;
      const _CharT* _M_day2;
      const _CharT* _M_day3;
      const _CharT* _M_day4;
      const _CharT* _M_day5;
      const _CharT* _M_day6;
      const _CharT* _M_day7;


      const _CharT* _M_aday1;
      const _CharT* _M_aday2;
      const _CharT* _M_aday3;
      const _CharT* _M_aday4;
      const _CharT* _M_aday5;
      const _CharT* _M_aday6;
      const _CharT* _M_aday7;


      const _CharT* _M_month01;
      const _CharT* _M_month02;
      const _CharT* _M_month03;
      const _CharT* _M_month04;
      const _CharT* _M_month05;
      const _CharT* _M_month06;
      const _CharT* _M_month07;
      const _CharT* _M_month08;
      const _CharT* _M_month09;
      const _CharT* _M_month10;
      const _CharT* _M_month11;
      const _CharT* _M_month12;


      const _CharT* _M_amonth01;
      const _CharT* _M_amonth02;
      const _CharT* _M_amonth03;
      const _CharT* _M_amonth04;
      const _CharT* _M_amonth05;
      const _CharT* _M_amonth06;
      const _CharT* _M_amonth07;
      const _CharT* _M_amonth08;
      const _CharT* _M_amonth09;
      const _CharT* _M_amonth10;
      const _CharT* _M_amonth11;
      const _CharT* _M_amonth12;

      bool _M_allocated;

      __timepunct_cache(size_t __refs = 0) : facet(__refs),
      _M_date_format(0), _M_date_era_format(0), _M_time_format(0),
      _M_time_era_format(0), _M_date_time_format(0),
      _M_date_time_era_format(0), _M_am(0), _M_pm(0),
      _M_am_pm_format(0), _M_day1(0), _M_day2(0), _M_day3(0),
      _M_day4(0), _M_day5(0), _M_day6(0), _M_day7(0),
      _M_aday1(0), _M_aday2(0), _M_aday3(0), _M_aday4(0),
      _M_aday5(0), _M_aday6(0), _M_aday7(0), _M_month01(0),
      _M_month02(0), _M_month03(0), _M_month04(0), _M_month05(0),
      _M_month06(0), _M_month07(0), _M_month08(0), _M_month09(0),
      _M_month10(0), _M_month11(0), _M_month12(0), _M_amonth01(0),
      _M_amonth02(0), _M_amonth03(0), _M_amonth04(0),
      _M_amonth05(0), _M_amonth06(0), _M_amonth07(0),
      _M_amonth08(0), _M_amonth09(0), _M_amonth10(0),
      _M_amonth11(0), _M_amonth12(0), _M_allocated(false)
      { }

      ~__timepunct_cache();

    private:
      __timepunct_cache&
      operator=(const __timepunct_cache&);

      explicit
      __timepunct_cache(const __timepunct_cache&);
    };

  template<typename _CharT>
    __timepunct_cache<_CharT>::~__timepunct_cache()
    {
      if (_M_allocated)
 {

 }
    }


  template<>
    const char*
    __timepunct_cache<char>::_S_timezones[14];


  template<>
    const wchar_t*
    __timepunct_cache<wchar_t>::_S_timezones[14];



  template<typename _CharT>
    const _CharT* __timepunct_cache<_CharT>::_S_timezones[14];

  template<typename _CharT>
    class __timepunct : public locale::facet
    {
    public:

      typedef _CharT __char_type;
      typedef __timepunct_cache<_CharT> __cache_type;

    protected:
      __cache_type* _M_data;
      __c_locale _M_c_locale_timepunct;
      const char* _M_name_timepunct;

    public:

      static locale::id id;

      explicit
      __timepunct(size_t __refs = 0);

      explicit
      __timepunct(__cache_type* __cache, size_t __refs = 0);
# 206 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      explicit
      __timepunct(__c_locale __cloc, const char* __s, size_t __refs = 0);



      void
      _M_put(_CharT* __s, size_t __maxlen, const _CharT* __format,
      const tm* __tm) const throw ();

      void
      _M_date_formats(const _CharT** __date) const
      {

 __date[0] = _M_data->_M_date_format;
 __date[1] = _M_data->_M_date_era_format;
      }

      void
      _M_time_formats(const _CharT** __time) const
      {

 __time[0] = _M_data->_M_time_format;
 __time[1] = _M_data->_M_time_era_format;
      }

      void
      _M_date_time_formats(const _CharT** __dt) const
      {

 __dt[0] = _M_data->_M_date_time_format;
 __dt[1] = _M_data->_M_date_time_era_format;
      }


      void
      _M_am_pm_format(const _CharT*) const
      { }


      void
      _M_am_pm_format(const _CharT** __ampm_format) const
      {
 __ampm_format[0] = _M_data->_M_am_pm_format;
      }

      void
      _M_am_pm(const _CharT** __ampm) const
      {
 __ampm[0] = _M_data->_M_am;
 __ampm[1] = _M_data->_M_pm;
      }

      void
      _M_days(const _CharT** __days) const
      {
 __days[0] = _M_data->_M_day1;
 __days[1] = _M_data->_M_day2;
 __days[2] = _M_data->_M_day3;
 __days[3] = _M_data->_M_day4;
 __days[4] = _M_data->_M_day5;
 __days[5] = _M_data->_M_day6;
 __days[6] = _M_data->_M_day7;
      }

      void
      _M_days_abbreviated(const _CharT** __days) const
      {
 __days[0] = _M_data->_M_aday1;
 __days[1] = _M_data->_M_aday2;
 __days[2] = _M_data->_M_aday3;
 __days[3] = _M_data->_M_aday4;
 __days[4] = _M_data->_M_aday5;
 __days[5] = _M_data->_M_aday6;
 __days[6] = _M_data->_M_aday7;
      }

      void
      _M_months(const _CharT** __months) const
      {
 __months[0] = _M_data->_M_month01;
 __months[1] = _M_data->_M_month02;
 __months[2] = _M_data->_M_month03;
 __months[3] = _M_data->_M_month04;
 __months[4] = _M_data->_M_month05;
 __months[5] = _M_data->_M_month06;
 __months[6] = _M_data->_M_month07;
 __months[7] = _M_data->_M_month08;
 __months[8] = _M_data->_M_month09;
 __months[9] = _M_data->_M_month10;
 __months[10] = _M_data->_M_month11;
 __months[11] = _M_data->_M_month12;
      }

      void
      _M_months_abbreviated(const _CharT** __months) const
      {
 __months[0] = _M_data->_M_amonth01;
 __months[1] = _M_data->_M_amonth02;
 __months[2] = _M_data->_M_amonth03;
 __months[3] = _M_data->_M_amonth04;
 __months[4] = _M_data->_M_amonth05;
 __months[5] = _M_data->_M_amonth06;
 __months[6] = _M_data->_M_amonth07;
 __months[7] = _M_data->_M_amonth08;
 __months[8] = _M_data->_M_amonth09;
 __months[9] = _M_data->_M_amonth10;
 __months[10] = _M_data->_M_amonth11;
 __months[11] = _M_data->_M_amonth12;
      }

    protected:
      virtual
      ~__timepunct();


      void
      _M_initialize_timepunct(__c_locale __cloc = 0);
    };

  template<typename _CharT>
    locale::id __timepunct<_CharT>::id;


  template<>
    void
    __timepunct<char>::_M_initialize_timepunct(__c_locale __cloc);

  template<>
    void
    __timepunct<char>::_M_put(char*, size_t, const char*, const tm*) const throw ();


  template<>
    void
    __timepunct<wchar_t>::_M_initialize_timepunct(__c_locale __cloc);

  template<>
    void
    __timepunct<wchar_t>::_M_put(wchar_t*, size_t, const wchar_t*,
     const tm*) const throw ();



}


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/time_members.h" 1 3
# 37 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/time_members.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{


  template<typename _CharT>
    __timepunct<_CharT>::__timepunct(size_t __refs)
    : facet(__refs), _M_data(0), _M_c_locale_timepunct(0),
      _M_name_timepunct(_S_get_c_name())
    { _M_initialize_timepunct(); }

  template<typename _CharT>
    __timepunct<_CharT>::__timepunct(__cache_type* __cache, size_t __refs)
    : facet(__refs), _M_data(__cache), _M_c_locale_timepunct(0),
      _M_name_timepunct(_S_get_c_name())
    { _M_initialize_timepunct(); }

  template<typename _CharT>
    __timepunct<_CharT>::__timepunct(__c_locale __cloc, const char* __s,
         size_t __refs)
    : facet(__refs), _M_data(0), _M_c_locale_timepunct(0),
      _M_name_timepunct(0)
    {
      if (__builtin_strcmp(__s, _S_get_c_name()) != 0)
 {
   const size_t __len = __builtin_strlen(__s) + 1;
   char* __tmp = new char[__len];
   __builtin_memcpy(__tmp, __s, __len);
   _M_name_timepunct = __tmp;
 }
      else
 _M_name_timepunct = _S_get_c_name();

      try
 { _M_initialize_timepunct(__cloc); }
      catch(...)
 {
   if (_M_name_timepunct != _S_get_c_name())
     delete [] _M_name_timepunct;
   throw;
 }
    }

  template<typename _CharT>
    __timepunct<_CharT>::~__timepunct()
    {
      if (_M_name_timepunct != _S_get_c_name())
 delete [] _M_name_timepunct;
      delete _M_data;
      _S_destroy_c_locale(_M_c_locale_timepunct);
    }


}
# 353 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{


  struct __time_get_state
  {

    void
    _M_finalize_state(tm* __tm);

    unsigned int _M_have_I : 1;
    unsigned int _M_have_wday : 1;
    unsigned int _M_have_yday : 1;
    unsigned int _M_have_mon : 1;
    unsigned int _M_have_mday : 1;
    unsigned int _M_have_uweek : 1;
    unsigned int _M_have_wweek : 1;
    unsigned int _M_have_century : 1;
    unsigned int _M_is_pm : 1;
    unsigned int _M_want_century : 1;
    unsigned int _M_want_xday : 1;
    unsigned int _M_pad1 : 5;
    unsigned int _M_week_no : 6;
    unsigned int _M_pad2 : 10;
    int _M_century;
    int _M_pad3;
  };

namespace __cxx11 {
# 397 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
  template<typename _CharT, typename _InIter>
    class time_get : public locale::facet, public time_base
    {
    public:



      typedef _CharT char_type;
      typedef _InIter iter_type;



      static locale::id id;
# 418 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      explicit
      time_get(size_t __refs = 0)
      : facet (__refs) { }
# 435 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      dateorder
      date_order() const
      { return this->do_date_order(); }
# 459 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      iter_type
      get_time(iter_type __beg, iter_type __end, ios_base& __io,
        ios_base::iostate& __err, tm* __tm) const
      { return this->do_get_time(__beg, __end, __io, __err, __tm); }
# 484 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      iter_type
      get_date(iter_type __beg, iter_type __end, ios_base& __io,
        ios_base::iostate& __err, tm* __tm) const
      { return this->do_get_date(__beg, __end, __io, __err, __tm); }
# 512 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      iter_type
      get_weekday(iter_type __beg, iter_type __end, ios_base& __io,
    ios_base::iostate& __err, tm* __tm) const
      { return this->do_get_weekday(__beg, __end, __io, __err, __tm); }
# 541 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      iter_type
      get_monthname(iter_type __beg, iter_type __end, ios_base& __io,
      ios_base::iostate& __err, tm* __tm) const
      { return this->do_get_monthname(__beg, __end, __io, __err, __tm); }
# 567 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      iter_type
      get_year(iter_type __beg, iter_type __end, ios_base& __io,
        ios_base::iostate& __err, tm* __tm) const
      { return this->do_get_year(__beg, __end, __io, __err, __tm); }
# 588 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      inline
      iter_type get(iter_type __s, iter_type __end, ios_base& __io,
                    ios_base::iostate& __err, tm* __tm, char __format,
                    char __modifier = 0) const
      {
        return this->do_get(__s, __end, __io, __err, __tm, __format,
                            __modifier);
      }
# 615 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      iter_type get(iter_type __s, iter_type __end, ios_base& __io,
                    ios_base::iostate& __err, tm* __tm, const char_type* __fmt,
                    const char_type* __fmtend) const;


    protected:

      virtual
      ~time_get() { }
# 635 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      virtual dateorder
      do_date_order() const;
# 653 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      virtual iter_type
      do_get_time(iter_type __beg, iter_type __end, ios_base& __io,
    ios_base::iostate& __err, tm* __tm) const;
# 672 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      virtual iter_type
      do_get_date(iter_type __beg, iter_type __end, ios_base& __io,
    ios_base::iostate& __err, tm* __tm) const;
# 691 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      virtual iter_type
      do_get_weekday(iter_type __beg, iter_type __end, ios_base&,
       ios_base::iostate& __err, tm* __tm) const;
# 710 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      virtual iter_type
      do_get_monthname(iter_type __beg, iter_type __end, ios_base&,
         ios_base::iostate& __err, tm* __tm) const;
# 729 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      virtual iter_type
      do_get_year(iter_type __beg, iter_type __end, ios_base& __io,
    ios_base::iostate& __err, tm* __tm) const;
# 752 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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;



      iter_type
      _M_extract_via_format(iter_type __beg, iter_type __end, ios_base& __io,
       ios_base::iostate& __err, tm* __tm,
       const _CharT* __format,
       __time_get_state &__state) const;
    };

  template<typename _CharT, typename _InIter>
    locale::id time_get<_CharT, _InIter>::id;


  template<typename _CharT, typename _InIter>
    class time_get_byname : public time_get<_CharT, _InIter>
    {
    public:

      typedef _CharT char_type;
      typedef _InIter iter_type;

      explicit
      time_get_byname(const char*, size_t __refs = 0)
      : time_get<_CharT, _InIter>(__refs) { }


      explicit
      time_get_byname(const string& __s, size_t __refs = 0)
      : time_get_byname(__s.c_str(), __refs) { }


    protected:
      virtual
      ~time_get_byname() { }
    };

}
# 834 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
  template<typename _CharT, typename _OutIter>
    class time_put : public locale::facet
    {
    public:



      typedef _CharT char_type;
      typedef _OutIter iter_type;



      static locale::id id;
# 855 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      explicit
      time_put(size_t __refs = 0)
      : facet(__refs) { }
# 874 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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;
# 894 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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()
      { }
# 921 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      virtual iter_type
      do_put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
      char __format, char __mod) const;
    };

  template<typename _CharT, typename _OutIter>
    locale::id time_put<_CharT, _OutIter>::id;


  template<typename _CharT, typename _OutIter>
    class time_put_byname : public time_put<_CharT, _OutIter>
    {
    public:

      typedef _CharT char_type;
      typedef _OutIter iter_type;

      explicit
      time_put_byname(const char*, size_t __refs = 0)
      : time_put<_CharT, _OutIter>(__refs)
      { }


      explicit
      time_put_byname(const string& __s, size_t __refs = 0)
      : time_put_byname(__s.c_str(), __refs) { }


    protected:
      virtual
      ~time_put_byname() { }
    };
# 966 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
  class money_base
  {
  public:
    enum part { none, space, symbol, sign, value };
    struct pattern { char field[4]; };

    static const pattern _S_default_pattern;

    enum
    {
      _S_minus,
      _S_zero,
      _S_end = 11
    };



    static const char* _S_atoms;



    __attribute__ ((__const__)) static pattern
    _S_construct_pattern(char __precedes, char __space, char __posn) throw ();
  };

  template<typename _CharT, bool _Intl>
    struct __moneypunct_cache : public locale::facet
    {
      const char* _M_grouping;
      size_t _M_grouping_size;
      bool _M_use_grouping;
      _CharT _M_decimal_point;
      _CharT _M_thousands_sep;
      const _CharT* _M_curr_symbol;
      size_t _M_curr_symbol_size;
      const _CharT* _M_positive_sign;
      size_t _M_positive_sign_size;
      const _CharT* _M_negative_sign;
      size_t _M_negative_sign_size;
      int _M_frac_digits;
      money_base::pattern _M_pos_format;
      money_base::pattern _M_neg_format;




      _CharT _M_atoms[money_base::_S_end];

      bool _M_allocated;

      __moneypunct_cache(size_t __refs = 0) : facet(__refs),
      _M_grouping(0), _M_grouping_size(0), _M_use_grouping(false),
      _M_decimal_point(_CharT()), _M_thousands_sep(_CharT()),
      _M_curr_symbol(0), _M_curr_symbol_size(0),
      _M_positive_sign(0), _M_positive_sign_size(0),
      _M_negative_sign(0), _M_negative_sign_size(0),
      _M_frac_digits(0),
      _M_pos_format(money_base::pattern()),
      _M_neg_format(money_base::pattern()), _M_allocated(false)
      { }

      ~__moneypunct_cache();

      void
      _M_cache(const locale& __loc);

    private:
      __moneypunct_cache&
      operator=(const __moneypunct_cache&);

      explicit
      __moneypunct_cache(const __moneypunct_cache&);
    };

  template<typename _CharT, bool _Intl>
    __moneypunct_cache<_CharT, _Intl>::~__moneypunct_cache()
    {
      if (_M_allocated)
 {
   delete [] _M_grouping;
   delete [] _M_curr_symbol;
   delete [] _M_positive_sign;
   delete [] _M_negative_sign;
 }
    }

namespace __cxx11 {
# 1061 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
  template<typename _CharT, bool _Intl>
    class moneypunct : public locale::facet, public money_base
    {
    public:



      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;

      typedef __moneypunct_cache<_CharT, _Intl> __cache_type;

    private:
      __cache_type* _M_data;

    public:


      static const bool intl = _Intl;

      static locale::id id;
# 1090 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      explicit
      moneypunct(size_t __refs = 0)
      : facet(__refs), _M_data(0)
      { _M_initialize_moneypunct(); }
# 1103 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      explicit
      moneypunct(__cache_type* __cache, size_t __refs = 0)
      : facet(__refs), _M_data(__cache)
      { _M_initialize_moneypunct(); }
# 1118 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      explicit
      moneypunct(__c_locale __cloc, const char* __s, size_t __refs = 0)
      : facet(__refs), _M_data(0)
      { _M_initialize_moneypunct(__cloc, __s); }
# 1132 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      char_type
      decimal_point() const
      { return this->do_decimal_point(); }
# 1145 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      char_type
      thousands_sep() const
      { return this->do_thousands_sep(); }
# 1175 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      string
      grouping() const
      { return this->do_grouping(); }
# 1188 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      string_type
      curr_symbol() const
      { return this->do_curr_symbol(); }
# 1205 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      string_type
      positive_sign() const
      { return this->do_positive_sign(); }
# 1222 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      string_type
      negative_sign() const
      { return this->do_negative_sign(); }
# 1238 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      int
      frac_digits() const
      { return this->do_frac_digits(); }
# 1274 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      pattern
      pos_format() const
      { return this->do_pos_format(); }

      pattern
      neg_format() const
      { return this->do_neg_format(); }


    protected:

      virtual
      ~moneypunct();
# 1296 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      virtual char_type
      do_decimal_point() const
      { return _M_data->_M_decimal_point; }
# 1308 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      virtual char_type
      do_thousands_sep() const
      { return _M_data->_M_thousands_sep; }
# 1321 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      virtual string
      do_grouping() const
      { return _M_data->_M_grouping; }
# 1334 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      virtual string_type
      do_curr_symbol() const
      { return _M_data->_M_curr_symbol; }
# 1347 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      virtual string_type
      do_positive_sign() const
      { return _M_data->_M_positive_sign; }
# 1360 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      virtual string_type
      do_negative_sign() const
      { return _M_data->_M_negative_sign; }
# 1374 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      virtual int
      do_frac_digits() const
      { return _M_data->_M_frac_digits; }
# 1388 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      virtual pattern
      do_pos_format() const
      { return _M_data->_M_pos_format; }
# 1402 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      virtual pattern
      do_neg_format() const
      { return _M_data->_M_neg_format; }


       void
       _M_initialize_moneypunct(__c_locale __cloc = 0,
    const char* __name = 0);
    };

  template<typename _CharT, bool _Intl>
    locale::id moneypunct<_CharT, _Intl>::id;

  template<typename _CharT, bool _Intl>
    const bool moneypunct<_CharT, _Intl>::intl;

  template<>
    moneypunct<char, true>::~moneypunct();

  template<>
    moneypunct<char, false>::~moneypunct();

  template<>
    void
    moneypunct<char, true>::_M_initialize_moneypunct(__c_locale, const char*);

  template<>
    void
    moneypunct<char, false>::_M_initialize_moneypunct(__c_locale, const char*);


  template<>
    moneypunct<wchar_t, true>::~moneypunct();

  template<>
    moneypunct<wchar_t, false>::~moneypunct();

  template<>
    void
    moneypunct<wchar_t, true>::_M_initialize_moneypunct(__c_locale,
       const char*);

  template<>
    void
    moneypunct<wchar_t, false>::_M_initialize_moneypunct(__c_locale,
        const char*);



  template<typename _CharT, bool _Intl>
    class moneypunct_byname : public moneypunct<_CharT, _Intl>
    {
    public:
      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;

      static const bool intl = _Intl;

      explicit
      moneypunct_byname(const char* __s, size_t __refs = 0)
      : moneypunct<_CharT, _Intl>(__refs)
      {
 if (__builtin_strcmp(__s, "C") != 0
     && __builtin_strcmp(__s, "POSIX") != 0)
   {
     __c_locale __tmp;
     this->_S_create_c_locale(__tmp, __s);
     this->_M_initialize_moneypunct(__tmp);
     this->_S_destroy_c_locale(__tmp);
   }
      }


      explicit
      moneypunct_byname(const string& __s, size_t __refs = 0)
      : moneypunct_byname(__s.c_str(), __refs) { }


    protected:
      virtual
      ~moneypunct_byname() { }
    };

  template<typename _CharT, bool _Intl>
    const bool moneypunct_byname<_CharT, _Intl>::intl;

}

namespace __cxx11 {
# 1505 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
  template<typename _CharT, typename _InIter>
    class money_get : public locale::facet
    {
    public:



      typedef _CharT char_type;
      typedef _InIter iter_type;
      typedef basic_string<_CharT> string_type;



      static locale::id id;
# 1527 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      explicit
      money_get(size_t __refs = 0) : facet(__refs) { }
# 1557 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      iter_type
      get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
   ios_base::iostate& __err, long double& __units) const
      { return this->do_get(__s, __end, __intl, __io, __err, __units); }
# 1588 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      iter_type
      get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
   ios_base::iostate& __err, string_type& __digits) const
      { return this->do_get(__s, __end, __intl, __io, __err, __digits); }

    protected:

      virtual
      ~money_get() { }
# 1612 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      virtual iter_type
      do_get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
      ios_base::iostate& __err, long double& __units) const;
# 1624 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      virtual iter_type
      do_get(iter_type __s, iter_type __end, bool __intl, ios_base& __io,
      ios_base::iostate& __err, string_type& __digits) const;
# 1644 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      template<bool _Intl>
        iter_type
        _M_extract(iter_type __s, iter_type __end, ios_base& __io,
     ios_base::iostate& __err, string& __digits) const;
    };

  template<typename _CharT, typename _InIter>
    locale::id money_get<_CharT, _InIter>::id;
# 1666 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
  template<typename _CharT, typename _OutIter>
    class money_put : public locale::facet
    {
    public:


      typedef _CharT char_type;
      typedef _OutIter iter_type;
      typedef basic_string<_CharT> string_type;



      static locale::id id;
# 1687 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      explicit
      money_put(size_t __refs = 0) : facet(__refs) { }
# 1707 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      iter_type
      put(iter_type __s, bool __intl, ios_base& __io,
   char_type __fill, long double __units) const
      { return this->do_put(__s, __intl, __io, __fill, __units); }
# 1730 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      iter_type
      put(iter_type __s, bool __intl, ios_base& __io,
   char_type __fill, const string_type& __digits) const
      { return this->do_put(__s, __intl, __io, __fill, __digits); }

    protected:

      virtual
      ~money_put() { }
# 1765 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      virtual iter_type
      do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
      long double __units) const;
# 1789 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      virtual iter_type
      do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
      const string_type& __digits) const;
# 1809 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      template<bool _Intl>
        iter_type
        _M_insert(iter_type __s, ios_base& __io, char_type __fill,
    const string_type& __digits) const;
    };

  template<typename _CharT, typename _OutIter>
    locale::id money_put<_CharT, _OutIter>::id;

}





  struct messages_base
  {
    typedef int catalog;
  };

namespace __cxx11 {
# 1852 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
  template<typename _CharT>
    class messages : public locale::facet, public messages_base
    {
    public:



      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;


    protected:


      __c_locale _M_c_locale_messages;
      const char* _M_name_messages;

    public:

      static locale::id id;
# 1880 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      explicit
      messages(size_t __refs = 0);
# 1894 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      explicit
      messages(__c_locale __cloc, const char* __s, size_t __refs = 0);
# 1907 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      catalog
      open(const basic_string<char>& __s, const locale& __loc) const
      { return this->do_open(__s, __loc); }
# 1925 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      catalog
      open(const basic_string<char>&, const locale&, const char*) const;
# 1943 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      string_type
      get(catalog __c, int __set, int __msgid, const string_type& __s) const
      { return this->do_get(__c, __set, __msgid, __s); }
# 1954 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      void
      close(catalog __c) const
      { return this->do_close(__c); }

    protected:

      virtual
      ~messages();
# 1974 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      virtual catalog
      do_open(const basic_string<char>&, const locale&) const;
# 1993 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 3
      virtual string_type
      do_get(catalog, int, int, const string_type& __dfault) const;






      virtual void
      do_close(catalog) const;


      char*
      _M_convert_to_char(const string_type& __msg) const
      {

 return reinterpret_cast<char*>(const_cast<_CharT*>(__msg.c_str()));
      }


      string_type
      _M_convert_from_char(char*) const
      {

 return string_type();
      }
     };

  template<typename _CharT>
    locale::id messages<_CharT>::id;


  template<>
    string
    messages<char>::do_get(catalog, int, int, const string&) const;


  template<>
    wstring
    messages<wchar_t>::do_get(catalog, int, int, const wstring&) const;



   template<typename _CharT>
    class messages_byname : public messages<_CharT>
    {
    public:
      typedef _CharT char_type;
      typedef basic_string<_CharT> string_type;

      explicit
      messages_byname(const char* __s, size_t __refs = 0);


      explicit
      messages_byname(const string& __s, size_t __refs = 0)
      : messages_byname(__s.c_str(), __refs) { }


    protected:
      virtual
      ~messages_byname()
      { }
    };

}


}


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/messages_members.h" 1 3
# 36 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/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)
     noexcept (true) __attribute__ ((__format_arg__ (1)));



extern char *dgettext (const char *__domainname, const char *__msgid)
     noexcept (true) __attribute__ ((__format_arg__ (2)));
extern char *__dgettext (const char *__domainname, const char *__msgid)
     noexcept (true) __attribute__ ((__format_arg__ (2)));



extern char *dcgettext (const char *__domainname,
   const char *__msgid, int __category)
     noexcept (true) __attribute__ ((__format_arg__ (2)));
extern char *__dcgettext (const char *__domainname,
     const char *__msgid, int __category)
     noexcept (true) __attribute__ ((__format_arg__ (2)));




extern char *ngettext (const char *__msgid1, const char *__msgid2,
         unsigned long int __n)
     noexcept (true) __attribute__ ((__format_arg__ (1))) __attribute__ ((__format_arg__ (2)));



extern char *dngettext (const char *__domainname, const char *__msgid1,
   const char *__msgid2, unsigned long int __n)
     noexcept (true) __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)
     noexcept (true) __attribute__ ((__format_arg__ (2))) __attribute__ ((__format_arg__ (3)));





extern char *textdomain (const char *__domainname) noexcept (true);



extern char *bindtextdomain (const char *__domainname,
        const char *__dirname) noexcept (true);



extern char *bind_textdomain_codeset (const char *__domainname,
          const char *__codeset) noexcept (true);
# 121 "/usr/include/libintl.h" 3 4
}
# 37 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/messages_members.h" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{



  template<typename _CharT>
    messages<_CharT>::messages(size_t __refs)
    : facet(__refs), _M_c_locale_messages(_S_get_c_locale()),
      _M_name_messages(_S_get_c_name())
    { }

  template<typename _CharT>
    messages<_CharT>::messages(__c_locale __cloc, const char* __s,
          size_t __refs)
    : facet(__refs), _M_c_locale_messages(0), _M_name_messages(0)
    {
      if (__builtin_strcmp(__s, _S_get_c_name()) != 0)
 {
   const size_t __len = __builtin_strlen(__s) + 1;
   char* __tmp = new char[__len];
   __builtin_memcpy(__tmp, __s, __len);
   _M_name_messages = __tmp;
 }
      else
 _M_name_messages = _S_get_c_name();


      _M_c_locale_messages = _S_clone_c_locale(__cloc);
    }

  template<typename _CharT>
    typename messages<_CharT>::catalog
    messages<_CharT>::open(const basic_string<char>& __s, const locale& __loc,
      const char* __dir) const
    {
      bindtextdomain(__s.c_str(), __dir);
      return this->do_open(__s, __loc);
    }


  template<typename _CharT>
    messages<_CharT>::~messages()
    {
      if (_M_name_messages != _S_get_c_name())
 delete [] _M_name_messages;
      _S_destroy_c_locale(_M_c_locale_messages);
    }

  template<typename _CharT>
    typename messages<_CharT>::catalog
    messages<_CharT>::do_open(const basic_string<char>& __s,
         const locale&) const
    {


      textdomain(__s.c_str());
      return 0;
    }

  template<typename _CharT>
    void
    messages<_CharT>::do_close(catalog) const
    { }


  template<typename _CharT>
    messages_byname<_CharT>::messages_byname(const char* __s, size_t __refs)
    : messages<_CharT>(__refs)
    {
      if (this->_M_name_messages != locale::facet::_S_get_c_name())
 {
   delete [] this->_M_name_messages;
   if (__builtin_strcmp(__s, locale::facet::_S_get_c_name()) != 0)
     {
       const size_t __len = __builtin_strlen(__s) + 1;
       char* __tmp = new char[__len];
       __builtin_memcpy(__tmp, __s, __len);
       this->_M_name_messages = __tmp;
     }
   else
     this->_M_name_messages = locale::facet::_S_get_c_name();
 }

      if (__builtin_strcmp(__s, "C") != 0
   && __builtin_strcmp(__s, "POSIX") != 0)
 {
   this->_S_destroy_c_locale(this->_M_c_locale_messages);
   this->_S_create_c_locale(this->_M_c_locale_messages, __s);
 }
    }


  template<>
    typename messages<char>::catalog
    messages<char>::do_open(const basic_string<char>&,
       const locale&) const;

  template<>
    void
    messages<char>::do_close(catalog) const;


  template<>
    typename messages<wchar_t>::catalog
    messages<wchar_t>::do_open(const basic_string<char>&,
          const locale&) const;

  template<>
    void
    messages<wchar_t>::do_close(catalog) const;



}
# 2065 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 2 3


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/codecvt.h" 1 3
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/codecvt.h" 3




namespace std __attribute__ ((__visibility__ ("default")))
{



  class codecvt_base
  {
  public:
    enum result
    {
      ok,
      partial,
      error,
      noconv
    };
  };
# 70 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/codecvt.h" 3
  template<typename _InternT, typename _ExternT, typename _StateT>
    class __codecvt_abstract_base
    : public locale::facet, public codecvt_base
    {
    public:

      typedef codecvt_base::result result;
      typedef _InternT intern_type;
      typedef _ExternT extern_type;
      typedef _StateT state_type;
# 118 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/codecvt.h" 3
      result
      out(state_type& __state, const intern_type* __from,
   const intern_type* __from_end, const intern_type*& __from_next,
   extern_type* __to, extern_type* __to_end,
   extern_type*& __to_next) const
      {
 return this->do_out(__state, __from, __from_end, __from_next,
       __to, __to_end, __to_next);
      }
# 157 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/codecvt.h" 3
      result
      unshift(state_type& __state, extern_type* __to, extern_type* __to_end,
       extern_type*& __to_next) const
      { return this->do_unshift(__state, __to,__to_end,__to_next); }
# 198 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/codecvt.h" 3
      result
      in(state_type& __state, const extern_type* __from,
  const extern_type* __from_end, const extern_type*& __from_next,
  intern_type* __to, intern_type* __to_end,
  intern_type*& __to_next) const
      {
 return this->do_in(__state, __from, __from_end, __from_next,
      __to, __to_end, __to_next);
      }

      int
      encoding() const throw()
      { return this->do_encoding(); }

      bool
      always_noconv() const throw()
      { return this->do_always_noconv(); }

      int
      length(state_type& __state, const extern_type* __from,
      const extern_type* __end, size_t __max) const
      { return this->do_length(__state, __from, __end, __max); }

      int
      max_length() const throw()
      { return this->do_max_length(); }

    protected:
      explicit
      __codecvt_abstract_base(size_t __refs = 0) : locale::facet(__refs) { }

      virtual
      ~__codecvt_abstract_base() { }
# 239 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/codecvt.h" 3
      virtual result
      do_out(state_type& __state, const intern_type* __from,
      const intern_type* __from_end, const intern_type*& __from_next,
      extern_type* __to, extern_type* __to_end,
      extern_type*& __to_next) const = 0;

      virtual result
      do_unshift(state_type& __state, extern_type* __to,
   extern_type* __to_end, extern_type*& __to_next) const = 0;

      virtual result
      do_in(state_type& __state, const extern_type* __from,
     const extern_type* __from_end, const extern_type*& __from_next,
     intern_type* __to, intern_type* __to_end,
     intern_type*& __to_next) const = 0;

      virtual int
      do_encoding() const throw() = 0;

      virtual bool
      do_always_noconv() const throw() = 0;

      virtual int
      do_length(state_type&, const extern_type* __from,
  const extern_type* __end, size_t __max) const = 0;

      virtual int
      do_max_length() const throw() = 0;
    };
# 276 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/codecvt.h" 3
   template<typename _InternT, typename _ExternT, typename _StateT>
    class codecvt
    : public __codecvt_abstract_base<_InternT, _ExternT, _StateT>
    {
    public:

      typedef codecvt_base::result result;
      typedef _InternT intern_type;
      typedef _ExternT extern_type;
      typedef _StateT state_type;

    protected:
      __c_locale _M_c_locale_codecvt;

    public:
      static locale::id id;

      explicit
      codecvt(size_t __refs = 0)
      : __codecvt_abstract_base<_InternT, _ExternT, _StateT> (__refs),
 _M_c_locale_codecvt(0)
      { }

      explicit
      codecvt(__c_locale __cloc, size_t __refs = 0);

    protected:
      virtual
      ~codecvt() { }

      virtual result
      do_out(state_type& __state, const intern_type* __from,
      const intern_type* __from_end, const intern_type*& __from_next,
      extern_type* __to, extern_type* __to_end,
      extern_type*& __to_next) const;

      virtual result
      do_unshift(state_type& __state, extern_type* __to,
   extern_type* __to_end, extern_type*& __to_next) const;

      virtual result
      do_in(state_type& __state, const extern_type* __from,
     const extern_type* __from_end, const extern_type*& __from_next,
     intern_type* __to, intern_type* __to_end,
     intern_type*& __to_next) const;

      virtual int
      do_encoding() const throw();

      virtual bool
      do_always_noconv() const throw();

      virtual int
      do_length(state_type&, const extern_type* __from,
  const extern_type* __end, size_t __max) const;

      virtual int
      do_max_length() const throw();
    };

  template<typename _InternT, typename _ExternT, typename _StateT>
    locale::id codecvt<_InternT, _ExternT, _StateT>::id;


  template<>
    class codecvt<char, char, mbstate_t>
    : public __codecvt_abstract_base<char, char, mbstate_t>
    {
      friend class messages<char>;

    public:

      typedef char intern_type;
      typedef char extern_type;
      typedef mbstate_t state_type;

    protected:
      __c_locale _M_c_locale_codecvt;

    public:
      static locale::id id;

      explicit
      codecvt(size_t __refs = 0);

      explicit
      codecvt(__c_locale __cloc, size_t __refs = 0);

    protected:
      virtual
      ~codecvt();

      virtual result
      do_out(state_type& __state, const intern_type* __from,
      const intern_type* __from_end, const intern_type*& __from_next,
      extern_type* __to, extern_type* __to_end,
      extern_type*& __to_next) const;

      virtual result
      do_unshift(state_type& __state, extern_type* __to,
   extern_type* __to_end, extern_type*& __to_next) const;

      virtual result
      do_in(state_type& __state, const extern_type* __from,
     const extern_type* __from_end, const extern_type*& __from_next,
     intern_type* __to, intern_type* __to_end,
     intern_type*& __to_next) const;

      virtual int
      do_encoding() const throw();

      virtual bool
      do_always_noconv() const throw();

      virtual int
      do_length(state_type&, const extern_type* __from,
  const extern_type* __end, size_t __max) const;

      virtual int
      do_max_length() const throw();
  };






  template<>
    class codecvt<wchar_t, char, mbstate_t>
    : public __codecvt_abstract_base<wchar_t, char, mbstate_t>
    {
      friend class messages<wchar_t>;

    public:

      typedef wchar_t intern_type;
      typedef char extern_type;
      typedef mbstate_t state_type;

    protected:
      __c_locale _M_c_locale_codecvt;

    public:
      static locale::id id;

      explicit
      codecvt(size_t __refs = 0);

      explicit
      codecvt(__c_locale __cloc, size_t __refs = 0);

    protected:
      virtual
      ~codecvt();

      virtual result
      do_out(state_type& __state, const intern_type* __from,
      const intern_type* __from_end, const intern_type*& __from_next,
      extern_type* __to, extern_type* __to_end,
      extern_type*& __to_next) const;

      virtual result
      do_unshift(state_type& __state,
   extern_type* __to, extern_type* __to_end,
   extern_type*& __to_next) const;

      virtual result
      do_in(state_type& __state,
      const extern_type* __from, const extern_type* __from_end,
      const extern_type*& __from_next,
      intern_type* __to, intern_type* __to_end,
      intern_type*& __to_next) const;

      virtual
      int do_encoding() const throw();

      virtual
      bool do_always_noconv() const throw();

      virtual
      int do_length(state_type&, const extern_type* __from,
      const extern_type* __end, size_t __max) const;

      virtual int
      do_max_length() const throw();
    };







  template<>
    class codecvt<char16_t, char, mbstate_t>
    : public __codecvt_abstract_base<char16_t, char, mbstate_t>
    {
    public:

      typedef char16_t intern_type;
      typedef char extern_type;
      typedef mbstate_t state_type;

    public:
      static locale::id id;

      explicit
      codecvt(size_t __refs = 0)
      : __codecvt_abstract_base<char16_t, char, mbstate_t>(__refs) { }

    protected:
      virtual
      ~codecvt();

      virtual result
      do_out(state_type& __state, const intern_type* __from,
      const intern_type* __from_end, const intern_type*& __from_next,
      extern_type* __to, extern_type* __to_end,
      extern_type*& __to_next) const;

      virtual result
      do_unshift(state_type& __state,
   extern_type* __to, extern_type* __to_end,
   extern_type*& __to_next) const;

      virtual result
      do_in(state_type& __state,
      const extern_type* __from, const extern_type* __from_end,
      const extern_type*& __from_next,
      intern_type* __to, intern_type* __to_end,
      intern_type*& __to_next) const;

      virtual
      int do_encoding() const throw();

      virtual
      bool do_always_noconv() const throw();

      virtual
      int do_length(state_type&, const extern_type* __from,
      const extern_type* __end, size_t __max) const;

      virtual int
      do_max_length() const throw();
    };





  template<>
    class codecvt<char32_t, char, mbstate_t>
    : public __codecvt_abstract_base<char32_t, char, mbstate_t>
    {
    public:

      typedef char32_t intern_type;
      typedef char extern_type;
      typedef mbstate_t state_type;

    public:
      static locale::id id;

      explicit
      codecvt(size_t __refs = 0)
      : __codecvt_abstract_base<char32_t, char, mbstate_t>(__refs) { }

    protected:
      virtual
      ~codecvt();

      virtual result
      do_out(state_type& __state, const intern_type* __from,
      const intern_type* __from_end, const intern_type*& __from_next,
      extern_type* __to, extern_type* __to_end,
      extern_type*& __to_next) const;

      virtual result
      do_unshift(state_type& __state,
   extern_type* __to, extern_type* __to_end,
   extern_type*& __to_next) const;

      virtual result
      do_in(state_type& __state,
      const extern_type* __from, const extern_type* __from_end,
      const extern_type*& __from_next,
      intern_type* __to, intern_type* __to_end,
      intern_type*& __to_next) const;

      virtual
      int do_encoding() const throw();

      virtual
      bool do_always_noconv() const throw();

      virtual
      int do_length(state_type&, const extern_type* __from,
      const extern_type* __end, size_t __max) const;

      virtual int
      do_max_length() const throw();
    };






  template<>
    class codecvt<char16_t, char8_t, mbstate_t>
    : public __codecvt_abstract_base<char16_t, char8_t, mbstate_t>
    {
    public:

      typedef char16_t intern_type;
      typedef char8_t extern_type;
      typedef mbstate_t state_type;

    public:
      static locale::id id;

      explicit
      codecvt(size_t __refs = 0)
      : __codecvt_abstract_base<char16_t, char8_t, mbstate_t>(__refs) { }

    protected:
      virtual
      ~codecvt();

      virtual result
      do_out(state_type& __state, const intern_type* __from,
      const intern_type* __from_end, const intern_type*& __from_next,
      extern_type* __to, extern_type* __to_end,
      extern_type*& __to_next) const;

      virtual result
      do_unshift(state_type& __state,
   extern_type* __to, extern_type* __to_end,
   extern_type*& __to_next) const;

      virtual result
      do_in(state_type& __state,
      const extern_type* __from, const extern_type* __from_end,
      const extern_type*& __from_next,
      intern_type* __to, intern_type* __to_end,
      intern_type*& __to_next) const;

      virtual
      int do_encoding() const throw();

      virtual
      bool do_always_noconv() const throw();

      virtual
      int do_length(state_type&, const extern_type* __from,
      const extern_type* __end, size_t __max) const;

      virtual int
      do_max_length() const throw();
    };





  template<>
    class codecvt<char32_t, char8_t, mbstate_t>
    : public __codecvt_abstract_base<char32_t, char8_t, mbstate_t>
    {
    public:

      typedef char32_t intern_type;
      typedef char8_t extern_type;
      typedef mbstate_t state_type;

    public:
      static locale::id id;

      explicit
      codecvt(size_t __refs = 0)
      : __codecvt_abstract_base<char32_t, char8_t, mbstate_t>(__refs) { }

    protected:
      virtual
      ~codecvt();

      virtual result
      do_out(state_type& __state, const intern_type* __from,
      const intern_type* __from_end, const intern_type*& __from_next,
      extern_type* __to, extern_type* __to_end,
      extern_type*& __to_next) const;

      virtual result
      do_unshift(state_type& __state,
   extern_type* __to, extern_type* __to_end,
   extern_type*& __to_next) const;

      virtual result
      do_in(state_type& __state,
      const extern_type* __from, const extern_type* __from_end,
      const extern_type*& __from_next,
      intern_type* __to, intern_type* __to_end,
      intern_type*& __to_next) const;

      virtual
      int do_encoding() const throw();

      virtual
      bool do_always_noconv() const throw();

      virtual
      int do_length(state_type&, const extern_type* __from,
      const extern_type* __end, size_t __max) const;

      virtual int
      do_max_length() const throw();
    };





  template<typename _InternT, typename _ExternT, typename _StateT>
    class codecvt_byname : public codecvt<_InternT, _ExternT, _StateT>
    {
    public:
      explicit
      codecvt_byname(const char* __s, size_t __refs = 0)
      : codecvt<_InternT, _ExternT, _StateT>(__refs)
      {
 if (__builtin_strcmp(__s, "C") != 0
     && __builtin_strcmp(__s, "POSIX") != 0)
   {
     this->_S_destroy_c_locale(this->_M_c_locale_codecvt);
     this->_S_create_c_locale(this->_M_c_locale_codecvt, __s);
   }
      }


      explicit
      codecvt_byname(const string& __s, size_t __refs = 0)
      : codecvt_byname(__s.c_str(), __refs) { }


    protected:
      virtual
      ~codecvt_byname() { }
    };


  template<>
    class codecvt_byname<char16_t, char, mbstate_t>
    : public codecvt<char16_t, char, mbstate_t>
    {
    public:
      explicit
      codecvt_byname(const char*, size_t __refs = 0)
      : codecvt<char16_t, char, mbstate_t>(__refs) { }

      explicit
      codecvt_byname(const string& __s, size_t __refs = 0)
      : codecvt_byname(__s.c_str(), __refs) { }

    protected:
      virtual
      ~codecvt_byname() { }
    };

  template<>
    class codecvt_byname<char32_t, char, mbstate_t>
    : public codecvt<char32_t, char, mbstate_t>
    {
    public:
      explicit
      codecvt_byname(const char*, size_t __refs = 0)
      : codecvt<char32_t, char, mbstate_t>(__refs) { }

      explicit
      codecvt_byname(const string& __s, size_t __refs = 0)
      : codecvt_byname(__s.c_str(), __refs) { }

    protected:
      virtual
      ~codecvt_byname() { }
    };


  template<>
    class codecvt_byname<char16_t, char8_t, mbstate_t>
    : public codecvt<char16_t, char8_t, mbstate_t>
    {
    public:
      explicit
      codecvt_byname(const char*, size_t __refs = 0)
      : codecvt<char16_t, char8_t, mbstate_t>(__refs) { }

      explicit
      codecvt_byname(const string& __s, size_t __refs = 0)
      : codecvt_byname(__s.c_str(), __refs) { }

    protected:
      virtual
      ~codecvt_byname() { }
    };

  template<>
    class codecvt_byname<char32_t, char8_t, mbstate_t>
    : public codecvt<char32_t, char8_t, mbstate_t>
    {
    public:
      explicit
      codecvt_byname(const char*, size_t __refs = 0)
      : codecvt<char32_t, char8_t, mbstate_t>(__refs) { }

      explicit
      codecvt_byname(const string& __s, size_t __refs = 0)
      : codecvt_byname(__s.c_str(), __refs) { }

    protected:
      virtual
      ~codecvt_byname() { }
    };







  extern template class codecvt_byname<char, char, mbstate_t>;

  extern template
    const codecvt<char, char, mbstate_t>&
    use_facet<codecvt<char, char, mbstate_t> >(const locale&);

  extern template
    bool
    has_facet<codecvt<char, char, mbstate_t> >(const locale&);


  extern template class codecvt_byname<wchar_t, char, mbstate_t>;

  extern template
    const codecvt<wchar_t, char, mbstate_t>&
    use_facet<codecvt<wchar_t, char, mbstate_t> >(const locale&);

  extern template
    bool
    has_facet<codecvt<wchar_t, char, mbstate_t> >(const locale&);



  extern template class codecvt_byname<char16_t, char, mbstate_t>;
  extern template class codecvt_byname<char32_t, char, mbstate_t>;


  extern template class codecvt_byname<char16_t, char8_t, mbstate_t>;
  extern template class codecvt_byname<char32_t, char8_t, mbstate_t>;







}
# 2068 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 2 3

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.tcc" 1 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.tcc" 3

namespace std __attribute__ ((__visibility__ ("default")))
{


  template<typename _CharT, bool _Intl>
    struct __use_cache<__moneypunct_cache<_CharT, _Intl> >
    {
      const __moneypunct_cache<_CharT, _Intl>*
      operator() (const locale& __loc) const
      {
 const size_t __i = moneypunct<_CharT, _Intl>::id._M_id();
 const locale::facet** __caches = __loc._M_impl->_M_caches;
 if (!__caches[__i])
   {
     __moneypunct_cache<_CharT, _Intl>* __tmp = 0;
     try
       {
  __tmp = new __moneypunct_cache<_CharT, _Intl>;
  __tmp->_M_cache(__loc);
       }
     catch(...)
       {
  delete __tmp;
  throw;
       }
     __loc._M_impl->_M_install_cache(__tmp, __i);
   }
 return static_cast<
   const __moneypunct_cache<_CharT, _Intl>*>(__caches[__i]);
      }
    };

  template<typename _CharT, bool _Intl>
    void
    __moneypunct_cache<_CharT, _Intl>::_M_cache(const locale& __loc)
    {
      const moneypunct<_CharT, _Intl>& __mp =
 use_facet<moneypunct<_CharT, _Intl> >(__loc);

      struct _Scoped_str
      {
 size_t _M_len;
 _CharT* _M_str;

 explicit
 _Scoped_str(const basic_string<_CharT>& __str)
 : _M_len(__str.size()), _M_str(new _CharT[_M_len])
 { __str.copy(_M_str, _M_len); }

 ~_Scoped_str() { delete[] _M_str; }

 void
 _M_release(const _CharT*& __p, size_t& __n)
 {
   __p = _M_str;
   __n = _M_len;
   _M_str = 0;
 }
      };

      _Scoped_str __curr_symbol(__mp.curr_symbol());
      _Scoped_str __positive_sign(__mp.positive_sign());
      _Scoped_str __negative_sign(__mp.negative_sign());

      const string& __g = __mp.grouping();
      const size_t __g_size = __g.size();
      char* const __grouping = new char[__g_size];
      __g.copy(__grouping, __g_size);



      _M_grouping = __grouping;
      _M_grouping_size = __g_size;
      _M_use_grouping = (__g_size
    && static_cast<signed char>(__grouping[0]) > 0
    && (__grouping[0]
        != __gnu_cxx::__numeric_traits<char>::__max));

      _M_decimal_point = __mp.decimal_point();
      _M_thousands_sep = __mp.thousands_sep();

      __curr_symbol._M_release(_M_curr_symbol, _M_curr_symbol_size);
      __positive_sign._M_release(_M_positive_sign, _M_positive_sign_size);
      __negative_sign._M_release(_M_negative_sign, _M_negative_sign_size);

      _M_frac_digits = __mp.frac_digits();
      _M_pos_format = __mp.pos_format();
      _M_neg_format = __mp.neg_format();

      const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc);
      __ct.widen(money_base::_S_atoms,
   money_base::_S_atoms + money_base::_S_end, _M_atoms);

      _M_allocated = true;
    }

namespace __cxx11 {

  template<typename _CharT, typename _InIter>
    template<bool _Intl>
      _InIter
      money_get<_CharT, _InIter>::
      _M_extract(iter_type __beg, iter_type __end, ios_base& __io,
   ios_base::iostate& __err, string& __units) const
      {
 typedef char_traits<_CharT> __traits_type;
 typedef typename string_type::size_type size_type;
 typedef money_base::part part;
 typedef __moneypunct_cache<_CharT, _Intl> __cache_type;

 const locale& __loc = __io._M_getloc();
 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

 __use_cache<__cache_type> __uc;
 const __cache_type* __lc = __uc(__loc);
 const char_type* __lit = __lc->_M_atoms;


 bool __negative = false;

 size_type __sign_size = 0;

 const bool __mandatory_sign = (__lc->_M_positive_sign_size
           && __lc->_M_negative_sign_size);

 string __grouping_tmp;
 if (__lc->_M_use_grouping)
   __grouping_tmp.reserve(32);

 int __last_pos = 0;

 int __n = 0;

 bool __testvalid = true;

 bool __testdecfound = false;


 string __res;
 __res.reserve(32);

 const char_type* __lit_zero = __lit + money_base::_S_zero;
 const money_base::pattern __p = __lc->_M_neg_format;
 for (int __i = 0; __i < 4 && __testvalid; ++__i)
   {
     const part __which = static_cast<part>(__p.field[__i]);
     switch (__which)
       {
       case money_base::symbol:




  if (__io.flags() & ios_base::showbase || __sign_size > 1
      || __i == 0
      || (__i == 1 && (__mandatory_sign
         || (static_cast<part>(__p.field[0])
      == money_base::sign)
         || (static_cast<part>(__p.field[2])
      == money_base::space)))
      || (__i == 2 && ((static_cast<part>(__p.field[3])
          == money_base::value)
         || (__mandatory_sign
      && (static_cast<part>(__p.field[3])
          == money_base::sign)))))
    {
      const size_type __len = __lc->_M_curr_symbol_size;
      size_type __j = 0;
      for (; __beg != __end && __j < __len
      && *__beg == __lc->_M_curr_symbol[__j];
    ++__beg, (void)++__j);
      if (__j != __len
   && (__j || __io.flags() & ios_base::showbase))
        __testvalid = false;
    }
  break;
       case money_base::sign:

  if (__lc->_M_positive_sign_size && __beg != __end
      && *__beg == __lc->_M_positive_sign[0])
    {
      __sign_size = __lc->_M_positive_sign_size;
      ++__beg;
    }
  else if (__lc->_M_negative_sign_size && __beg != __end
    && *__beg == __lc->_M_negative_sign[0])
    {
      __negative = true;
      __sign_size = __lc->_M_negative_sign_size;
      ++__beg;
    }
  else if (__lc->_M_positive_sign_size
    && !__lc->_M_negative_sign_size)


    __negative = true;
  else if (__mandatory_sign)
    __testvalid = false;
  break;
       case money_base::value:


  for (; __beg != __end; ++__beg)
    {
      const char_type __c = *__beg;
      const char_type* __q = __traits_type::find(__lit_zero,
              10, __c);
      if (__q != 0)
        {
   __res += money_base::_S_atoms[__q - __lit];
   ++__n;
        }
      else if (__c == __lc->_M_decimal_point
        && !__testdecfound)
        {
   if (__lc->_M_frac_digits <= 0)
     break;

   __last_pos = __n;
   __n = 0;
   __testdecfound = true;
        }
      else if (__lc->_M_use_grouping
        && __c == __lc->_M_thousands_sep
        && !__testdecfound)
        {
   if (__n)
     {

       __grouping_tmp += static_cast<char>(__n);
       __n = 0;
     }
   else
     {
       __testvalid = false;
       break;
     }
        }
      else
        break;
    }
  if (__res.empty())
    __testvalid = false;
  break;
       case money_base::space:

  if (__beg != __end && __ctype.is(ctype_base::space, *__beg))
    ++__beg;
  else
    __testvalid = false;

       case money_base::none:

  if (__i != 3)
    for (; __beg != __end
    && __ctype.is(ctype_base::space, *__beg); ++__beg);
  break;
       }
   }


 if (__sign_size > 1 && __testvalid)
   {
     const char_type* __sign = __negative ? __lc->_M_negative_sign
                                          : __lc->_M_positive_sign;
     size_type __i = 1;
     for (; __beg != __end && __i < __sign_size
     && *__beg == __sign[__i]; ++__beg, (void)++__i);

     if (__i != __sign_size)
       __testvalid = false;
   }

 if (__testvalid)
   {

     if (__res.size() > 1)
       {
  const size_type __first = __res.find_first_not_of('0');
  const bool __only_zeros = __first == string::npos;
  if (__first)
    __res.erase(0, __only_zeros ? __res.size() - 1 : __first);
       }


     if (__negative && __res[0] != '0')
       __res.insert(__res.begin(), '-');


     if (__grouping_tmp.size())
       {

  __grouping_tmp += static_cast<char>(__testdecfound ? __last_pos
                         : __n);
  if (!std::__verify_grouping(__lc->_M_grouping,
         __lc->_M_grouping_size,
         __grouping_tmp))
    __err |= ios_base::failbit;
       }


     if (__testdecfound && __n != __lc->_M_frac_digits)
       __testvalid = false;
   }


 if (!__testvalid)
   __err |= ios_base::failbit;
 else
   __units.swap(__res);


 if (__beg == __end)
   __err |= ios_base::eofbit;
 return __beg;
      }
# 368 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.tcc" 3
  template<typename _CharT, typename _InIter>
    _InIter
    money_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
    ios_base::iostate& __err, long double& __units) const
    {
      string __str;
      __beg = __intl ? _M_extract<true>(__beg, __end, __io, __err, __str)
              : _M_extract<false>(__beg, __end, __io, __err, __str);
      std::__convert_to_v(__str.c_str(), __units, __err, _S_get_c_locale());
      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    money_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, bool __intl, ios_base& __io,
    ios_base::iostate& __err, string_type& __digits) const
    {
      typedef typename string::size_type size_type;

      const locale& __loc = __io._M_getloc();
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

      string __str;
      __beg = __intl ? _M_extract<true>(__beg, __end, __io, __err, __str)
              : _M_extract<false>(__beg, __end, __io, __err, __str);
      const size_type __len = __str.size();
      if (__len)
 {
   __digits.resize(__len);
   __ctype.widen(__str.data(), __str.data() + __len, &__digits[0]);
 }
      return __beg;
    }
# 420 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.tcc" 3
  template<typename _CharT, typename _OutIter>
    template<bool _Intl>
      _OutIter
      money_put<_CharT, _OutIter>::
      _M_insert(iter_type __s, ios_base& __io, char_type __fill,
  const string_type& __digits) const
      {
 typedef typename string_type::size_type size_type;
 typedef money_base::part part;
 typedef __moneypunct_cache<_CharT, _Intl> __cache_type;

 const locale& __loc = __io._M_getloc();
 const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

 __use_cache<__cache_type> __uc;
 const __cache_type* __lc = __uc(__loc);
 const char_type* __lit = __lc->_M_atoms;



 const char_type* __beg = __digits.data();

 money_base::pattern __p;
 const char_type* __sign;
 size_type __sign_size;
 if (!(*__beg == __lit[money_base::_S_minus]))
   {
     __p = __lc->_M_pos_format;
     __sign = __lc->_M_positive_sign;
     __sign_size = __lc->_M_positive_sign_size;
   }
 else
   {
     __p = __lc->_M_neg_format;
     __sign = __lc->_M_negative_sign;
     __sign_size = __lc->_M_negative_sign_size;
     if (__digits.size())
       ++__beg;
   }


 size_type __len = __ctype.scan_not(ctype_base::digit, __beg,
        __beg + __digits.size()) - __beg;
 if (__len)
   {



     string_type __value;
     __value.reserve(2 * __len);



     long __paddec = __len - __lc->_M_frac_digits;
     if (__paddec > 0)
       {
  if (__lc->_M_frac_digits < 0)
    __paddec = __len;
  if (__lc->_M_grouping_size)
    {
      __value.assign(2 * __paddec, char_type());
      _CharT* __vend =
        std::__add_grouping(&__value[0], __lc->_M_thousands_sep,
       __lc->_M_grouping,
       __lc->_M_grouping_size,
       __beg, __beg + __paddec);
      __value.erase(__vend - &__value[0]);
    }
  else
    __value.assign(__beg, __paddec);
       }


     if (__lc->_M_frac_digits > 0)
       {
  __value += __lc->_M_decimal_point;
  if (__paddec >= 0)
    __value.append(__beg + __paddec, __lc->_M_frac_digits);
  else
    {

      __value.append(-__paddec, __lit[money_base::_S_zero]);
      __value.append(__beg, __len);
    }
       }


     const ios_base::fmtflags __f = __io.flags()
                                    & ios_base::adjustfield;
     __len = __value.size() + __sign_size;
     __len += ((__io.flags() & ios_base::showbase)
        ? __lc->_M_curr_symbol_size : 0);

     string_type __res;
     __res.reserve(2 * __len);

     const size_type __width = static_cast<size_type>(__io.width());
     const bool __testipad = (__f == ios_base::internal
         && __len < __width);

     for (int __i = 0; __i < 4; ++__i)
       {
  const part __which = static_cast<part>(__p.field[__i]);
  switch (__which)
    {
    case money_base::symbol:
      if (__io.flags() & ios_base::showbase)
        __res.append(__lc->_M_curr_symbol,
       __lc->_M_curr_symbol_size);
      break;
    case money_base::sign:



      if (__sign_size)
        __res += __sign[0];
      break;
    case money_base::value:
      __res += __value;
      break;
    case money_base::space:



      if (__testipad)
        __res.append(__width - __len, __fill);
      else
        __res += __fill;
      break;
    case money_base::none:
      if (__testipad)
        __res.append(__width - __len, __fill);
      break;
    }
       }


     if (__sign_size > 1)
       __res.append(__sign + 1, __sign_size - 1);


     __len = __res.size();
     if (__width > __len)
       {
  if (__f == ios_base::left)

    __res.append(__width - __len, __fill);
  else

    __res.insert(0, __width - __len, __fill);
  __len = __width;
       }


     __s = std::__write(__s, __res.data(), __len);
   }
 __io.width(0);
 return __s;
      }
# 590 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.tcc" 3
  template<typename _CharT, typename _OutIter>
    _OutIter
    money_put<_CharT, _OutIter>::
    do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
    long double __units) const
    {
      const locale __loc = __io.getloc();
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);


      int __cs_size = 64;
      char* __cs = static_cast<char*>(__builtin_alloca(__cs_size));


      int __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
     "%.*Lf", 0, __units);

      if (__len >= __cs_size)
 {
   __cs_size = __len + 1;
   __cs = static_cast<char*>(__builtin_alloca(__cs_size));
   __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size,
     "%.*Lf", 0, __units);
 }
# 622 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.tcc" 3
      string_type __digits(__len, char_type());
      __ctype.widen(__cs, __cs + __len, &__digits[0]);
      return __intl ? _M_insert<true>(__s, __io, __fill, __digits)
             : _M_insert<false>(__s, __io, __fill, __digits);
    }

  template<typename _CharT, typename _OutIter>
    _OutIter
    money_put<_CharT, _OutIter>::
    do_put(iter_type __s, bool __intl, ios_base& __io, char_type __fill,
    const string_type& __digits) const
    { return __intl ? _M_insert<true>(__s, __io, __fill, __digits)
             : _M_insert<false>(__s, __io, __fill, __digits); }
# 674 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.tcc" 3
}




  template<typename _CharT, typename _InIter>
    time_base::dateorder
    time_get<_CharT, _InIter>::do_date_order() const
    { return time_base::no_order; }



  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    _M_extract_via_format(iter_type __beg, iter_type __end, ios_base& __io,
     ios_base::iostate& __err, tm* __tm,
     const _CharT* __format,
     __time_get_state &__state) const
    {
      const locale& __loc = __io._M_getloc();
      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);
      const size_t __len = char_traits<_CharT>::length(__format);

      ios_base::iostate __tmperr = ios_base::goodbit;
      size_t __i = 0;
      for (; __beg != __end && __i < __len && !__tmperr; ++__i)
 {
   if (__ctype.narrow(__format[__i], 0) == '%')
     {

       char __c = __ctype.narrow(__format[++__i], 0);
       int __mem = 0;
       if (__c == 'E' || __c == 'O')
  __c = __ctype.narrow(__format[++__i], 0);
       switch (__c)
  {
    const char* __cs;
    _CharT __wcs[10];
  case 'a':
  case 'A':

    const char_type* __days[14];
    __tp._M_days(&__days[0]);
    __tp._M_days_abbreviated(&__days[7]);
    __beg = _M_extract_name(__beg, __end, __mem, __days,
       14, __io, __tmperr);
    if (!__tmperr)
      {
        __tm->tm_wday = __mem % 7;
        __state._M_have_wday = 1;
      }
    break;
  case 'h':
  case 'b':
  case 'B':

    const char_type* __months[24];
    __tp._M_months(&__months[0]);
    __tp._M_months_abbreviated(&__months[12]);
    __beg = _M_extract_name(__beg, __end, __mem,
       __months, 24, __io, __tmperr);
    if (!__tmperr)
      {
        __tm->tm_mon = __mem % 12;
        __state._M_have_mon = 1;
        __state._M_want_xday = 1;
      }
    break;
  case 'c':

    const char_type* __dt[2];
    __tp._M_date_time_formats(__dt);
    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
      __tm, __dt[0], __state);
    if (!__tmperr)
      __state._M_want_xday = 1;
    break;
  case 'C':

    __beg = _M_extract_num(__beg, __end, __mem, 0, 99, 2,
      __io, __tmperr);
    if (!__tmperr)
      {
        __state._M_century = __mem;
        __state._M_have_century = 1;
        __state._M_want_xday = 1;
      }
    break;
  case 'd':
  case 'e':

    if (__ctype.is(ctype_base::space, *__beg))
      ++__beg;
    __beg = _M_extract_num(__beg, __end, __mem, 1, 31, 2,
      __io, __tmperr);
    if (!__tmperr)
      {
        __tm->tm_mday = __mem;
        __state._M_have_mday = 1;
        __state._M_want_xday = 1;
      }
    break;
  case 'D':

    __cs = "%m/%d/%y";
    __ctype.widen(__cs, __cs + 9, __wcs);
    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
      __tm, __wcs, __state);
    if (!__tmperr)
      __state._M_want_xday = 1;
    break;
  case 'H':

    __beg = _M_extract_num(__beg, __end, __mem, 0, 23, 2,
      __io, __tmperr);
    if (!__tmperr)
      {
        __tm->tm_hour = __mem;
        __state._M_have_I = 0;
      }
    break;
  case 'I':

    __beg = _M_extract_num(__beg, __end, __mem, 1, 12, 2,
      __io, __tmperr);
    if (!__tmperr)
      {
        __tm->tm_hour = __mem % 12;
        __state._M_have_I = 1;
      }
    break;
  case 'j':

    __beg = _M_extract_num(__beg, __end, __mem, 1, 366, 3,
      __io, __tmperr);
    if (!__tmperr)
      {
        __tm->tm_yday = __mem - 1;
        __state._M_have_yday = 1;
      }
    break;
  case 'm':

    __beg = _M_extract_num(__beg, __end, __mem, 1, 12, 2,
      __io, __tmperr);
    if (!__tmperr)
      {
        __tm->tm_mon = __mem - 1;
        __state._M_have_mon = 1;
      }
    break;
  case 'M':

    __beg = _M_extract_num(__beg, __end, __mem, 0, 59, 2,
      __io, __tmperr);
    if (!__tmperr)
      __tm->tm_min = __mem;
    break;
  case 'n':
  case 't':
    while (__beg != __end
    && __ctype.is(ctype_base::space, *__beg))
      ++__beg;
    break;
  case 'p':

    const char_type* __ampm[2];
    __tp._M_am_pm(&__ampm[0]);
    if (!__ampm[0][0] || !__ampm[1][0])
      break;
    __beg = _M_extract_name(__beg, __end, __mem, __ampm,
       2, __io, __tmperr);
    if (!__tmperr && __mem)
      __state._M_is_pm = 1;
    break;
  case 'r':

    const char_type* __ampm_format;
    __tp._M_am_pm_format(&__ampm_format);
    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
      __tm, __ampm_format, __state);
    break;
  case 'R':

    __cs = "%H:%M";
    __ctype.widen(__cs, __cs + 6, __wcs);
    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
      __tm, __wcs, __state);
    break;
  case 'S':



    __beg = _M_extract_num(__beg, __end, __mem, 0, 60, 2,



      __io, __tmperr);
    if (!__tmperr)
      __tm->tm_sec = __mem;
    break;
  case 'T':

    __cs = "%H:%M:%S";
    __ctype.widen(__cs, __cs + 9, __wcs);
    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
      __tm, __wcs, __state);
    break;
  case 'U':

    __beg = _M_extract_num(__beg, __end, __mem, 0, 53, 2,
      __io, __tmperr);
    if (!__tmperr)
      {
        __state._M_week_no = __mem;
        __state._M_have_uweek = 1;
      }
    break;
  case 'w':

    __beg = _M_extract_num(__beg, __end, __mem, 0, 6, 1,
      __io, __tmperr);
    if (!__tmperr)
      {
        __tm->tm_wday = __mem;
        __state._M_have_wday = 1;
      }
    break;
  case 'W':

    __beg = _M_extract_num(__beg, __end, __mem, 0, 53, 2,
      __io, __tmperr);
    if (!__tmperr)
      {
        __state._M_week_no = __mem;
        __state._M_have_wweek = 1;
      }
    break;
  case 'x':

    const char_type* __dates[2];
    __tp._M_date_formats(__dates);
    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
      __tm, __dates[0], __state);
    break;
  case 'X':

    const char_type* __times[2];
    __tp._M_time_formats(__times);
    __beg = _M_extract_via_format(__beg, __end, __io, __tmperr,
      __tm, __times[0], __state);
    break;
  case 'y':

    __beg = _M_extract_num(__beg, __end, __mem, 0, 99, 2,
      __io, __tmperr);
    if (!__tmperr)
      {
        __state._M_want_century = 1;
        __state._M_want_xday = 1;


        __c = 0;
        if (__beg != __end)
   __c = __ctype.narrow(*__beg, '*');
        if (__c >= '0' && __c <= '9')
   {
     ++__beg;
     __mem = __mem * 10 + (__c - '0');
     if (__beg != __end)
       {
         __c = __ctype.narrow(*__beg, '*');
         if (__c >= '0' && __c <= '9')
    {
      ++__beg;
      __mem = __mem * 10 + (__c - '0');
    }
       }
     __mem -= 1900;
     __state._M_want_century = 0;
   }


        else if (__mem < 69)
   __mem += 100;
        __tm->tm_year = __mem;
      }
    break;
  case 'Y':

    __beg = _M_extract_num(__beg, __end, __mem, 0, 9999, 4,
      __io, __tmperr);
    if (!__tmperr)
      {
        __tm->tm_year = __mem - 1900;
        __state._M_want_century = 0;
        __state._M_want_xday = 1;
      }
    break;
  case 'Z':

    if (__ctype.is(ctype_base::upper, *__beg))
      {
        int __tmp;
        __beg = _M_extract_name(__beg, __end, __tmp,
           __timepunct_cache<_CharT>::_S_timezones,
           14, __io, __tmperr);


        if (__beg != __end && !__tmperr && __tmp == 0
     && (*__beg == __ctype.widen('-')
         || *__beg == __ctype.widen('+')))
   {
     __beg = _M_extract_num(__beg, __end, __tmp, 0, 23, 2,
       __io, __tmperr);
     __beg = _M_extract_num(__beg, __end, __tmp, 0, 59, 2,
       __io, __tmperr);
   }
      }
    else
      __tmperr |= ios_base::failbit;
    break;
  case '%':
    if (*__beg == __ctype.widen('%'))
      ++__beg;
    else
      __tmperr |= ios_base::failbit;
    break;
  default:

    __tmperr |= ios_base::failbit;
  }
     }
   else if (__ctype.is(ctype_base::space, __format[__i]))
     {

       while (__beg != __end
       && __ctype.is(ctype_base::space, *__beg))
  ++__beg;
     }
   else
     {


       if (__ctype.tolower(__format[__i]) == __ctype.tolower(*__beg)
    || __ctype.toupper(__format[__i]) == __ctype.toupper(*__beg))
  ++__beg;
       else
  __tmperr |= ios_base::failbit;
     }
 }

      if (__tmperr || __i != __len)
 __err |= ios_base::failbit;

      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    _M_extract_via_format(iter_type __beg, iter_type __end, ios_base& __io,
     ios_base::iostate& __err, tm* __tm,
     const _CharT* __format) const
    {
      __time_get_state __state = __time_get_state();
      return _M_extract_via_format(__beg, __end, __io, __err, __tm,
       __format, __state);
    }

  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    _M_extract_num(iter_type __beg, iter_type __end, int& __member,
     int __min, int __max, size_t __len,
     ios_base& __io, ios_base::iostate& __err) const
    {
      const locale& __loc = __io._M_getloc();
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

      size_t __i = 0;
      int __value = 0;
      for (; __beg != __end && __i < __len; ++__beg, (void)++__i)
 {
   const char __c = __ctype.narrow(*__beg, '*');
   if (__c >= '0' && __c <= '9')
     {
       __value = __value * 10 + (__c - '0');
       if (__value > __max)
  break;
     }
   else
     break;
 }
      if (__i && __value >= __min && __value <= __max)
 __member = __value;
      else
 __err |= ios_base::failbit;

      return __beg;
    }






  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    _M_extract_name(iter_type __beg, iter_type __end, int& __member,
      const _CharT** __names, size_t __indexlen,
      ios_base& __io, ios_base::iostate& __err) const
    {
      typedef char_traits<_CharT> __traits_type;
      const locale& __loc = __io._M_getloc();
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

      size_t* __matches
 = static_cast<size_t*>(__builtin_alloca(2 * sizeof(size_t)
      * __indexlen));
      size_t* __lengths = __matches + __indexlen;
      size_t __nmatches = 0;
      size_t __pos = 0;
      bool __testvalid = true;
      const char_type* __name;
      bool __begupdated = false;


      if (__beg != __end)
 {
   const char_type __c = *__beg;

   const char_type __cl = __ctype.tolower(__c);
   const char_type __cu = __ctype.toupper(__c);
   for (size_t __i1 = 0; __i1 < __indexlen; ++__i1)
     if (__cl == __ctype.tolower(__names[__i1][0])
  || __cu == __ctype.toupper(__names[__i1][0]))
       {
  __lengths[__nmatches]
    = __traits_type::length(__names[__i1]);
  __matches[__nmatches++] = __i1;
       }
 }

      while (__nmatches > 1)
 {

   size_t __minlen = __lengths[0];
   for (size_t __i2 = 1; __i2 < __nmatches; ++__i2)
     __minlen = std::min(__minlen, __lengths[__i2]);
   ++__pos;
   ++__beg;
   if (__pos == __minlen)
     {






       bool __match_longer = false;

       if (__beg != __end)
  {

    const char_type __cl = __ctype.tolower(*__beg);
    const char_type __cu = __ctype.toupper(*__beg);
    for (size_t __i3 = 0; __i3 < __nmatches; ++__i3)
      {
        __name = __names[__matches[__i3]];
        if (__lengths[__i3] > __pos
     && (__ctype.tolower(__name[__pos]) == __cl
         || __ctype.toupper(__name[__pos]) == __cu))
   {
     __match_longer = true;
     break;
   }
      }
  }
       for (size_t __i4 = 0; __i4 < __nmatches;)
  if (__match_longer == (__lengths[__i4] == __pos))
    {
      __matches[__i4] = __matches[--__nmatches];
      __lengths[__i4] = __lengths[__nmatches];
    }
  else
    ++__i4;
       if (__match_longer)
  {
    __minlen = __lengths[0];
    for (size_t __i5 = 1; __i5 < __nmatches; ++__i5)
      __minlen = std::min(__minlen, __lengths[__i5]);
  }
       else
  {


    if (__nmatches == 2 && (__indexlen & 1) == 0)
      {
        if (__matches[0] < __indexlen / 2)
   {
     if (__matches[1] == __matches[0] + __indexlen / 2)
       __nmatches = 1;
   }
        else if (__matches[1] == __matches[0] - __indexlen / 2)
   {
     __matches[0] = __matches[1];
     __lengths[0] = __lengths[1];
     __nmatches = 1;
   }
      }
    __begupdated = true;
    break;
  }
     }
   if (__pos < __minlen && __beg != __end)
     {

       const char_type __cl = __ctype.tolower(*__beg);
       const char_type __cu = __ctype.toupper(*__beg);
       for (size_t __i6 = 0; __i6 < __nmatches;)
  {
    __name = __names[__matches[__i6]];
    if (__ctype.tolower(__name[__pos]) != __cl
        && __ctype.toupper(__name[__pos]) != __cu)
      {
        __matches[__i6] = __matches[--__nmatches];
        __lengths[__i6] = __lengths[__nmatches];
      }
    else
      ++__i6;
  }
     }
   else
     break;
 }

      if (__nmatches == 1)
 {

   if (!__begupdated)
     {
       ++__beg;
       ++__pos;
     }
   __name = __names[__matches[0]];
   const size_t __len = __lengths[0];
   while (__pos < __len
   && __beg != __end

   && (__ctype.tolower(__name[__pos]) == __ctype.tolower(*__beg)
       || (__ctype.toupper(__name[__pos])
    == __ctype.toupper(*__beg))))
     ++__beg, (void)++__pos;

   if (__len == __pos)
     __member = __matches[0];
   else
     __testvalid = false;
 }
      else
 __testvalid = false;
      if (!__testvalid)
 __err |= ios_base::failbit;

      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    _M_extract_wday_or_month(iter_type __beg, iter_type __end, int& __member,
        const _CharT** __names, size_t __indexlen,
        ios_base& __io, ios_base::iostate& __err) const
    {
      typedef char_traits<_CharT> __traits_type;
      const locale& __loc = __io._M_getloc();
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

      int* __matches = static_cast<int*>(__builtin_alloca(2 * sizeof(int)
         * __indexlen));
      size_t __nmatches = 0;
      size_t* __matches_lengths = 0;
      size_t __pos = 0;

      if (__beg != __end)
 {
   const char_type __c = *__beg;
   for (size_t __i = 0; __i < 2 * __indexlen; ++__i)
     if (__c == __names[__i][0]
  || __c == __ctype.toupper(__names[__i][0]))
       __matches[__nmatches++] = __i;
 }

      if (__nmatches)
 {
   ++__beg;
   ++__pos;

   __matches_lengths
     = static_cast<size_t*>(__builtin_alloca(sizeof(size_t)
          * __nmatches));
   for (size_t __i = 0; __i < __nmatches; ++__i)
     __matches_lengths[__i]
       = __traits_type::length(__names[__matches[__i]]);
 }

      for (; __beg != __end; ++__beg, (void)++__pos)
 {
   size_t __nskipped = 0;
   const char_type __c = *__beg;
   for (size_t __i = 0; __i < __nmatches;)
     {
       const char_type* __name = __names[__matches[__i]];
       if (__pos >= __matches_lengths[__i])
  ++__nskipped, ++__i;
       else if (!(__name[__pos] == __c))
  {
    --__nmatches;
    __matches[__i] = __matches[__nmatches];
    __matches_lengths[__i] = __matches_lengths[__nmatches];
  }
       else
  ++__i;
     }
   if (__nskipped == __nmatches)
     break;
 }

      if ((__nmatches == 1 && __matches_lengths[0] == __pos)
   || (__nmatches == 2 && (__matches_lengths[0] == __pos
      || __matches_lengths[1] == __pos)))
 __member = (__matches[0] >= (int)__indexlen
      ? __matches[0] - (int)__indexlen : __matches[0]);
      else
 __err |= ios_base::failbit;

      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    do_get_time(iter_type __beg, iter_type __end, ios_base& __io,
  ios_base::iostate& __err, tm* __tm) const
    {
      const locale& __loc = __io._M_getloc();
      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
      const char_type* __times[2];
      __tp._M_time_formats(__times);
      __time_get_state __state = __time_get_state();
      __beg = _M_extract_via_format(__beg, __end, __io, __err,
        __tm, __times[0], __state);
      __state._M_finalize_state(__tm);
      if (__beg == __end)
 __err |= ios_base::eofbit;
      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    do_get_date(iter_type __beg, iter_type __end, ios_base& __io,
  ios_base::iostate& __err, tm* __tm) const
    {
      const locale& __loc = __io._M_getloc();
      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
      const char_type* __dates[2];
      __tp._M_date_formats(__dates);
      __time_get_state __state = __time_get_state();
      __beg = _M_extract_via_format(__beg, __end, __io, __err,
        __tm, __dates[0], __state);
      __state._M_finalize_state(__tm);
      if (__beg == __end)
 __err |= ios_base::eofbit;
      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    do_get_weekday(iter_type __beg, iter_type __end, ios_base& __io,
     ios_base::iostate& __err, tm* __tm) const
    {
      const locale& __loc = __io._M_getloc();
      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
      const char_type* __days[14];
      __tp._M_days_abbreviated(__days);
      __tp._M_days(__days + 7);
      int __tmpwday;
      ios_base::iostate __tmperr = ios_base::goodbit;

      __beg = _M_extract_wday_or_month(__beg, __end, __tmpwday, __days, 7,
           __io, __tmperr);
      if (!__tmperr)
 __tm->tm_wday = __tmpwday;
      else
 __err |= ios_base::failbit;

      if (__beg == __end)
 __err |= ios_base::eofbit;
      return __beg;
     }

  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    do_get_monthname(iter_type __beg, iter_type __end,
                     ios_base& __io, ios_base::iostate& __err, tm* __tm) const
    {
      const locale& __loc = __io._M_getloc();
      const __timepunct<_CharT>& __tp = use_facet<__timepunct<_CharT> >(__loc);
      const char_type* __months[24];
      __tp._M_months_abbreviated(__months);
      __tp._M_months(__months + 12);
      int __tmpmon;
      ios_base::iostate __tmperr = ios_base::goodbit;

      __beg = _M_extract_wday_or_month(__beg, __end, __tmpmon, __months, 12,
           __io, __tmperr);
      if (!__tmperr)
 __tm->tm_mon = __tmpmon;
      else
 __err |= ios_base::failbit;

      if (__beg == __end)
 __err |= ios_base::eofbit;
      return __beg;
    }

  template<typename _CharT, typename _InIter>
    _InIter
    time_get<_CharT, _InIter>::
    do_get_year(iter_type __beg, iter_type __end, ios_base& __io,
  ios_base::iostate& __err, tm* __tm) const
    {
      int __tmpyear;
      ios_base::iostate __tmperr = ios_base::goodbit;
      const locale& __loc = __io._M_getloc();
      const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc);

      __beg = _M_extract_num(__beg, __end, __tmpyear, 0, 99, 2,
        __io, __tmperr);
      if (!__tmperr)
 {
   char __c = 0;
   if (__beg != __end)
     __c = __ctype.narrow(*__beg, '*');



   if (__c >= '0' && __c <= '9')
     {
       ++__beg;
       __tmpyear = __tmpyear * 10 + (__c - '0');
       if (__beg != __end)
  {
    __c = __ctype.narrow(*__beg, '*');
    if (__c >= '0' && __c <= '9')
      {
        ++__beg;
        __tmpyear = __tmpyear * 10 + (__c - '0');
      }
  }
       __tmpyear -= 1900;
     }
   else if (__tmpyear < 69)
     __tmpyear += 100;
   __tm->tm_year = __tmpyear;
 }
      else
 __err |= ios_base::failbit;

      if (__beg == __end)
 __err |= ios_base::eofbit;
      return __beg;
    }


  template<typename _CharT, typename _InIter>
    inline
    _InIter
    time_get<_CharT, _InIter>::
    get(iter_type __s, iter_type __end, ios_base& __io,
        ios_base::iostate& __err, tm* __tm, const char_type* __fmt,
        const char_type* __fmtend) const
    {
      const locale& __loc = __io._M_getloc();
      ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
      __err = ios_base::goodbit;
      bool __use_state = false;
# 1481 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.tcc" 3
      __time_get_state __state = __time_get_state();
      while (__fmt != __fmtend &&
             __err == ios_base::goodbit)
        {
          if (__s == __end)
            {
              __err = ios_base::eofbit | ios_base::failbit;
              break;
            }
          else if (__ctype.narrow(*__fmt, 0) == '%')
            {
       const char_type* __fmt_start = __fmt;
              char __format;
              char __mod = 0;
              if (++__fmt == __fmtend)
                {
                  __err = ios_base::failbit;
                  break;
                }
              const char __c = __ctype.narrow(*__fmt, 0);
              if (__c != 'E' && __c != 'O')
                __format = __c;
              else if (++__fmt != __fmtend)
                {
                  __mod = __c;
                  __format = __ctype.narrow(*__fmt, 0);
                }
              else
                {
                  __err = ios_base::failbit;
                  break;
                }
       if (__use_state)
  {
    char_type __new_fmt[4];
    __new_fmt[0] = __fmt_start[0];
    __new_fmt[1] = __fmt_start[1];
    if (__mod)
      {
        __new_fmt[2] = __fmt_start[2];
        __new_fmt[3] = char_type();
      }
    else
      __new_fmt[2] = char_type();
    __s = _M_extract_via_format(__s, __end, __io, __err, __tm,
           __new_fmt, __state);
    if (__s == __end)
      __err |= ios_base::eofbit;
  }
       else
  __s = this->do_get(__s, __end, __io, __err, __tm, __format,
       __mod);
              ++__fmt;
            }
          else if (__ctype.is(ctype_base::space, *__fmt))
            {
              ++__fmt;
              while (__fmt != __fmtend &&
                     __ctype.is(ctype_base::space, *__fmt))
                ++__fmt;

              while (__s != __end &&
                     __ctype.is(ctype_base::space, *__s))
                ++__s;
            }

          else if (__ctype.tolower(*__s) == __ctype.tolower(*__fmt) ||
                   __ctype.toupper(*__s) == __ctype.toupper(*__fmt))
            {
              ++__s;
              ++__fmt;
            }
          else
            {
              __err = ios_base::failbit;
              break;
            }
        }
      if (__use_state)
 __state._M_finalize_state(__tm);
      return __s;
    }

  template<typename _CharT, typename _InIter>
    inline
    _InIter
    time_get<_CharT, _InIter>::
    do_get(iter_type __beg, iter_type __end, ios_base& __io,
           ios_base::iostate& __err, tm* __tm,
           char __format, char __mod) const
    {
      const locale& __loc = __io._M_getloc();
      ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
      __err = ios_base::goodbit;

      char_type __fmt[4];
      __fmt[0] = __ctype.widen('%');
      if (!__mod)
        {
          __fmt[1] = __format;
          __fmt[2] = char_type();
        }
      else
        {
          __fmt[1] = __mod;
          __fmt[2] = __format;
          __fmt[3] = char_type();
        }

      __time_get_state __state = __time_get_state();
      __beg = _M_extract_via_format(__beg, __end, __io, __err, __tm, __fmt,
        __state);
      __state._M_finalize_state(__tm);
      if (__beg == __end)
 __err |= ios_base::eofbit;
      return __beg;
    }



  template<typename _CharT, typename _OutIter>
    _OutIter
    time_put<_CharT, _OutIter>::
    put(iter_type __s, ios_base& __io, char_type __fill, const tm* __tm,
 const _CharT* __beg, const _CharT* __end) const
    {
      const locale& __loc = __io._M_getloc();
      ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
      for (; __beg != __end; ++__beg)
 if (__ctype.narrow(*__beg, 0) != '%')
   {
     *__s = *__beg;
     ++__s;
   }
 else if (++__beg != __end)
   {
     char __format;
     char __mod = 0;
     const char __c = __ctype.narrow(*__beg, 0);
     if (__c != 'E' && __c != 'O')
       __format = __c;
     else if (++__beg != __end)
       {
  __mod = __c;
  __format = __ctype.narrow(*__beg, 0);
       }
     else
       break;
     __s = this->do_put(__s, __io, __fill, __tm, __format, __mod);
   }
 else
   break;
      return __s;
    }

  template<typename _CharT, typename _OutIter>
    _OutIter
    time_put<_CharT, _OutIter>::
    do_put(iter_type __s, ios_base& __io, char_type, const tm* __tm,
    char __format, char __mod) const
    {
      const locale& __loc = __io._M_getloc();
      ctype<_CharT> const& __ctype = use_facet<ctype<_CharT> >(__loc);
      __timepunct<_CharT> const& __tp = use_facet<__timepunct<_CharT> >(__loc);



      const size_t __maxlen = 128;
      char_type __res[__maxlen];






      char_type __fmt[4];
      __fmt[0] = __ctype.widen('%');
      if (!__mod)
 {
   __fmt[1] = __format;
   __fmt[2] = char_type();
 }
      else
 {
   __fmt[1] = __mod;
   __fmt[2] = __format;
   __fmt[3] = char_type();
 }

      __tp._M_put(__res, __maxlen, __fmt, __tm);


      return std::__write(__s, __res, char_traits<char_type>::length(__res));
    }





  extern template class moneypunct<char, false>;
  extern template class moneypunct<char, true>;
  extern template class moneypunct_byname<char, false>;
  extern template class moneypunct_byname<char, true>;
  extern template class __cxx11:: money_get<char>;
  extern template class __cxx11:: money_put<char>;
  extern template class __timepunct<char>;
  extern template class time_put<char>;
  extern template class time_put_byname<char>;
  extern template class time_get<char>;
  extern template class time_get_byname<char>;
  extern template class messages<char>;
  extern template class messages_byname<char>;

  extern template
    const moneypunct<char, true>*
    __try_use_facet<moneypunct<char, true> >(const locale&) noexcept;

  extern template
    const moneypunct<char, false>*
    __try_use_facet<moneypunct<char, false> >(const locale&) noexcept;

  extern template
    const money_put<char>*
    __try_use_facet<money_put<char> >(const locale&) noexcept;

  extern template
    const money_get<char>*
    __try_use_facet<money_get<char> >(const locale&) noexcept;

  extern template
    const __timepunct<char>*
    __try_use_facet<__timepunct<char> >(const locale&) noexcept;

  extern template
    const time_put<char>*
    __try_use_facet<time_put<char> >(const locale&) noexcept;

  extern template
    const time_get<char>*
    __try_use_facet<time_get<char> >(const locale&) noexcept;

  extern template
    const messages<char>*
    __try_use_facet<messages<char> >(const locale&) noexcept;

  extern template
    const moneypunct<char, true>&
    use_facet<moneypunct<char, true> >(const locale&);

  extern template
    const moneypunct<char, false>&
    use_facet<moneypunct<char, false> >(const locale&);

  extern template
    const money_put<char>&
    use_facet<money_put<char> >(const locale&);

  extern template
    const money_get<char>&
    use_facet<money_get<char> >(const locale&);

  extern template
    const __timepunct<char>&
    use_facet<__timepunct<char> >(const locale&);

  extern template
    const time_put<char>&
    use_facet<time_put<char> >(const locale&);

  extern template
    const time_get<char>&
    use_facet<time_get<char> >(const locale&);

  extern template
    const messages<char>&
    use_facet<messages<char> >(const locale&);

  extern template
    bool
    has_facet<moneypunct<char> >(const locale&);

  extern template
    bool
    has_facet<money_put<char> >(const locale&);

  extern template
    bool
    has_facet<money_get<char> >(const locale&);

  extern template
    bool
    has_facet<__timepunct<char> >(const locale&);

  extern template
    bool
    has_facet<time_put<char> >(const locale&);

  extern template
    bool
    has_facet<time_get<char> >(const locale&);

  extern template
    bool
    has_facet<messages<char> >(const locale&);


  extern template class moneypunct<wchar_t, false>;
  extern template class moneypunct<wchar_t, true>;
  extern template class moneypunct_byname<wchar_t, false>;
  extern template class moneypunct_byname<wchar_t, true>;
  extern template class __cxx11:: money_get<wchar_t>;
  extern template class __cxx11:: money_put<wchar_t>;
  extern template class __timepunct<wchar_t>;
  extern template class time_put<wchar_t>;
  extern template class time_put_byname<wchar_t>;
  extern template class time_get<wchar_t>;
  extern template class time_get_byname<wchar_t>;
  extern template class messages<wchar_t>;
  extern template class messages_byname<wchar_t>;

  extern template
    const moneypunct<wchar_t, true>*
    __try_use_facet<moneypunct<wchar_t, true> >(const locale&) noexcept;

  extern template
    const moneypunct<wchar_t, false>*
    __try_use_facet<moneypunct<wchar_t, false> >(const locale&) noexcept;

  extern template
    const money_put<wchar_t>*
    __try_use_facet<money_put<wchar_t> >(const locale&) noexcept;

  extern template
    const money_get<wchar_t>*
    __try_use_facet<money_get<wchar_t> >(const locale&) noexcept;

  extern template
    const __timepunct<wchar_t>*
    __try_use_facet<__timepunct<wchar_t> >(const locale&) noexcept;

  extern template
    const time_put<wchar_t>*
    __try_use_facet<time_put<wchar_t> >(const locale&) noexcept;

  extern template
    const time_get<wchar_t>*
    __try_use_facet<time_get<wchar_t> >(const locale&) noexcept;

  extern template
    const messages<wchar_t>*
    __try_use_facet<messages<wchar_t> >(const locale&) noexcept;

  extern template
    const moneypunct<wchar_t, true>&
    use_facet<moneypunct<wchar_t, true> >(const locale&);

  extern template
    const moneypunct<wchar_t, false>&
    use_facet<moneypunct<wchar_t, false> >(const locale&);

  extern template
    const money_put<wchar_t>&
    use_facet<money_put<wchar_t> >(const locale&);

  extern template
    const money_get<wchar_t>&
    use_facet<money_get<wchar_t> >(const locale&);

  extern template
    const __timepunct<wchar_t>&
    use_facet<__timepunct<wchar_t> >(const locale&);

  extern template
    const time_put<wchar_t>&
    use_facet<time_put<wchar_t> >(const locale&);

  extern template
    const time_get<wchar_t>&
    use_facet<time_get<wchar_t> >(const locale&);

  extern template
    const messages<wchar_t>&
    use_facet<messages<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<moneypunct<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<money_put<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<money_get<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<__timepunct<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<time_put<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<time_get<wchar_t> >(const locale&);

  extern template
    bool
    has_facet<messages<wchar_t> >(const locale&);




}
# 2070 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_facets_nonio.h" 2 3
# 44 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/locale" 2 3

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_conv.h" 1 3
# 42 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_conv.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{







  template<typename _OutStr, typename _InChar, typename _Codecvt,
    typename _State, typename _Fn>
    bool
    __do_str_codecvt(const _InChar* __first, const _InChar* __last,
       _OutStr& __outstr, const _Codecvt& __cvt, _State& __state,
       size_t& __count, _Fn __fn)
    {
      if (__first == __last)
 {
   __outstr.clear();
   __count = 0;
   return true;
 }

      size_t __outchars = 0;
      auto __next = __first;
      const auto __maxlen = __cvt.max_length() + 1;

      codecvt_base::result __result;
      do
 {
   __outstr.resize(__outstr.size() + (__last - __next) * __maxlen);
   auto __outnext = &__outstr.front() + __outchars;
   auto const __outlast = &__outstr.back() + 1;
   __result = (__cvt.*__fn)(__state, __next, __last, __next,
     __outnext, __outlast, __outnext);
   __outchars = __outnext - &__outstr.front();
 }
      while (__result == codecvt_base::partial && __next != __last
      && ptrdiff_t(__outstr.size() - __outchars) < __maxlen);

      if (__result == codecvt_base::error)
 {
   __count = __next - __first;
   return false;
 }



      if constexpr (is_same<typename _Codecvt::intern_type,
           typename _Codecvt::extern_type>())
 if (__result == codecvt_base::noconv)
   {
     __outstr.assign(__first, __last);
     __count = __last - __first;
     return true;
   }

      __outstr.resize(__outchars);
      __count = __next - __first;
      return true;
    }


  template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
    inline bool
    __str_codecvt_in(const char* __first, const char* __last,
       basic_string<_CharT, _Traits, _Alloc>& __outstr,
       const codecvt<_CharT, char, _State>& __cvt,
       _State& __state, size_t& __count)
    {
      using _Codecvt = codecvt<_CharT, char, _State>;
      using _ConvFn
 = codecvt_base::result
   (_Codecvt::*)(_State&, const char*, const char*, const char*&,
   _CharT*, _CharT*, _CharT*&) const;
      _ConvFn __fn = &codecvt<_CharT, char, _State>::in;
      return __do_str_codecvt(__first, __last, __outstr, __cvt, __state,
         __count, __fn);
    }


  template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
    inline bool
    __str_codecvt_in(const char* __first, const char* __last,
       basic_string<_CharT, _Traits, _Alloc>& __outstr,
       const codecvt<_CharT, char, _State>& __cvt)
    {
      _State __state = {};
      size_t __n;
      return __str_codecvt_in(__first, __last, __outstr, __cvt, __state, __n);
    }


  template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
    inline bool
    __str_codecvt_in_all(const char* __first, const char* __last,
    basic_string<_CharT, _Traits, _Alloc>& __outstr,
    const codecvt<_CharT, char, _State>& __cvt)
    {
      _State __state = {};
      size_t __n;
      return __str_codecvt_in(__first, __last, __outstr, __cvt, __state, __n)
 && (__n == size_t(__last - __first));
    }


  template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
    inline bool
    __str_codecvt_out(const _CharT* __first, const _CharT* __last,
        basic_string<char, _Traits, _Alloc>& __outstr,
        const codecvt<_CharT, char, _State>& __cvt,
        _State& __state, size_t& __count)
    {
      using _Codecvt = codecvt<_CharT, char, _State>;
      using _ConvFn
 = codecvt_base::result
   (_Codecvt::*)(_State&, const _CharT*, const _CharT*, const _CharT*&,
   char*, char*, char*&) const;
      _ConvFn __fn = &codecvt<_CharT, char, _State>::out;
      return __do_str_codecvt(__first, __last, __outstr, __cvt, __state,
         __count, __fn);
    }


  template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
    inline bool
    __str_codecvt_out(const _CharT* __first, const _CharT* __last,
        basic_string<char, _Traits, _Alloc>& __outstr,
        const codecvt<_CharT, char, _State>& __cvt)
    {
      _State __state = {};
      size_t __n;
      return __str_codecvt_out(__first, __last, __outstr, __cvt, __state, __n);
    }


  template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
    inline bool
    __str_codecvt_out_all(const _CharT* __first, const _CharT* __last,
     basic_string<char, _Traits, _Alloc>& __outstr,
     const codecvt<_CharT, char, _State>& __cvt)
    {
      _State __state = {};
      size_t __n;
      return __str_codecvt_out(__first, __last, __outstr, __cvt, __state, __n)
 && (__n == size_t(__last - __first));
    }




  template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
    inline bool
    __str_codecvt_out(const _CharT* __first, const _CharT* __last,
        basic_string<char8_t, _Traits, _Alloc>& __outstr,
        const codecvt<_CharT, char8_t, _State>& __cvt,
        _State& __state, size_t& __count)
    {
      using _Codecvt = codecvt<_CharT, char8_t, _State>;
      using _ConvFn
 = codecvt_base::result
   (_Codecvt::*)(_State&, const _CharT*, const _CharT*, const _CharT*&,
   char8_t*, char8_t*, char8_t*&) const;
      _ConvFn __fn = &codecvt<_CharT, char8_t, _State>::out;
      return __do_str_codecvt(__first, __last, __outstr, __cvt, __state,
         __count, __fn);
    }

  template<typename _CharT, typename _Traits, typename _Alloc, typename _State>
    inline bool
    __str_codecvt_out(const _CharT* __first, const _CharT* __last,
        basic_string<char8_t, _Traits, _Alloc>& __outstr,
        const codecvt<_CharT, char8_t, _State>& __cvt)
    {
      _State __state = {};
      size_t __n;
      return __str_codecvt_out(__first, __last, __outstr, __cvt, __state, __n);
    }



  namespace __detail
  {
    template<typename _Tp>
      struct _Scoped_ptr
      {
 __attribute__((__nonnull__(2)))
 explicit
 _Scoped_ptr(_Tp* __ptr) noexcept
 : _M_ptr(__ptr)
 { }

 _Scoped_ptr(_Tp* __ptr, const char* __msg)
 : _M_ptr(__ptr)
 {
   if (!__ptr)
     __throw_logic_error(__msg);
 }

 ~_Scoped_ptr() { delete _M_ptr; }

 _Scoped_ptr(const _Scoped_ptr&) = delete;
 _Scoped_ptr& operator=(const _Scoped_ptr&) = delete;

 __attribute__((__returns_nonnull__))
 _Tp* operator->() const noexcept { return _M_ptr; }

 _Tp& operator*() const noexcept { return *_M_ptr; }

      private:
 _Tp* _M_ptr;
      };
  }

namespace __cxx11 {


  template<typename _Codecvt, typename _Elem = wchar_t,
    typename _Wide_alloc = allocator<_Elem>,
    typename _Byte_alloc = allocator<char>>
    class wstring_convert
    {
    public:
      typedef basic_string<char, char_traits<char>, _Byte_alloc> byte_string;
      typedef basic_string<_Elem, char_traits<_Elem>, _Wide_alloc> wide_string;
      typedef typename _Codecvt::state_type state_type;
      typedef typename wide_string::traits_type::int_type int_type;


      wstring_convert() : _M_cvt(new _Codecvt()) { }







      explicit
      wstring_convert(_Codecvt* __pcvt) : _M_cvt(__pcvt, "wstring_convert")
      { }
# 291 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_conv.h" 3
      wstring_convert(_Codecvt* __pcvt, state_type __state)
      : _M_cvt(__pcvt, "wstring_convert"),
 _M_state(__state), _M_with_cvtstate(true)
      { }






      explicit
      wstring_convert(const byte_string& __byte_err,
        const wide_string& __wide_err = wide_string())
      : _M_cvt(new _Codecvt),
 _M_byte_err_string(__byte_err), _M_wide_err_string(__wide_err),
 _M_with_strings(true)
      { }

      ~wstring_convert() = default;



      wstring_convert(const wstring_convert&) = delete;
      wstring_convert& operator=(const wstring_convert&) = delete;


      wide_string
      from_bytes(char __byte)
      {
 char __bytes[2] = { __byte };
 return from_bytes(__bytes, __bytes+1);
      }

      wide_string
      from_bytes(const char* __ptr)
      { return from_bytes(__ptr, __ptr+char_traits<char>::length(__ptr)); }

      wide_string
      from_bytes(const byte_string& __str)
      {
 auto __ptr = __str.data();
 return from_bytes(__ptr, __ptr + __str.size());
      }

      wide_string
      from_bytes(const char* __first, const char* __last)
      {
 if (!_M_with_cvtstate)
   _M_state = state_type();
 wide_string __out{ _M_wide_err_string.get_allocator() };
 if (__str_codecvt_in(__first, __last, __out, *_M_cvt, _M_state,
        _M_count))
   return __out;
 if (_M_with_strings)
   return _M_wide_err_string;
 __throw_range_error("wstring_convert::from_bytes");
      }



      byte_string
      to_bytes(_Elem __wchar)
      {
 _Elem __wchars[2] = { __wchar };
 return to_bytes(__wchars, __wchars+1);
      }

      byte_string
      to_bytes(const _Elem* __ptr)
      {
 return to_bytes(__ptr, __ptr+wide_string::traits_type::length(__ptr));
      }

      byte_string
      to_bytes(const wide_string& __wstr)
      {
 auto __ptr = __wstr.data();
 return to_bytes(__ptr, __ptr + __wstr.size());
      }

      byte_string
      to_bytes(const _Elem* __first, const _Elem* __last)
      {
 if (!_M_with_cvtstate)
   _M_state = state_type();
 byte_string __out{ _M_byte_err_string.get_allocator() };
 if (__str_codecvt_out(__first, __last, __out, *_M_cvt, _M_state,
         _M_count))
   return __out;
 if (_M_with_strings)
   return _M_byte_err_string;
 __throw_range_error("wstring_convert::to_bytes");
      }





      size_t converted() const noexcept { return _M_count; }


      state_type state() const { return _M_state; }

    private:
      __detail::_Scoped_ptr<_Codecvt> _M_cvt;
      byte_string _M_byte_err_string;
      wide_string _M_wide_err_string;
      state_type _M_state = state_type();
      size_t _M_count = 0;
      bool _M_with_cvtstate = false;
      bool _M_with_strings = false;
    };

}


  template<typename _Codecvt, typename _Elem = wchar_t,
    typename _Tr = char_traits<_Elem>>
    class wbuffer_convert : public basic_streambuf<_Elem, _Tr>
    {
      typedef basic_streambuf<_Elem, _Tr> _Wide_streambuf;

    public:
      typedef typename _Codecvt::state_type state_type;


      wbuffer_convert() : wbuffer_convert(nullptr) { }
# 427 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/locale_conv.h" 3
      explicit
      wbuffer_convert(streambuf* __bytebuf, _Codecvt* __pcvt = new _Codecvt,
        state_type __state = state_type())
      : _M_buf(__bytebuf), _M_cvt(__pcvt, "wbuffer_convert"),
 _M_state(__state), _M_always_noconv(_M_cvt->always_noconv())
      {
 if (_M_buf)
   {
     this->setp(_M_put_area, _M_put_area + _S_buffer_length);
     this->setg(_M_get_area + _S_putback_length,
         _M_get_area + _S_putback_length,
         _M_get_area + _S_putback_length);
   }
      }

      ~wbuffer_convert() = default;



      wbuffer_convert(const wbuffer_convert&) = delete;
      wbuffer_convert& operator=(const wbuffer_convert&) = delete;

      streambuf* rdbuf() const noexcept { return _M_buf; }

      streambuf*
      rdbuf(streambuf *__bytebuf) noexcept
      {
 auto __prev = _M_buf;
 _M_buf = __bytebuf;
 return __prev;
      }


      state_type state() const noexcept { return _M_state; }

    protected:
      int
      sync()
      { return _M_buf && _M_conv_put() && !_M_buf->pubsync() ? 0 : -1; }

      typename _Wide_streambuf::int_type
      overflow(typename _Wide_streambuf::int_type __out)
      {
 if (!_M_buf || !_M_conv_put())
   return _Tr::eof();
 else if (!_Tr::eq_int_type(__out, _Tr::eof()))
   return this->sputc(__out);
 return _Tr::not_eof(__out);
      }

      typename _Wide_streambuf::int_type
      underflow()
      {
 if (!_M_buf)
   return _Tr::eof();

 if (this->gptr() < this->egptr() || (_M_buf && _M_conv_get()))
   return _Tr::to_int_type(*this->gptr());
 else
   return _Tr::eof();
      }

      streamsize
      xsputn(const typename _Wide_streambuf::char_type* __s, streamsize __n)
      {
 if (!_M_buf || __n == 0)
   return 0;
 streamsize __done = 0;
 do
 {
   auto __nn = std::min<streamsize>(this->epptr() - this->pptr(),
        __n - __done);
   _Tr::copy(this->pptr(), __s + __done, __nn);
   this->pbump(__nn);
   __done += __nn;
 } while (__done < __n && _M_conv_put());
 return __done;
      }

    private:

      bool
      _M_conv_get()
      {
 const streamsize __pb1 = this->gptr() - this->eback();
 const streamsize __pb2 = _S_putback_length;
 const streamsize __npb = std::min(__pb1, __pb2);

 _Tr::move(_M_get_area + _S_putback_length - __npb,
    this->gptr() - __npb, __npb);

 streamsize __nbytes = sizeof(_M_get_buf) - _M_unconv;
 __nbytes = std::min(__nbytes, _M_buf->in_avail());
 if (__nbytes < 1)
   __nbytes = 1;
 __nbytes = _M_buf->sgetn(_M_get_buf + _M_unconv, __nbytes);
 if (__nbytes < 1)
   return false;
 __nbytes += _M_unconv;



 _Elem* __outbuf = _M_get_area + _S_putback_length;
 _Elem* __outnext = __outbuf;
 const char* __bnext = _M_get_buf;

 codecvt_base::result __result;
 if (_M_always_noconv)
   __result = codecvt_base::noconv;
 else
   {
     _Elem* __outend = _M_get_area + _S_buffer_length;

     __result = _M_cvt->in(_M_state,
      __bnext, __bnext + __nbytes, __bnext,
      __outbuf, __outend, __outnext);
   }

 if (__result == codecvt_base::noconv)
   {

     auto __get_buf = reinterpret_cast<const _Elem*>(_M_get_buf);
     _Tr::copy(__outbuf, __get_buf, __nbytes);
     _M_unconv = 0;
     return true;
   }

 if ((_M_unconv = _M_get_buf + __nbytes - __bnext))
   char_traits<char>::move(_M_get_buf, __bnext, _M_unconv);

 this->setg(__outbuf, __outbuf, __outnext);

 return __result != codecvt_base::error;
      }


      bool
      _M_put(...)
      { return false; }

      bool
      _M_put(const char* __p, streamsize __n)
      {
 if (_M_buf->sputn(__p, __n) < __n)
   return false;
 return true;
      }


      bool
      _M_conv_put()
      {
 _Elem* const __first = this->pbase();
 const _Elem* const __last = this->pptr();
 const streamsize __pending = __last - __first;

 if (_M_always_noconv)
   return _M_put(__first, __pending);

 char __outbuf[2 * _S_buffer_length];

 const _Elem* __next = __first;
 const _Elem* __start;
 do
   {
     __start = __next;
     char* __outnext = __outbuf;
     char* const __outlast = __outbuf + sizeof(__outbuf);
     auto __result = _M_cvt->out(_M_state, __next, __last, __next,
     __outnext, __outlast, __outnext);
     if (__result == codecvt_base::error)
       return false;
     else if (__result == codecvt_base::noconv)
       return _M_put(__next, __pending);

     if (!_M_put(__outbuf, __outnext - __outbuf))
       return false;
   }
 while (__next != __last && __next != __start);

 if (__next != __last)
   _Tr::move(__first, __next, __last - __next);

 this->pbump(__first - __next);
 return __next != __first;
      }

      streambuf* _M_buf;
      __detail::_Scoped_ptr<_Codecvt> _M_cvt;
      state_type _M_state;

      static const streamsize _S_buffer_length = 32;
      static const streamsize _S_putback_length = 3;
      _Elem _M_put_area[_S_buffer_length];
      _Elem _M_get_area[_S_buffer_length];
      streamsize _M_unconv = 0;
      char _M_get_buf[_S_buffer_length-_S_putback_length];
      bool _M_always_noconv;
    };




}
# 46 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/locale" 2 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/format" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/optional" 1 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/optional" 3



# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 38 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/optional" 2 3
# 58 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/optional" 3
namespace std __attribute__ ((__visibility__ ("default")))
{







  template<typename _Tp>
    class optional;


  struct nullopt_t
  {





    enum class _Construct { _Token };


    explicit constexpr nullopt_t(_Construct) noexcept { }
  };


  inline constexpr nullopt_t nullopt { nullopt_t::_Construct::_Token };

  template<typename _Fn> struct _Optional_func { _Fn& _M_f; };






  class bad_optional_access : public exception
  {
  public:
    bad_optional_access() = default;
    virtual ~bad_optional_access() = default;

    const char* what() const noexcept override
    { return "bad optional access"; }
  };


  [[__noreturn__]] inline void
  __throw_bad_optional_access()
  { (throw (bad_optional_access())); }



  template <typename _Tp>
    struct _Optional_payload_base
    {
      using _Stored_type = remove_const_t<_Tp>;

      _Optional_payload_base() = default;
      ~_Optional_payload_base() = default;

      template<typename... _Args>
 constexpr
 _Optional_payload_base(in_place_t __tag, _Args&&... __args)
 : _M_payload(__tag, std::forward<_Args>(__args)...),
   _M_engaged(true)
 { }

      template<typename _Up, typename... _Args>
 constexpr
 _Optional_payload_base(std::initializer_list<_Up> __il,
          _Args&&... __args)
 : _M_payload(__il, std::forward<_Args>(__args)...),
   _M_engaged(true)
 { }



      constexpr
      _Optional_payload_base(bool ,
        const _Optional_payload_base& __other)
      {
 if (__other._M_engaged)
   this->_M_construct(__other._M_get());
      }



      constexpr
      _Optional_payload_base(bool ,
        _Optional_payload_base&& __other)
      {
 if (__other._M_engaged)
   this->_M_construct(std::move(__other._M_get()));
      }



      _Optional_payload_base(const _Optional_payload_base&) = default;



      _Optional_payload_base(_Optional_payload_base&&) = default;

      _Optional_payload_base&
      operator=(const _Optional_payload_base&) = default;

      _Optional_payload_base&
      operator=(_Optional_payload_base&&) = default;


      constexpr void
      _M_copy_assign(const _Optional_payload_base& __other)
      {
 if (this->_M_engaged && __other._M_engaged)
   this->_M_get() = __other._M_get();
 else
   {
     if (__other._M_engaged)
       this->_M_construct(__other._M_get());
     else
       this->_M_reset();
   }
      }


      constexpr void
      _M_move_assign(_Optional_payload_base&& __other)
      noexcept(__and_v<is_nothrow_move_constructible<_Tp>,
         is_nothrow_move_assignable<_Tp>>)
      {
 if (this->_M_engaged && __other._M_engaged)
   this->_M_get() = std::move(__other._M_get());
 else
   {
     if (__other._M_engaged)
       this->_M_construct(std::move(__other._M_get()));
     else
       this->_M_reset();
   }
      }

      struct _Empty_byte { };

      template<typename _Up, bool = is_trivially_destructible_v<_Up>>
 union _Storage
 {
   constexpr _Storage() noexcept : _M_empty() { }

   template<typename... _Args>
     constexpr
     _Storage(in_place_t, _Args&&... __args)
     : _M_value(std::forward<_Args>(__args)...)
     { }

   template<typename _Vp, typename... _Args>
     constexpr
     _Storage(std::initializer_list<_Vp> __il, _Args&&... __args)
     : _M_value(__il, std::forward<_Args>(__args)...)
     { }


   template<typename _Fn, typename _Arg>
     constexpr
     _Storage(_Optional_func<_Fn> __f, _Arg&& __arg)
     : _M_value(std::__invoke(std::forward<_Fn>(__f._M_f),
         std::forward<_Arg>(__arg)))
     { }


   _Empty_byte _M_empty;
   _Up _M_value;
 };

      template<typename _Up>
 union _Storage<_Up, false>
 {
   constexpr _Storage() noexcept : _M_empty() { }

   template<typename... _Args>
     constexpr
     _Storage(in_place_t, _Args&&... __args)
     : _M_value(std::forward<_Args>(__args)...)
     { }

   template<typename _Vp, typename... _Args>
     constexpr
     _Storage(std::initializer_list<_Vp> __il, _Args&&... __args)
     : _M_value(__il, std::forward<_Args>(__args)...)
     { }


   template<typename _Fn, typename _Arg>
     constexpr
     _Storage(_Optional_func<_Fn> __f, _Arg&& __arg)
     : _M_value(std::__invoke(std::forward<_Fn>(__f._M_f),
         std::forward<_Arg>(__arg)))
     { }



   constexpr ~_Storage() { }

   _Empty_byte _M_empty;
   _Up _M_value;
 };

      _Storage<_Stored_type> _M_payload;

      bool _M_engaged = false;

      template<typename... _Args>
 constexpr void
 _M_construct(_Args&&... __args)
 noexcept(is_nothrow_constructible_v<_Stored_type, _Args...>)
 {
   std::_Construct(std::__addressof(this->_M_payload._M_value),
     std::forward<_Args>(__args)...);
   this->_M_engaged = true;
 }

      constexpr void
      _M_destroy() noexcept
      {
 _M_engaged = false;
 _M_payload._M_value.~_Stored_type();
      }


      template<typename _Fn, typename _Up>
 constexpr void
 _M_apply(_Optional_func<_Fn> __f, _Up&& __x)
 {
   std::construct_at(std::__addressof(this->_M_payload),
       __f, std::forward<_Up>(__x));
   _M_engaged = true;
 }






      constexpr _Tp&
      _M_get() noexcept
      { return this->_M_payload._M_value; }

      constexpr const _Tp&
      _M_get() const noexcept
      { return this->_M_payload._M_value; }


      constexpr void
      _M_reset() noexcept
      {
 if (this->_M_engaged)
   _M_destroy();
 else
   this->_M_engaged = false;
      }
    };


  template <typename _Tp,
     bool =
       is_trivially_destructible_v<_Tp>,
     bool =
       is_trivially_copy_assignable_v<_Tp>
       && is_trivially_copy_constructible_v<_Tp>,
     bool =
       is_trivially_move_assignable_v<_Tp>
       && is_trivially_move_constructible_v<_Tp>>
    struct _Optional_payload;


  template <typename _Tp>
    struct _Optional_payload<_Tp, true, true, true>
    : _Optional_payload_base<_Tp>
    {
      using _Optional_payload_base<_Tp>::_Optional_payload_base;

      _Optional_payload() = default;
    };


  template <typename _Tp>
    struct _Optional_payload<_Tp, true, false, true>
    : _Optional_payload_base<_Tp>
    {
      using _Optional_payload_base<_Tp>::_Optional_payload_base;

      _Optional_payload() = default;
      ~_Optional_payload() = default;
      _Optional_payload(const _Optional_payload&) = default;
      _Optional_payload(_Optional_payload&&) = default;
      _Optional_payload& operator=(_Optional_payload&&) = default;


      constexpr
      _Optional_payload&
      operator=(const _Optional_payload& __other)
      {
 this->_M_copy_assign(__other);
 return *this;
      }
    };


  template <typename _Tp>
    struct _Optional_payload<_Tp, true, true, false>
    : _Optional_payload_base<_Tp>
    {
      using _Optional_payload_base<_Tp>::_Optional_payload_base;

      _Optional_payload() = default;
      ~_Optional_payload() = default;
      _Optional_payload(const _Optional_payload&) = default;
      _Optional_payload(_Optional_payload&&) = default;
      _Optional_payload& operator=(const _Optional_payload&) = default;


      constexpr
      _Optional_payload&
      operator=(_Optional_payload&& __other)
      noexcept(__and_v<is_nothrow_move_constructible<_Tp>,
         is_nothrow_move_assignable<_Tp>>)
      {
 this->_M_move_assign(std::move(__other));
 return *this;
      }
    };


  template <typename _Tp>
    struct _Optional_payload<_Tp, true, false, false>
    : _Optional_payload_base<_Tp>
    {
      using _Optional_payload_base<_Tp>::_Optional_payload_base;

      _Optional_payload() = default;
      ~_Optional_payload() = default;
      _Optional_payload(const _Optional_payload&) = default;
      _Optional_payload(_Optional_payload&&) = default;


      constexpr
      _Optional_payload&
      operator=(const _Optional_payload& __other)
      {
 this->_M_copy_assign(__other);
 return *this;
      }


      constexpr
      _Optional_payload&
      operator=(_Optional_payload&& __other)
      noexcept(__and_v<is_nothrow_move_constructible<_Tp>,
         is_nothrow_move_assignable<_Tp>>)
      {
 this->_M_move_assign(std::move(__other));
 return *this;
      }
    };


  template <typename _Tp, bool _Copy, bool _Move>
    struct _Optional_payload<_Tp, false, _Copy, _Move>
    : _Optional_payload<_Tp, true, false, false>
    {

      using _Optional_payload<_Tp, true, false, false>::_Optional_payload;
      _Optional_payload() = default;
      _Optional_payload(const _Optional_payload&) = default;
      _Optional_payload(_Optional_payload&&) = default;
      _Optional_payload& operator=(const _Optional_payload&) = default;
      _Optional_payload& operator=(_Optional_payload&&) = default;


      constexpr ~_Optional_payload() { this->_M_reset(); }
    };



  template<typename _Tp, typename _Dp>
    class _Optional_base_impl
    {
    protected:
      using _Stored_type = remove_const_t<_Tp>;



      template<typename... _Args>
 constexpr void
 _M_construct(_Args&&... __args)
 noexcept(is_nothrow_constructible_v<_Stored_type, _Args...>)
 {
   static_cast<_Dp*>(this)->_M_payload._M_construct(
     std::forward<_Args>(__args)...);
 }

      constexpr void
      _M_destruct() noexcept
      { static_cast<_Dp*>(this)->_M_payload._M_destroy(); }


      constexpr void
      _M_reset() noexcept
      { static_cast<_Dp*>(this)->_M_payload._M_reset(); }

      constexpr bool _M_is_engaged() const noexcept
      { return static_cast<const _Dp*>(this)->_M_payload._M_engaged; }


      constexpr _Tp&
      _M_get() noexcept
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(this->_M_is_engaged()), false)) std::__glibcxx_assert_fail(); } while (false);
 return static_cast<_Dp*>(this)->_M_payload._M_get();
      }

      constexpr const _Tp&
      _M_get() const noexcept
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(this->_M_is_engaged()), false)) std::__glibcxx_assert_fail(); } while (false);
 return static_cast<const _Dp*>(this)->_M_payload._M_get();
      }
    };
# 505 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/optional" 3
  template<typename _Tp,
    bool = is_trivially_copy_constructible_v<_Tp>,
    bool = is_trivially_move_constructible_v<_Tp>>
    struct _Optional_base
    : _Optional_base_impl<_Tp, _Optional_base<_Tp>>
    {

      constexpr _Optional_base() = default;


      template<typename... _Args,
        enable_if_t<is_constructible_v<_Tp, _Args...>, bool> = false>
 constexpr explicit
 _Optional_base(in_place_t, _Args&&... __args)
 : _M_payload(in_place, std::forward<_Args>(__args)...)
 { }

      template<typename _Up, typename... _Args,
        enable_if_t<is_constructible_v<_Tp,
           initializer_list<_Up>&,
           _Args...>, bool> = false>
 constexpr explicit
 _Optional_base(in_place_t,
         initializer_list<_Up> __il,
         _Args&&... __args)
 : _M_payload(in_place, __il, std::forward<_Args>(__args)...)
 { }


      constexpr
      _Optional_base(const _Optional_base& __other)
      : _M_payload(__other._M_payload._M_engaged, __other._M_payload)
      { }

      constexpr
      _Optional_base(_Optional_base&& __other)
      noexcept(is_nothrow_move_constructible_v<_Tp>)
      : _M_payload(__other._M_payload._M_engaged,
     std::move(__other._M_payload))
      { }


      _Optional_base& operator=(const _Optional_base&) = default;
      _Optional_base& operator=(_Optional_base&&) = default;

      _Optional_payload<_Tp> _M_payload;
    };

  template<typename _Tp>
    struct _Optional_base<_Tp, false, true>
    : _Optional_base_impl<_Tp, _Optional_base<_Tp>>
    {

      constexpr _Optional_base() = default;


      template<typename... _Args,
        enable_if_t<is_constructible_v<_Tp, _Args...>, bool> = false>
 constexpr explicit
 _Optional_base(in_place_t, _Args&&... __args)
 : _M_payload(in_place, std::forward<_Args>(__args)...)
 { }

      template<typename _Up, typename... _Args,
        enable_if_t<is_constructible_v<_Tp,
           initializer_list<_Up>&,
           _Args...>, bool> = false>
 constexpr explicit
 _Optional_base(in_place_t,
         initializer_list<_Up> __il,
         _Args... __args)
 : _M_payload(in_place, __il, std::forward<_Args>(__args)...)
 { }


      constexpr _Optional_base(const _Optional_base& __other)
      : _M_payload(__other._M_payload._M_engaged, __other._M_payload)
      { }

      constexpr _Optional_base(_Optional_base&& __other) = default;


      _Optional_base& operator=(const _Optional_base&) = default;
      _Optional_base& operator=(_Optional_base&&) = default;

      _Optional_payload<_Tp> _M_payload;
    };

  template<typename _Tp>
    struct _Optional_base<_Tp, true, false>
    : _Optional_base_impl<_Tp, _Optional_base<_Tp>>
    {

      constexpr _Optional_base() = default;


      template<typename... _Args,
        enable_if_t<is_constructible_v<_Tp, _Args...>, bool> = false>
 constexpr explicit
 _Optional_base(in_place_t, _Args&&... __args)
 : _M_payload(in_place, std::forward<_Args>(__args)...)
 { }

      template<typename _Up, typename... _Args,
        enable_if_t<is_constructible_v<_Tp,
           initializer_list<_Up>&,
           _Args...>, bool> = false>
 constexpr explicit
 _Optional_base(in_place_t,
         initializer_list<_Up> __il,
         _Args&&... __args)
 : _M_payload(in_place, __il, std::forward<_Args>(__args)...)
 { }


      constexpr _Optional_base(const _Optional_base& __other) = default;

      constexpr
      _Optional_base(_Optional_base&& __other)
      noexcept(is_nothrow_move_constructible_v<_Tp>)
      : _M_payload(__other._M_payload._M_engaged,
     std::move(__other._M_payload))
      { }


      _Optional_base& operator=(const _Optional_base&) = default;
      _Optional_base& operator=(_Optional_base&&) = default;

      _Optional_payload<_Tp> _M_payload;
    };

  template<typename _Tp>
    struct _Optional_base<_Tp, true, true>
    : _Optional_base_impl<_Tp, _Optional_base<_Tp>>
    {

      constexpr _Optional_base() = default;


      template<typename... _Args,
        enable_if_t<is_constructible_v<_Tp, _Args...>, bool> = false>
 constexpr explicit
 _Optional_base(in_place_t, _Args&&... __args)
 : _M_payload(in_place, std::forward<_Args>(__args)...)
 { }

      template<typename _Up, typename... _Args,
        enable_if_t<is_constructible_v<_Tp,
           initializer_list<_Up>&,
           _Args...>, bool> = false>
 constexpr explicit
 _Optional_base(in_place_t,
         initializer_list<_Up> __il,
         _Args&&... __args)
 : _M_payload(in_place, __il, std::forward<_Args>(__args)...)
 { }


      constexpr _Optional_base(const _Optional_base& __other) = default;
      constexpr _Optional_base(_Optional_base&& __other) = default;


      _Optional_base& operator=(const _Optional_base&) = default;
      _Optional_base& operator=(_Optional_base&&) = default;

      _Optional_payload<_Tp> _M_payload;
    };

  template<typename _Tp>
  class optional;

  template<typename _Tp>
    inline constexpr bool __is_optional_v = false;
  template<typename _Tp>
    inline constexpr bool __is_optional_v<optional<_Tp>> = true;

  template<typename _Tp, typename _Up>
    using __converts_from_optional =
      __or_<is_constructible<_Tp, const optional<_Up>&>,
     is_constructible<_Tp, optional<_Up>&>,
     is_constructible<_Tp, const optional<_Up>&&>,
     is_constructible<_Tp, optional<_Up>&&>,
     is_convertible<const optional<_Up>&, _Tp>,
     is_convertible<optional<_Up>&, _Tp>,
     is_convertible<const optional<_Up>&&, _Tp>,
     is_convertible<optional<_Up>&&, _Tp>>;

  template<typename _Tp, typename _Up>
    using __assigns_from_optional =
      __or_<is_assignable<_Tp&, const optional<_Up>&>,
     is_assignable<_Tp&, optional<_Up>&>,
     is_assignable<_Tp&, const optional<_Up>&&>,
     is_assignable<_Tp&, optional<_Up>&&>>;




  template<typename _Tp>
    class optional
    : private _Optional_base<_Tp>,
      private _Enable_copy_move<

 is_copy_constructible_v<_Tp>,

 __and_v<is_copy_constructible<_Tp>, is_copy_assignable<_Tp>>,

 is_move_constructible_v<_Tp>,

 __and_v<is_move_constructible<_Tp>, is_move_assignable<_Tp>>,

 optional<_Tp>>
    {
      static_assert(!is_same_v<remove_cv_t<_Tp>, nullopt_t>);
      static_assert(!is_same_v<remove_cv_t<_Tp>, in_place_t>);
      static_assert(is_object_v<_Tp> && !is_array_v<_Tp>);

    private:
      using _Base = _Optional_base<_Tp>;


      template<typename _Up>
 using __not_self = __not_<is_same<optional, __remove_cvref_t<_Up>>>;
      template<typename _Up>
 using __not_tag = __not_<is_same<in_place_t, __remove_cvref_t<_Up>>>;
      template<typename... _Cond>
 using _Requires = enable_if_t<__and_v<_Cond...>, bool>;

    public:
      using value_type = _Tp;

      constexpr optional() noexcept { }

      constexpr optional(nullopt_t) noexcept { }


      template<typename _Up = _Tp,
        _Requires<__not_self<_Up>, __not_tag<_Up>,
    is_constructible<_Tp, _Up>,
    is_convertible<_Up, _Tp>> = true>
 constexpr
 optional(_Up&& __t)
 noexcept(is_nothrow_constructible_v<_Tp, _Up>)
 : _Base(std::in_place, std::forward<_Up>(__t)) { }

      template<typename _Up = _Tp,
        _Requires<__not_self<_Up>, __not_tag<_Up>,
    is_constructible<_Tp, _Up>,
    __not_<is_convertible<_Up, _Tp>>> = false>
 explicit constexpr
 optional(_Up&& __t)
 noexcept(is_nothrow_constructible_v<_Tp, _Up>)
 : _Base(std::in_place, std::forward<_Up>(__t)) { }

      template<typename _Up,
        _Requires<__not_<is_same<_Tp, _Up>>,
    is_constructible<_Tp, const _Up&>,
    is_convertible<const _Up&, _Tp>,
    __not_<__converts_from_optional<_Tp, _Up>>> = true>
 constexpr
 optional(const optional<_Up>& __t)
 noexcept(is_nothrow_constructible_v<_Tp, const _Up&>)
 {
   if (__t)
     emplace(*__t);
 }

      template<typename _Up,
        _Requires<__not_<is_same<_Tp, _Up>>,
    is_constructible<_Tp, const _Up&>,
    __not_<is_convertible<const _Up&, _Tp>>,
    __not_<__converts_from_optional<_Tp, _Up>>> = false>
 explicit constexpr
 optional(const optional<_Up>& __t)
 noexcept(is_nothrow_constructible_v<_Tp, const _Up&>)
 {
   if (__t)
     emplace(*__t);
 }

      template<typename _Up,
        _Requires<__not_<is_same<_Tp, _Up>>,
    is_constructible<_Tp, _Up>,
    is_convertible<_Up, _Tp>,
    __not_<__converts_from_optional<_Tp, _Up>>> = true>
 constexpr
 optional(optional<_Up>&& __t)
 noexcept(is_nothrow_constructible_v<_Tp, _Up>)
 {
   if (__t)
     emplace(std::move(*__t));
 }

      template<typename _Up,
        _Requires<__not_<is_same<_Tp, _Up>>,
    is_constructible<_Tp, _Up>,
    __not_<is_convertible<_Up, _Tp>>,
    __not_<__converts_from_optional<_Tp, _Up>>> = false>
 explicit constexpr
 optional(optional<_Up>&& __t)
 noexcept(is_nothrow_constructible_v<_Tp, _Up>)
 {
   if (__t)
     emplace(std::move(*__t));
 }

      template<typename... _Args,
        _Requires<is_constructible<_Tp, _Args...>> = false>
 explicit constexpr
 optional(in_place_t, _Args&&... __args)
 noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
 : _Base(std::in_place, std::forward<_Args>(__args)...) { }

      template<typename _Up, typename... _Args,
        _Requires<is_constructible<_Tp,
       initializer_list<_Up>&,
       _Args...>> = false>
 explicit constexpr
 optional(in_place_t, initializer_list<_Up> __il, _Args&&... __args)
 noexcept(is_nothrow_constructible_v<_Tp, initializer_list<_Up>&,
         _Args...>)
 : _Base(std::in_place, __il, std::forward<_Args>(__args)...) { }



      constexpr optional&
      operator=(nullopt_t) noexcept
      {
 this->_M_reset();
 return *this;
      }

      template<typename _Up = _Tp>
 constexpr
 enable_if_t<__and_v<__not_self<_Up>,
       __not_<__and_<is_scalar<_Tp>,
       is_same<_Tp, decay_t<_Up>>>>,
       is_constructible<_Tp, _Up>,
       is_assignable<_Tp&, _Up>>,
      optional&>
 operator=(_Up&& __u)
 noexcept(__and_v<is_nothrow_constructible<_Tp, _Up>,
    is_nothrow_assignable<_Tp&, _Up>>)
 {
   if (this->_M_is_engaged())
     this->_M_get() = std::forward<_Up>(__u);
   else
     this->_M_construct(std::forward<_Up>(__u));

   return *this;
 }

      template<typename _Up>
 constexpr
 enable_if_t<__and_v<__not_<is_same<_Tp, _Up>>,
       is_constructible<_Tp, const _Up&>,
       is_assignable<_Tp&, const _Up&>,
       __not_<__converts_from_optional<_Tp, _Up>>,
       __not_<__assigns_from_optional<_Tp, _Up>>>,
      optional&>
 operator=(const optional<_Up>& __u)
 noexcept(__and_v<is_nothrow_constructible<_Tp, const _Up&>,
    is_nothrow_assignable<_Tp&, const _Up&>>)
 {
   if (__u)
     {
       if (this->_M_is_engaged())
  this->_M_get() = *__u;
       else
  this->_M_construct(*__u);
     }
   else
     {
       this->_M_reset();
     }
   return *this;
 }

      template<typename _Up>
 constexpr
 enable_if_t<__and_v<__not_<is_same<_Tp, _Up>>,
       is_constructible<_Tp, _Up>,
       is_assignable<_Tp&, _Up>,
       __not_<__converts_from_optional<_Tp, _Up>>,
       __not_<__assigns_from_optional<_Tp, _Up>>>,
      optional&>
 operator=(optional<_Up>&& __u)
 noexcept(__and_v<is_nothrow_constructible<_Tp, _Up>,
    is_nothrow_assignable<_Tp&, _Up>>)
 {
   if (__u)
     {
       if (this->_M_is_engaged())
  this->_M_get() = std::move(*__u);
       else
  this->_M_construct(std::move(*__u));
     }
   else
     {
       this->_M_reset();
     }

   return *this;
 }

      template<typename... _Args>
 constexpr
 enable_if_t<is_constructible_v<_Tp, _Args...>, _Tp&>
 emplace(_Args&&... __args)
 noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
 {
   this->_M_reset();
   this->_M_construct(std::forward<_Args>(__args)...);
   return this->_M_get();
 }

      template<typename _Up, typename... _Args>
 constexpr
 enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>,
      _Tp&>
 emplace(initializer_list<_Up> __il, _Args&&... __args)
 noexcept(is_nothrow_constructible_v<_Tp, initializer_list<_Up>&,
         _Args...>)
 {
   this->_M_reset();
   this->_M_construct(__il, std::forward<_Args>(__args)...);
   return this->_M_get();
 }




      constexpr void
      swap(optional& __other)
      noexcept(is_nothrow_move_constructible_v<_Tp>
        && is_nothrow_swappable_v<_Tp>)
      {
 using std::swap;

 if (this->_M_is_engaged() && __other._M_is_engaged())
   swap(this->_M_get(), __other._M_get());
 else if (this->_M_is_engaged())
   {
     __other._M_construct(std::move(this->_M_get()));
     this->_M_destruct();
   }
 else if (__other._M_is_engaged())
   {
     this->_M_construct(std::move(__other._M_get()));
     __other._M_destruct();
   }
      }


      constexpr const _Tp*
      operator->() const noexcept
      { return std::__addressof(this->_M_get()); }

      constexpr _Tp*
      operator->() noexcept
      { return std::__addressof(this->_M_get()); }

      constexpr const _Tp&
      operator*() const& noexcept
      { return this->_M_get(); }

      constexpr _Tp&
      operator*()& noexcept
      { return this->_M_get(); }

      constexpr _Tp&&
      operator*()&& noexcept
      { return std::move(this->_M_get()); }

      constexpr const _Tp&&
      operator*() const&& noexcept
      { return std::move(this->_M_get()); }

      constexpr explicit operator bool() const noexcept
      { return this->_M_is_engaged(); }

      constexpr bool has_value() const noexcept
      { return this->_M_is_engaged(); }

      constexpr const _Tp&
      value() const&
      {
 if (this->_M_is_engaged())
   return this->_M_get();
 __throw_bad_optional_access();
      }

      constexpr _Tp&
      value()&
      {
 if (this->_M_is_engaged())
   return this->_M_get();
 __throw_bad_optional_access();
      }

      constexpr _Tp&&
      value()&&
      {
 if (this->_M_is_engaged())
   return std::move(this->_M_get());
 __throw_bad_optional_access();
      }

      constexpr const _Tp&&
      value() const&&
      {
 if (this->_M_is_engaged())
   return std::move(this->_M_get());
 __throw_bad_optional_access();
      }

      template<typename _Up>
 constexpr _Tp
 value_or(_Up&& __u) const&
 {
   static_assert(is_copy_constructible_v<_Tp>);
   static_assert(is_convertible_v<_Up&&, _Tp>);

   if (this->_M_is_engaged())
     return this->_M_get();
   else
     return static_cast<_Tp>(std::forward<_Up>(__u));
 }

      template<typename _Up>
 constexpr _Tp
 value_or(_Up&& __u) &&
 {
   static_assert(is_move_constructible_v<_Tp>);
   static_assert(is_convertible_v<_Up&&, _Tp>);

   if (this->_M_is_engaged())
     return std::move(this->_M_get());
   else
     return static_cast<_Tp>(std::forward<_Up>(__u));
 }




      template<typename _Fn>
 constexpr auto
 and_then(_Fn&& __f) &
 {
   using _Up = remove_cvref_t<invoke_result_t<_Fn, _Tp&>>;
   static_assert(__is_optional_v<remove_cvref_t<_Up>>,
   "the function passed to std::optional<T>::and_then "
   "must return a std::optional");
   if (has_value())
     return std::__invoke(std::forward<_Fn>(__f), **this);
   else
     return _Up();
 }

      template<typename _Fn>
 constexpr auto
 and_then(_Fn&& __f) const &
 {
   using _Up = remove_cvref_t<invoke_result_t<_Fn, const _Tp&>>;
   static_assert(__is_optional_v<_Up>,
   "the function passed to std::optional<T>::and_then "
   "must return a std::optional");
   if (has_value())
     return std::__invoke(std::forward<_Fn>(__f), **this);
   else
     return _Up();
 }

      template<typename _Fn>
 constexpr auto
 and_then(_Fn&& __f) &&
 {
   using _Up = remove_cvref_t<invoke_result_t<_Fn, _Tp>>;
   static_assert(__is_optional_v<remove_cvref_t<_Up>>,
   "the function passed to std::optional<T>::and_then "
   "must return a std::optional");
   if (has_value())
     return std::__invoke(std::forward<_Fn>(__f), std::move(**this));
   else
     return _Up();
 }

      template<typename _Fn>
 constexpr auto
 and_then(_Fn&& __f) const &&
 {
   using _Up = remove_cvref_t<invoke_result_t<_Fn, const _Tp>>;
   static_assert(__is_optional_v<remove_cvref_t<_Up>>,
   "the function passed to std::optional<T>::and_then "
   "must return a std::optional");
   if (has_value())
     return std::__invoke(std::forward<_Fn>(__f), std::move(**this));
   else
     return _Up();
 }

      template<typename _Fn>
 constexpr auto
 transform(_Fn&& __f) &
 {
   using _Up = remove_cv_t<invoke_result_t<_Fn, _Tp&>>;
   if (has_value())
     return optional<_Up>(_Optional_func<_Fn>{__f}, **this);
   else
     return optional<_Up>();
 }

      template<typename _Fn>
 constexpr auto
 transform(_Fn&& __f) const &
 {
   using _Up = remove_cv_t<invoke_result_t<_Fn, const _Tp&>>;
   if (has_value())
     return optional<_Up>(_Optional_func<_Fn>{__f}, **this);
   else
     return optional<_Up>();
 }

      template<typename _Fn>
 constexpr auto
 transform(_Fn&& __f) &&
 {
   using _Up = remove_cv_t<invoke_result_t<_Fn, _Tp>>;
   if (has_value())
     return optional<_Up>(_Optional_func<_Fn>{__f}, std::move(**this));
   else
     return optional<_Up>();
 }

      template<typename _Fn>
 constexpr auto
 transform(_Fn&& __f) const &&
 {
   using _Up = remove_cv_t<invoke_result_t<_Fn, const _Tp>>;
   if (has_value())
     return optional<_Up>(_Optional_func<_Fn>{__f}, std::move(**this));
   else
     return optional<_Up>();
 }

      template<typename _Fn> requires invocable<_Fn> && copy_constructible<_Tp>
 constexpr optional
 or_else(_Fn&& __f) const&
 {
   using _Up = invoke_result_t<_Fn>;
   static_assert(is_same_v<remove_cvref_t<_Up>, optional>,
   "the function passed to std::optional<T>::or_else "
   "must return a std::optional<T>");

   if (has_value())
     return *this;
   else
     return std::forward<_Fn>(__f)();
 }

      template<typename _Fn> requires invocable<_Fn> && move_constructible<_Tp>
 constexpr optional
 or_else(_Fn&& __f) &&
 {
   using _Up = invoke_result_t<_Fn>;
   static_assert(is_same_v<remove_cvref_t<_Up>, optional>,
   "the function passed to std::optional<T>::or_else "
   "must return a std::optional<T>");

   if (has_value())
     return std::move(*this);
   else
     return std::forward<_Fn>(__f)();
 }


      constexpr void reset() noexcept { this->_M_reset(); }

    private:

      template<typename _Up> friend class optional;

      template<typename _Fn, typename _Value>
 explicit constexpr
 optional(_Optional_func<_Fn> __f, _Value&& __v)
 {
   this->_M_payload._M_apply(__f, std::forward<_Value>(__v));
 }

    };

  template<typename _Tp>
    using __optional_relop_t =
      enable_if_t<is_convertible<_Tp, bool>::value, bool>;

  template<typename _Tp, typename _Up>
    using __optional_eq_t = __optional_relop_t<
      decltype(std::declval<const _Tp&>() == std::declval<const _Up&>())
      >;

  template<typename _Tp, typename _Up>
    using __optional_ne_t = __optional_relop_t<
      decltype(std::declval<const _Tp&>() != std::declval<const _Up&>())
      >;

  template<typename _Tp, typename _Up>
    using __optional_lt_t = __optional_relop_t<
      decltype(std::declval<const _Tp&>() < std::declval<const _Up&>())
      >;

  template<typename _Tp, typename _Up>
    using __optional_gt_t = __optional_relop_t<
      decltype(std::declval<const _Tp&>() > std::declval<const _Up&>())
      >;

  template<typename _Tp, typename _Up>
    using __optional_le_t = __optional_relop_t<
      decltype(std::declval<const _Tp&>() <= std::declval<const _Up&>())
      >;

  template<typename _Tp, typename _Up>
    using __optional_ge_t = __optional_relop_t<
      decltype(std::declval<const _Tp&>() >= std::declval<const _Up&>())
      >;


  template<typename _Tp, typename _Up>
    constexpr auto
    operator==(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
    -> __optional_eq_t<_Tp, _Up>
    {
      return static_cast<bool>(__lhs) == static_cast<bool>(__rhs)
      && (!__lhs || *__lhs == *__rhs);
    }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator!=(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
    -> __optional_ne_t<_Tp, _Up>
    {
      return static_cast<bool>(__lhs) != static_cast<bool>(__rhs)
 || (static_cast<bool>(__lhs) && *__lhs != *__rhs);
    }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator<(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
    -> __optional_lt_t<_Tp, _Up>
    {
      return static_cast<bool>(__rhs) && (!__lhs || *__lhs < *__rhs);
    }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator>(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
    -> __optional_gt_t<_Tp, _Up>
    {
      return static_cast<bool>(__lhs) && (!__rhs || *__lhs > *__rhs);
    }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator<=(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
    -> __optional_le_t<_Tp, _Up>
    {
      return !__lhs || (static_cast<bool>(__rhs) && *__lhs <= *__rhs);
    }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator>=(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
    -> __optional_ge_t<_Tp, _Up>
    {
      return !__rhs || (static_cast<bool>(__lhs) && *__lhs >= *__rhs);
    }


  template<typename _Tp, three_way_comparable_with<_Tp> _Up>
    constexpr compare_three_way_result_t<_Tp, _Up>
    operator<=>(const optional<_Tp>& __x, const optional<_Up>& __y)
    {
      return __x && __y ? *__x <=> *__y : bool(__x) <=> bool(__y);
    }



  template<typename _Tp>
    constexpr bool
    operator==(const optional<_Tp>& __lhs, nullopt_t) noexcept
    { return !__lhs; }


  template<typename _Tp>
    constexpr strong_ordering
    operator<=>(const optional<_Tp>& __x, nullopt_t) noexcept
    { return bool(__x) <=> false; }
# 1358 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/optional" 3
  template<typename _Tp, typename _Up>
    constexpr auto
    operator==(const optional<_Tp>& __lhs, const _Up& __rhs)
    -> __optional_eq_t<_Tp, _Up>
    { return __lhs && *__lhs == __rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator==(const _Up& __lhs, const optional<_Tp>& __rhs)
    -> __optional_eq_t<_Up, _Tp>
    { return __rhs && __lhs == *__rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator!=(const optional<_Tp>& __lhs, const _Up& __rhs)
    -> __optional_ne_t<_Tp, _Up>
    { return !__lhs || *__lhs != __rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator!=(const _Up& __lhs, const optional<_Tp>& __rhs)
    -> __optional_ne_t<_Up, _Tp>
    { return !__rhs || __lhs != *__rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator<(const optional<_Tp>& __lhs, const _Up& __rhs)
    -> __optional_lt_t<_Tp, _Up>
    { return !__lhs || *__lhs < __rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator<(const _Up& __lhs, const optional<_Tp>& __rhs)
    -> __optional_lt_t<_Up, _Tp>
    { return __rhs && __lhs < *__rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator>(const optional<_Tp>& __lhs, const _Up& __rhs)
    -> __optional_gt_t<_Tp, _Up>
    { return __lhs && *__lhs > __rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator>(const _Up& __lhs, const optional<_Tp>& __rhs)
    -> __optional_gt_t<_Up, _Tp>
    { return !__rhs || __lhs > *__rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator<=(const optional<_Tp>& __lhs, const _Up& __rhs)
    -> __optional_le_t<_Tp, _Up>
    { return !__lhs || *__lhs <= __rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator<=(const _Up& __lhs, const optional<_Tp>& __rhs)
    -> __optional_le_t<_Up, _Tp>
    { return __rhs && __lhs <= *__rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator>=(const optional<_Tp>& __lhs, const _Up& __rhs)
    -> __optional_ge_t<_Tp, _Up>
    { return __lhs && *__lhs >= __rhs; }

  template<typename _Tp, typename _Up>
    constexpr auto
    operator>=(const _Up& __lhs, const optional<_Tp>& __rhs)
    -> __optional_ge_t<_Up, _Tp>
    { return !__rhs || __lhs >= *__rhs; }


  template<typename _Tp, typename _Up>
    requires (!__is_optional_v<_Up>)
      && three_way_comparable_with<_Up, _Tp>
    constexpr compare_three_way_result_t<_Tp, _Up>
    operator<=>(const optional<_Tp>& __x, const _Up& __v)
    { return bool(__x) ? *__x <=> __v : strong_ordering::less; }






  template<typename _Tp>
    constexpr
    inline enable_if_t<is_move_constructible_v<_Tp> && is_swappable_v<_Tp>>
    swap(optional<_Tp>& __lhs, optional<_Tp>& __rhs)
    noexcept(noexcept(__lhs.swap(__rhs)))
    { __lhs.swap(__rhs); }

  template<typename _Tp>
    enable_if_t<!(is_move_constructible_v<_Tp> && is_swappable_v<_Tp>)>
    swap(optional<_Tp>&, optional<_Tp>&) = delete;

  template<typename _Tp>
    constexpr
    enable_if_t<is_constructible_v<decay_t<_Tp>, _Tp>,
  optional<decay_t<_Tp>>>
    make_optional(_Tp&& __t)
    noexcept(is_nothrow_constructible_v<optional<decay_t<_Tp>>, _Tp>)
    { return optional<decay_t<_Tp>>{ std::forward<_Tp>(__t) }; }

  template<typename _Tp, typename... _Args>
    constexpr
    enable_if_t<is_constructible_v<_Tp, _Args...>,
  optional<_Tp>>
    make_optional(_Args&&... __args)
    noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
    { return optional<_Tp>{ in_place, std::forward<_Args>(__args)... }; }

  template<typename _Tp, typename _Up, typename... _Args>
    constexpr
    enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>,
  optional<_Tp>>
    make_optional(initializer_list<_Up> __il, _Args&&... __args)
    noexcept(is_nothrow_constructible_v<_Tp, initializer_list<_Up>&, _Args...>)
    { return optional<_Tp>{ in_place, __il, std::forward<_Args>(__args)... }; }



  template<typename _Tp, typename _Up = remove_const_t<_Tp>,
    bool = __poison_hash<_Up>::__enable_hash_call>
    struct __optional_hash_call_base
    {
      size_t
      operator()(const optional<_Tp>& __t) const
      noexcept(noexcept(hash<_Up>{}(*__t)))
      {


 constexpr size_t __magic_disengaged_hash = static_cast<size_t>(-3333);
 return __t ? hash<_Up>{}(*__t) : __magic_disengaged_hash;
      }
    };

  template<typename _Tp, typename _Up>
    struct __optional_hash_call_base<_Tp, _Up, false> {};

  template<typename _Tp>
    struct hash<optional<_Tp>>
    : private __poison_hash<remove_const_t<_Tp>>,
      public __optional_hash_call_base<_Tp>
    {
      using result_type [[__deprecated__]] = size_t;
      using argument_type [[__deprecated__]] = optional<_Tp>;
    };

  template<typename _Tp>
    struct __is_fast_hash<hash<optional<_Tp>>> : __is_fast_hash<hash<_Tp>>
    { };




  template <typename _Tp> optional(_Tp) -> optional<_Tp>;



}
# 49 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/format" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/span" 1 3
# 38 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/span" 3


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 41 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/span" 2 3






namespace std __attribute__ ((__visibility__ ("default")))
{


  inline constexpr size_t dynamic_extent = static_cast<size_t>(-1);

  template<typename _Type, size_t _Extent>
    class span;

  namespace __detail
  {
    template<typename _Tp>
      inline constexpr bool __is_span = false;

    template<typename _Tp, size_t _Num>
      inline constexpr bool __is_span<span<_Tp, _Num>> = true;

    template<typename _Tp>
      inline constexpr bool __is_std_array = false;

    template<typename _Tp, size_t _Num>
      inline constexpr bool __is_std_array<std::array<_Tp, _Num>> = true;

    template<size_t _Extent>
      class __extent_storage
      {
      public:
 constexpr
 __extent_storage(size_t) noexcept
 { }

 static constexpr size_t
 _M_extent() noexcept
 { return _Extent; }
      };

    template<>
      class __extent_storage<dynamic_extent>
      {
      public:
 constexpr
 __extent_storage(size_t __extent) noexcept
 : _M_extent_value(__extent)
 { }

 constexpr size_t
 _M_extent() const noexcept
 { return this->_M_extent_value; }

      private:
 size_t _M_extent_value;
      };
  }

  template<typename _Type, size_t _Extent = dynamic_extent>
    class span
    {
      template<size_t _Offset, size_t _Count>
 static constexpr size_t
 _S_subspan_extent()
 {
   if constexpr (_Count != dynamic_extent)
     return _Count;
   else if constexpr (extent != dynamic_extent)
     return _Extent - _Offset;
   else
     return dynamic_extent;
 }



      template<typename _Tp, size_t _ArrayExtent>
 requires (_Extent == dynamic_extent || _ArrayExtent == _Extent)
 using __is_compatible_array = __is_array_convertible<_Type, _Tp>;

      template<typename _Ref>
 using __is_compatible_ref
   = __is_array_convertible<_Type, remove_reference_t<_Ref>>;

    public:

      using element_type = _Type;
      using value_type = remove_cv_t<_Type>;
      using size_type = size_t;
      using difference_type = ptrdiff_t;
      using pointer = _Type*;
      using const_pointer = const _Type*;
      using reference = element_type&;
      using const_reference = const element_type&;
      using iterator = __gnu_cxx::__normal_iterator<pointer, span>;
      using reverse_iterator = std::reverse_iterator<iterator>;

      using const_iterator = std::const_iterator<iterator>;
      using const_reverse_iterator = std::const_iterator<reverse_iterator>;



      static constexpr size_t extent = _Extent;



      constexpr
      span() noexcept
      requires (_Extent == dynamic_extent || _Extent == 0)
      : _M_ptr(nullptr), _M_extent(0)
      { }

      template<contiguous_iterator _It>
 requires __is_compatible_ref<iter_reference_t<_It>>::value
 constexpr explicit(extent != dynamic_extent)
 span(_It __first, size_type __count)
 noexcept
 : _M_ptr(std::to_address(__first)), _M_extent(__count)
 {
   if constexpr (_Extent != dynamic_extent)
     {
       do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__count == _Extent), false)) std::__glibcxx_assert_fail(); } while (false);
     }
                                                             ;
 }

      template<contiguous_iterator _It, sized_sentinel_for<_It> _End>
 requires __is_compatible_ref<iter_reference_t<_It>>::value
   && (!is_convertible_v<_End, size_type>)
 constexpr explicit(extent != dynamic_extent)
 span(_It __first, _End __last)
 noexcept(noexcept(__last - __first))
 : _M_ptr(std::to_address(__first)),
   _M_extent(static_cast<size_type>(__last - __first))
 {
   if constexpr (_Extent != dynamic_extent)
     {
       do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool((__last - __first) == _Extent), false)) std::__glibcxx_assert_fail(); } while (false);
     }
                                                  ;
 }

      template<size_t _ArrayExtent>
 requires (_Extent == dynamic_extent || _ArrayExtent == _Extent)
 constexpr
 span(type_identity_t<element_type> (&__arr)[_ArrayExtent]) noexcept
 : span(static_cast<pointer>(__arr), _ArrayExtent)
 { }

      template<typename _Tp, size_t _ArrayExtent>
 requires __is_compatible_array<_Tp, _ArrayExtent>::value
 constexpr
 span(array<_Tp, _ArrayExtent>& __arr) noexcept
 : span(static_cast<pointer>(__arr.data()), _ArrayExtent)
 { }

      template<typename _Tp, size_t _ArrayExtent>
 requires __is_compatible_array<const _Tp, _ArrayExtent>::value
 constexpr
 span(const array<_Tp, _ArrayExtent>& __arr) noexcept
 : span(static_cast<pointer>(__arr.data()), _ArrayExtent)
 { }

      template<typename _Range>
 requires (!__detail::__is_span<remove_cvref_t<_Range>>)
   && (!__detail::__is_std_array<remove_cvref_t<_Range>>)
   && (!is_array_v<remove_cvref_t<_Range>>)
   && ranges::contiguous_range<_Range> && ranges::sized_range<_Range>
   && (ranges::borrowed_range<_Range> || is_const_v<element_type>)
   && __is_compatible_ref<ranges::range_reference_t<_Range>>::value
 constexpr explicit(extent != dynamic_extent)
 span(_Range&& __range)
 noexcept(noexcept(ranges::data(__range))
    && noexcept(ranges::size(__range)))
 : span(ranges::data(__range), ranges::size(__range))
 {
   if constexpr (extent != dynamic_extent)
     {
       do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(ranges::size(__range) == extent), false)) std::__glibcxx_assert_fail(); } while (false);
     }
 }

      constexpr
      span(const span&) noexcept = default;

      template<typename _OType, size_t _OExtent>
 requires (_Extent == dynamic_extent || _OExtent == dynamic_extent
    || _Extent == _OExtent)
   && (__is_array_convertible<_Type, _OType>::value)
 constexpr
 explicit(extent != dynamic_extent && _OExtent == dynamic_extent)
 span(const span<_OType, _OExtent>& __s) noexcept
 : _M_extent(__s.size()), _M_ptr(__s.data())
 {
   if constexpr (extent != dynamic_extent)
     {
       do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__s.size() == extent), false)) std::__glibcxx_assert_fail(); } while (false);
     }
 }

      ~span() noexcept = default;

      constexpr span&
      operator=(const span&) noexcept = default;



      [[nodiscard]]
      constexpr size_type
      size() const noexcept
      { return this->_M_extent._M_extent(); }

      [[nodiscard]]
      constexpr size_type
      size_bytes() const noexcept
      { return this->_M_extent._M_extent() * sizeof(element_type); }

      [[nodiscard]]
      constexpr bool
      empty() const noexcept
      { return size() == 0; }



      [[nodiscard]]
      constexpr reference
      front() const noexcept
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(!empty()), false)) std::__glibcxx_assert_fail(); } while (false);
 return *this->_M_ptr;
      }

      [[nodiscard]]
      constexpr reference
      back() const noexcept
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(!empty()), false)) std::__glibcxx_assert_fail(); } while (false);
 return *(this->_M_ptr + (size() - 1));
      }

      [[nodiscard]]
      constexpr reference
      operator[](size_type __idx) const noexcept
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__idx < size()), false)) std::__glibcxx_assert_fail(); } while (false);
 return *(this->_M_ptr + __idx);
      }
# 302 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/span" 3
      [[nodiscard]]
      constexpr pointer
      data() const noexcept
      { return this->_M_ptr; }



      [[nodiscard]]
      constexpr iterator
      begin() const noexcept
      { return iterator(this->_M_ptr); }

      [[nodiscard]]
      constexpr iterator
      end() const noexcept
      { return iterator(this->_M_ptr + this->size()); }

      [[nodiscard]]
      constexpr reverse_iterator
      rbegin() const noexcept
      { return reverse_iterator(this->end()); }

      [[nodiscard]]
      constexpr reverse_iterator
      rend() const noexcept
      { return reverse_iterator(this->begin()); }


      [[nodiscard]]
      constexpr const_iterator
      cbegin() const noexcept
      { return begin(); }

      [[nodiscard]]
      constexpr const_iterator
      cend() const noexcept
      { return end(); }

      [[nodiscard]]
      constexpr const_reverse_iterator
      crbegin() const noexcept
      { return rbegin(); }

      [[nodiscard]]
      constexpr const_reverse_iterator
      crend() const noexcept
      { return rend(); }




      template<size_t _Count>
 [[nodiscard]]
 constexpr span<element_type, _Count>
 first() const noexcept
 {
   if constexpr (_Extent == dynamic_extent)
     do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(_Count <= size()), false)) std::__glibcxx_assert_fail(); } while (false);
   else
     static_assert(_Count <= extent);
   using _Sp = span<element_type, _Count>;
   return _Sp{ this->data(), _Count };
 }

      [[nodiscard]]
      constexpr span<element_type, dynamic_extent>
      first(size_type __count) const noexcept
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__count <= size()), false)) std::__glibcxx_assert_fail(); } while (false);
 return { this->data(), __count };
      }

      template<size_t _Count>
 [[nodiscard]]
 constexpr span<element_type, _Count>
 last() const noexcept
 {
   if constexpr (_Extent == dynamic_extent)
     do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(_Count <= size()), false)) std::__glibcxx_assert_fail(); } while (false);
   else
     static_assert(_Count <= extent);
   using _Sp = span<element_type, _Count>;
   return _Sp{ this->data() + (this->size() - _Count), _Count };
 }

      [[nodiscard]]
      constexpr span<element_type, dynamic_extent>
      last(size_type __count) const noexcept
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__count <= size()), false)) std::__glibcxx_assert_fail(); } while (false);
 return { this->data() + (this->size() - __count), __count };
      }

      template<size_t _Offset, size_t _Count = dynamic_extent>
 [[nodiscard]]
 constexpr auto
 subspan() const noexcept
 -> span<element_type, _S_subspan_extent<_Offset, _Count>()>
 {
   if constexpr (_Extent == dynamic_extent)
     {
       do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(_Offset <= size()), false)) std::__glibcxx_assert_fail(); } while (false);
     }
   else
     static_assert(_Offset <= extent);

   using _Sp = span<element_type, _S_subspan_extent<_Offset, _Count>()>;

   if constexpr (_Count == dynamic_extent)
     return _Sp{ this->data() + _Offset, this->size() - _Offset };
   else
     {
       if constexpr (_Extent == dynamic_extent)
  {
    do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(_Count <= size()), false)) std::__glibcxx_assert_fail(); } while (false);
    do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(_Count <= (size() - _Offset)), false)) std::__glibcxx_assert_fail(); } while (false);
  }
       else
  {
    static_assert(_Count <= extent);
    static_assert(_Count <= (extent - _Offset));
  }
       return _Sp{ this->data() + _Offset, _Count };
     }
 }

      [[nodiscard]]
      constexpr span<element_type, dynamic_extent>
      subspan(size_type __offset, size_type __count = dynamic_extent) const
      noexcept
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__offset <= size()), false)) std::__glibcxx_assert_fail(); } while (false);
 if (__count == dynamic_extent)
   __count = this->size() - __offset;
 else
   {
     do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__count <= size()), false)) std::__glibcxx_assert_fail(); } while (false);
     do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__offset + __count <= size()), false)) std::__glibcxx_assert_fail(); } while (false);
   }
 return {this->data() + __offset, __count};
      }

    private:
      pointer _M_ptr;
      [[no_unique_address]] __detail::__extent_storage<extent> _M_extent;
    };



  template<typename _Type, size_t _ArrayExtent>
    span(_Type(&)[_ArrayExtent]) -> span<_Type, _ArrayExtent>;

  template<typename _Type, size_t _ArrayExtent>
    span(array<_Type, _ArrayExtent>&) -> span<_Type, _ArrayExtent>;

  template<typename _Type, size_t _ArrayExtent>
    span(const array<_Type, _ArrayExtent>&)
      -> span<const _Type, _ArrayExtent>;

  template<contiguous_iterator _Iter, typename _End>
    span(_Iter, _End)
      -> span<remove_reference_t<iter_reference_t<_Iter>>>;

  template<ranges::contiguous_range _Range>
    span(_Range &&)
      -> span<remove_reference_t<ranges::range_reference_t<_Range&>>>;

  template<typename _Type, size_t _Extent>
    [[nodiscard]]
    inline
    span<const byte, _Extent == dynamic_extent
 ? dynamic_extent : _Extent * sizeof(_Type)>
    as_bytes(span<_Type, _Extent> __sp) noexcept
    {
      auto data = reinterpret_cast<const byte*>(__sp.data());
      auto size = __sp.size_bytes();
      constexpr auto extent = _Extent == dynamic_extent
 ? dynamic_extent : _Extent * sizeof(_Type);
      return span<const byte, extent>{data, size};
    }

  template<typename _Type, size_t _Extent>
    requires (!is_const_v<_Type>)
    inline
    span<byte, _Extent == dynamic_extent
       ? dynamic_extent : _Extent * sizeof(_Type)>
    as_writable_bytes [[nodiscard]] (span<_Type, _Extent> __sp) noexcept
    {
      auto data = reinterpret_cast<byte*>(__sp.data());
      auto size = __sp.size_bytes();
      constexpr auto extent = _Extent == dynamic_extent
 ? dynamic_extent : _Extent * sizeof(_Type);
      return span<byte, extent>{data, size};
    }

  namespace ranges
  {

    template<typename _ElementType, size_t _Extent>
      inline constexpr bool
 enable_borrowed_range<span<_ElementType, _Extent>> = true;


    template<typename _ElementType, size_t _Extent>
      inline constexpr bool
 enable_view<span<_ElementType, _Extent>> = true;
  }

}
# 50 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/format" 2 3





# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ranges_algobase.h" 1 3
# 43 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ranges_algobase.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

namespace ranges
{
  namespace __detail
  {
    template<typename _Tp>
      constexpr inline bool __is_normal_iterator = false;

    template<typename _Iterator, typename _Container>
      constexpr inline bool
 __is_normal_iterator<__gnu_cxx::__normal_iterator<_Iterator,
         _Container>> = true;

    template<typename _Tp>
      constexpr inline bool __is_reverse_iterator = false;

    template<typename _Iterator>
      constexpr inline bool
 __is_reverse_iterator<reverse_iterator<_Iterator>> = true;

    template<typename _Tp>
      constexpr inline bool __is_move_iterator = false;

    template<typename _Iterator>
      constexpr inline bool
 __is_move_iterator<move_iterator<_Iterator>> = true;
  }

  struct __equal_fn
  {
    template<input_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
      input_iterator _Iter2, sentinel_for<_Iter2> _Sent2,
      typename _Pred = ranges::equal_to,
      typename _Proj1 = identity, typename _Proj2 = identity>
      requires indirectly_comparable<_Iter1, _Iter2, _Pred, _Proj1, _Proj2>
      constexpr bool
      operator()(_Iter1 __first1, _Sent1 __last1,
   _Iter2 __first2, _Sent2 __last2, _Pred __pred = {},
   _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
      {


 if constexpr (__detail::__is_normal_iterator<_Iter1>
        && same_as<_Iter1, _Sent1>)
   return (*this)(__first1.base(), __last1.base(),
    std::move(__first2), std::move(__last2),
    std::move(__pred),
    std::move(__proj1), std::move(__proj2));
 else if constexpr (__detail::__is_normal_iterator<_Iter2>
      && same_as<_Iter2, _Sent2>)
   return (*this)(std::move(__first1), std::move(__last1),
    __first2.base(), __last2.base(),
    std::move(__pred),
    std::move(__proj1), std::move(__proj2));
 else if constexpr (sized_sentinel_for<_Sent1, _Iter1>
      && sized_sentinel_for<_Sent2, _Iter2>)
   {
     auto __d1 = ranges::distance(__first1, __last1);
     auto __d2 = ranges::distance(__first2, __last2);
     if (__d1 != __d2)
       return false;

     using _ValueType1 = iter_value_t<_Iter1>;
     constexpr bool __use_memcmp
       = ((is_integral_v<_ValueType1> || is_pointer_v<_ValueType1>)
   && __memcmpable<_Iter1, _Iter2>::__value
   && is_same_v<_Pred, ranges::equal_to>
   && is_same_v<_Proj1, identity>
   && is_same_v<_Proj2, identity>);
     if constexpr (__use_memcmp)
       {
  if (const size_t __len = (__last1 - __first1))
    return !std::__memcmp(__first1, __first2, __len);
  return true;
       }
     else
       {
  for (; __first1 != __last1; ++__first1, (void)++__first2)
    if (!(bool)std::__invoke(__pred,
        std::__invoke(__proj1, *__first1),
        std::__invoke(__proj2, *__first2)))
      return false;
  return true;
       }
   }
 else
   {
     for (; __first1 != __last1 && __first2 != __last2;
   ++__first1, (void)++__first2)
       if (!(bool)std::__invoke(__pred,
           std::__invoke(__proj1, *__first1),
           std::__invoke(__proj2, *__first2)))
  return false;
     return __first1 == __last1 && __first2 == __last2;
   }
      }

    template<input_range _Range1, input_range _Range2,
      typename _Pred = ranges::equal_to,
      typename _Proj1 = identity, typename _Proj2 = identity>
      requires indirectly_comparable<iterator_t<_Range1>, iterator_t<_Range2>,
         _Pred, _Proj1, _Proj2>
      constexpr bool
      operator()(_Range1&& __r1, _Range2&& __r2, _Pred __pred = {},
   _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
      {
 return (*this)(ranges::begin(__r1), ranges::end(__r1),
         ranges::begin(__r2), ranges::end(__r2),
         std::move(__pred),
         std::move(__proj1), std::move(__proj2));
      }
  };

  inline constexpr __equal_fn equal{};

  template<typename _Iter, typename _Out>
    struct in_out_result
    {
      [[no_unique_address]] _Iter in;
      [[no_unique_address]] _Out out;

      template<typename _Iter2, typename _Out2>
 requires convertible_to<const _Iter&, _Iter2>
   && convertible_to<const _Out&, _Out2>
 constexpr
 operator in_out_result<_Iter2, _Out2>() const &
 { return {in, out}; }

      template<typename _Iter2, typename _Out2>
 requires convertible_to<_Iter, _Iter2>
   && convertible_to<_Out, _Out2>
 constexpr
 operator in_out_result<_Iter2, _Out2>() &&
 { return {std::move(in), std::move(out)}; }
    };

  template<typename _Iter, typename _Out>
    using copy_result = in_out_result<_Iter, _Out>;

  template<typename _Iter, typename _Out>
    using move_result = in_out_result<_Iter, _Out>;

  template<typename _Iter1, typename _Iter2>
    using move_backward_result = in_out_result<_Iter1, _Iter2>;

  template<typename _Iter1, typename _Iter2>
    using copy_backward_result = in_out_result<_Iter1, _Iter2>;

  template<bool _IsMove,
    bidirectional_iterator _Iter, sentinel_for<_Iter> _Sent,
    bidirectional_iterator _Out>
    requires (_IsMove
       ? indirectly_movable<_Iter, _Out>
       : indirectly_copyable<_Iter, _Out>)
    constexpr __conditional_t<_IsMove,
         move_backward_result<_Iter, _Out>,
         copy_backward_result<_Iter, _Out>>
    __copy_or_move_backward(_Iter __first, _Sent __last, _Out __result);

  template<bool _IsMove,
    input_iterator _Iter, sentinel_for<_Iter> _Sent,
    weakly_incrementable _Out>
    requires (_IsMove
       ? indirectly_movable<_Iter, _Out>
       : indirectly_copyable<_Iter, _Out>)
    constexpr __conditional_t<_IsMove,
         move_result<_Iter, _Out>,
         copy_result<_Iter, _Out>>
    __copy_or_move(_Iter __first, _Sent __last, _Out __result)
    {


      using __detail::__is_move_iterator;
      using __detail::__is_reverse_iterator;
      using __detail::__is_normal_iterator;
      if constexpr (__is_move_iterator<_Iter> && same_as<_Iter, _Sent>)
 {
   auto [__in, __out]
     = ranges::__copy_or_move<true>(std::move(__first).base(),
        std::move(__last).base(),
        std::move(__result));
   return {move_iterator{std::move(__in)}, std::move(__out)};
 }
      else if constexpr (__is_reverse_iterator<_Iter> && same_as<_Iter, _Sent>
    && __is_reverse_iterator<_Out>)
 {
   auto [__in,__out]
     = ranges::__copy_or_move_backward<_IsMove>(std::move(__last).base(),
             std::move(__first).base(),
             std::move(__result).base());
   return {reverse_iterator{std::move(__in)},
    reverse_iterator{std::move(__out)}};
 }
      else if constexpr (__is_normal_iterator<_Iter> && same_as<_Iter, _Sent>)
 {
   auto [__in,__out]
     = ranges::__copy_or_move<_IsMove>(__first.base(), __last.base(),
           std::move(__result));
   return {decltype(__first){__in}, std::move(__out)};
 }
      else if constexpr (__is_normal_iterator<_Out>)
 {
   auto [__in,__out]
     = ranges::__copy_or_move<_IsMove>(std::move(__first), __last, __result.base());
   return {std::move(__in), decltype(__result){__out}};
 }
      else if constexpr (sized_sentinel_for<_Sent, _Iter>)
 {
   if (!std::__is_constant_evaluated())
     {
       if constexpr (__memcpyable<_Iter, _Out>::__value)
  {
    using _ValueTypeI = iter_value_t<_Iter>;
    static_assert(_IsMove
        ? is_move_assignable_v<_ValueTypeI>
        : is_copy_assignable_v<_ValueTypeI>);
    auto __num = __last - __first;
    if (__num)
      __builtin_memmove(__result, __first,
   sizeof(_ValueTypeI) * __num);
    return {__first + __num, __result + __num};
  }
     }

   for (auto __n = __last - __first; __n > 0; --__n)
     {
       if constexpr (_IsMove)
  *__result = std::move(*__first);
       else
  *__result = *__first;
       ++__first;
       ++__result;
     }
   return {std::move(__first), std::move(__result)};
 }
      else
 {
   while (__first != __last)
     {
       if constexpr (_IsMove)
  *__result = std::move(*__first);
       else
  *__result = *__first;
       ++__first;
       ++__result;
     }
   return {std::move(__first), std::move(__result)};
 }
    }

  struct __copy_fn
  {
    template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
      weakly_incrementable _Out>
      requires indirectly_copyable<_Iter, _Out>
      constexpr copy_result<_Iter, _Out>
      operator()(_Iter __first, _Sent __last, _Out __result) const
      {
 return ranges::__copy_or_move<false>(std::move(__first),
          std::move(__last),
          std::move(__result));
      }

    template<input_range _Range, weakly_incrementable _Out>
      requires indirectly_copyable<iterator_t<_Range>, _Out>
      constexpr copy_result<borrowed_iterator_t<_Range>, _Out>
      operator()(_Range&& __r, _Out __result) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__result));
      }
  };

  inline constexpr __copy_fn copy{};

  struct __move_fn
  {
    template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
      weakly_incrementable _Out>
      requires indirectly_movable<_Iter, _Out>
      constexpr move_result<_Iter, _Out>
      operator()(_Iter __first, _Sent __last, _Out __result) const
      {
 return ranges::__copy_or_move<true>(std::move(__first),
         std::move(__last),
         std::move(__result));
      }

    template<input_range _Range, weakly_incrementable _Out>
      requires indirectly_movable<iterator_t<_Range>, _Out>
      constexpr move_result<borrowed_iterator_t<_Range>, _Out>
      operator()(_Range&& __r, _Out __result) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__result));
      }
  };

  inline constexpr __move_fn move{};

  template<bool _IsMove,
    bidirectional_iterator _Iter, sentinel_for<_Iter> _Sent,
    bidirectional_iterator _Out>
    requires (_IsMove
       ? indirectly_movable<_Iter, _Out>
       : indirectly_copyable<_Iter, _Out>)
    constexpr __conditional_t<_IsMove,
         move_backward_result<_Iter, _Out>,
         copy_backward_result<_Iter, _Out>>
    __copy_or_move_backward(_Iter __first, _Sent __last, _Out __result)
    {


      using __detail::__is_reverse_iterator;
      using __detail::__is_normal_iterator;
      if constexpr (__is_reverse_iterator<_Iter> && same_as<_Iter, _Sent>
      && __is_reverse_iterator<_Out>)
 {
   auto [__in,__out]
     = ranges::__copy_or_move<_IsMove>(std::move(__last).base(),
           std::move(__first).base(),
           std::move(__result).base());
   return {reverse_iterator{std::move(__in)},
    reverse_iterator{std::move(__out)}};
 }
      else if constexpr (__is_normal_iterator<_Iter> && same_as<_Iter, _Sent>)
 {
   auto [__in,__out]
     = ranges::__copy_or_move_backward<_IsMove>(__first.base(),
             __last.base(),
             std::move(__result));
   return {decltype(__first){__in}, std::move(__out)};
 }
      else if constexpr (__is_normal_iterator<_Out>)
 {
   auto [__in,__out]
     = ranges::__copy_or_move_backward<_IsMove>(std::move(__first),
             std::move(__last),
             __result.base());
   return {std::move(__in), decltype(__result){__out}};
 }
      else if constexpr (sized_sentinel_for<_Sent, _Iter>)
 {
   if (!std::__is_constant_evaluated())
     {
       if constexpr (__memcpyable<_Out, _Iter>::__value)
  {
    using _ValueTypeI = iter_value_t<_Iter>;
    static_assert(_IsMove
        ? is_move_assignable_v<_ValueTypeI>
        : is_copy_assignable_v<_ValueTypeI>);
    auto __num = __last - __first;
    if (__num)
      __builtin_memmove(__result - __num, __first,
          sizeof(_ValueTypeI) * __num);
    return {__first + __num, __result - __num};
  }
     }

   auto __lasti = ranges::next(__first, __last);
   auto __tail = __lasti;

   for (auto __n = __last - __first; __n > 0; --__n)
     {
       --__tail;
       --__result;
       if constexpr (_IsMove)
  *__result = std::move(*__tail);
       else
  *__result = *__tail;
     }
   return {std::move(__lasti), std::move(__result)};
 }
      else
 {
   auto __lasti = ranges::next(__first, __last);
   auto __tail = __lasti;

   while (__first != __tail)
     {
       --__tail;
       --__result;
       if constexpr (_IsMove)
  *__result = std::move(*__tail);
       else
  *__result = *__tail;
     }
   return {std::move(__lasti), std::move(__result)};
 }
    }

  struct __copy_backward_fn
  {
    template<bidirectional_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
      bidirectional_iterator _Iter2>
      requires indirectly_copyable<_Iter1, _Iter2>
      constexpr copy_backward_result<_Iter1, _Iter2>
      operator()(_Iter1 __first, _Sent1 __last, _Iter2 __result) const
      {
 return ranges::__copy_or_move_backward<false>(std::move(__first),
            std::move(__last),
            std::move(__result));
      }

    template<bidirectional_range _Range, bidirectional_iterator _Iter>
      requires indirectly_copyable<iterator_t<_Range>, _Iter>
      constexpr copy_backward_result<borrowed_iterator_t<_Range>, _Iter>
      operator()(_Range&& __r, _Iter __result) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__result));
      }
  };

  inline constexpr __copy_backward_fn copy_backward{};

  struct __move_backward_fn
  {
    template<bidirectional_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
      bidirectional_iterator _Iter2>
      requires indirectly_movable<_Iter1, _Iter2>
      constexpr move_backward_result<_Iter1, _Iter2>
      operator()(_Iter1 __first, _Sent1 __last, _Iter2 __result) const
      {
 return ranges::__copy_or_move_backward<true>(std::move(__first),
           std::move(__last),
           std::move(__result));
      }

    template<bidirectional_range _Range, bidirectional_iterator _Iter>
      requires indirectly_movable<iterator_t<_Range>, _Iter>
      constexpr move_backward_result<borrowed_iterator_t<_Range>, _Iter>
      operator()(_Range&& __r, _Iter __result) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__result));
      }
  };

  inline constexpr __move_backward_fn move_backward{};

  template<typename _Iter, typename _Out>
    using copy_n_result = in_out_result<_Iter, _Out>;

  struct __copy_n_fn
  {
    template<input_iterator _Iter, weakly_incrementable _Out>
      requires indirectly_copyable<_Iter, _Out>
      constexpr copy_n_result<_Iter, _Out>
      operator()(_Iter __first, iter_difference_t<_Iter> __n,
   _Out __result) const
      {
 if constexpr (random_access_iterator<_Iter>)
   {
     if (__n > 0)
       return ranges::copy(__first, __first + __n, std::move(__result));
   }
 else
   {
     for (; __n > 0; --__n, (void)++__result, (void)++__first)
       *__result = *__first;
   }
 return {std::move(__first), std::move(__result)};
      }
  };

  inline constexpr __copy_n_fn copy_n{};

  struct __fill_n_fn
  {
    template<typename _Tp, output_iterator<const _Tp&> _Out>
      constexpr _Out
      operator()(_Out __first, iter_difference_t<_Out> __n,
   const _Tp& __value) const
      {


 if (__n <= 0)
   return __first;

 if constexpr (is_scalar_v<_Tp>)
   {

     if constexpr (is_pointer_v<_Out>

     && __is_byte<remove_pointer_t<_Out>>::__value
     && integral<_Tp>)
       {
  if (!std::__is_constant_evaluated())
    {
      __builtin_memset(__first,
         static_cast<unsigned char>(__value),
         __n);
      return __first + __n;
    }
       }

     const auto __tmp = __value;
     for (; __n > 0; --__n, (void)++__first)
       *__first = __tmp;
     return __first;
   }
 else
   {
     for (; __n > 0; --__n, (void)++__first)
       *__first = __value;
     return __first;
   }
      }
  };

  inline constexpr __fill_n_fn fill_n{};

  struct __fill_fn
  {
    template<typename _Tp,
      output_iterator<const _Tp&> _Out, sentinel_for<_Out> _Sent>
      constexpr _Out
      operator()(_Out __first, _Sent __last, const _Tp& __value) const
      {


 if constexpr (sized_sentinel_for<_Sent, _Out>)
   {
     const auto __len = __last - __first;
     return ranges::fill_n(__first, __len, __value);
   }
 else if constexpr (is_scalar_v<_Tp>)
   {
     const auto __tmp = __value;
     for (; __first != __last; ++__first)
       *__first = __tmp;
     return __first;
   }
 else
   {
     for (; __first != __last; ++__first)
       *__first = __value;
     return __first;
   }
      }

    template<typename _Tp, output_range<const _Tp&> _Range>
      constexpr borrowed_iterator_t<_Range>
      operator()(_Range&& __r, const _Tp& __value) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r), __value);
      }
  };

  inline constexpr __fill_fn fill{};
}

}
# 56 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/format" 2 3


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unicode.h" 1 3
# 38 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unicode.h" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdint" 1 3
# 33 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdint" 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdint" 3
namespace std
{

  using ::int8_t;
  using ::int16_t;
  using ::int32_t;
  using ::int64_t;

  using ::int_fast8_t;
  using ::int_fast16_t;
  using ::int_fast32_t;
  using ::int_fast64_t;

  using ::int_least8_t;
  using ::int_least16_t;
  using ::int_least32_t;
  using ::int_least64_t;

  using ::intmax_t;
  using ::intptr_t;

  using ::uint8_t;
  using ::uint16_t;
  using ::uint32_t;
  using ::uint64_t;

  using ::uint_fast8_t;
  using ::uint_fast16_t;
  using ::uint_fast32_t;
  using ::uint_fast64_t;

  using ::uint_least8_t;
  using ::uint_least16_t;
  using ::uint_least32_t;
  using ::uint_least64_t;

  using ::uintmax_t;
  using ::uintptr_t;
# 142 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdint" 3
}
# 39 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unicode.h" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 1 3
# 59 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/algorithmfwd.h" 1 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/algorithmfwd.h" 3








namespace std __attribute__ ((__visibility__ ("default")))
{
# 195 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/algorithmfwd.h" 3
  template<typename _IIter, typename _Predicate>
    constexpr
    bool
    all_of(_IIter, _IIter, _Predicate);

  template<typename _IIter, typename _Predicate>
    constexpr
    bool
    any_of(_IIter, _IIter, _Predicate);


  template<typename _FIter, typename _Tp>
    constexpr
    bool
    binary_search(_FIter, _FIter, const _Tp&);

  template<typename _FIter, typename _Tp, typename _Compare>
    constexpr
    bool
    binary_search(_FIter, _FIter, const _Tp&, _Compare);


  template<typename _Tp>
    constexpr
    const _Tp&
    clamp(const _Tp&, const _Tp&, const _Tp&);

  template<typename _Tp, typename _Compare>
    constexpr
    const _Tp&
    clamp(const _Tp&, const _Tp&, const _Tp&, _Compare);


  template<typename _IIter, typename _OIter>
    constexpr
    _OIter
    copy(_IIter, _IIter, _OIter);

  template<typename _BIter1, typename _BIter2>
    constexpr
    _BIter2
    copy_backward(_BIter1, _BIter1, _BIter2);


  template<typename _IIter, typename _OIter, typename _Predicate>
    constexpr
    _OIter
    copy_if(_IIter, _IIter, _OIter, _Predicate);

  template<typename _IIter, typename _Size, typename _OIter>
    constexpr
    _OIter
    copy_n(_IIter, _Size, _OIter);





  template<typename _FIter, typename _Tp>
    constexpr
    pair<_FIter, _FIter>
    equal_range(_FIter, _FIter, const _Tp&);

  template<typename _FIter, typename _Tp, typename _Compare>
    constexpr
    pair<_FIter, _FIter>
    equal_range(_FIter, _FIter, const _Tp&, _Compare);

  template<typename _FIter, typename _Tp>
    constexpr
    void
    fill(_FIter, _FIter, const _Tp&);

  template<typename _OIter, typename _Size, typename _Tp>
    constexpr
    _OIter
    fill_n(_OIter, _Size, const _Tp&);



  template<typename _FIter1, typename _FIter2>
    constexpr
    _FIter1
    find_end(_FIter1, _FIter1, _FIter2, _FIter2);

  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
    constexpr
    _FIter1
    find_end(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);





  template<typename _IIter, typename _Predicate>
    constexpr
    _IIter
    find_if_not(_IIter, _IIter, _Predicate);






  template<typename _IIter1, typename _IIter2>
    constexpr
    bool
    includes(_IIter1, _IIter1, _IIter2, _IIter2);

  template<typename _IIter1, typename _IIter2, typename _Compare>
    constexpr
    bool
    includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);

  template<typename _BIter>
    void
    inplace_merge(_BIter, _BIter, _BIter);

  template<typename _BIter, typename _Compare>
    void
    inplace_merge(_BIter, _BIter, _BIter, _Compare);


  template<typename _RAIter>
    constexpr
    bool
    is_heap(_RAIter, _RAIter);

  template<typename _RAIter, typename _Compare>
    constexpr
    bool
    is_heap(_RAIter, _RAIter, _Compare);

  template<typename _RAIter>
    constexpr
    _RAIter
    is_heap_until(_RAIter, _RAIter);

  template<typename _RAIter, typename _Compare>
    constexpr
    _RAIter
    is_heap_until(_RAIter, _RAIter, _Compare);

  template<typename _IIter, typename _Predicate>
    constexpr
    bool
    is_partitioned(_IIter, _IIter, _Predicate);

  template<typename _FIter1, typename _FIter2>
    constexpr
    bool
    is_permutation(_FIter1, _FIter1, _FIter2);

  template<typename _FIter1, typename _FIter2,
    typename _BinaryPredicate>
    constexpr
    bool
    is_permutation(_FIter1, _FIter1, _FIter2, _BinaryPredicate);

  template<typename _FIter>
    constexpr
    bool
    is_sorted(_FIter, _FIter);

  template<typename _FIter, typename _Compare>
    constexpr
    bool
    is_sorted(_FIter, _FIter, _Compare);

  template<typename _FIter>
    constexpr
    _FIter
    is_sorted_until(_FIter, _FIter);

  template<typename _FIter, typename _Compare>
    constexpr
    _FIter
    is_sorted_until(_FIter, _FIter, _Compare);


  template<typename _FIter1, typename _FIter2>
    constexpr
    void
    iter_swap(_FIter1, _FIter2);

  template<typename _FIter, typename _Tp>
    constexpr
    _FIter
    lower_bound(_FIter, _FIter, const _Tp&);

  template<typename _FIter, typename _Tp, typename _Compare>
    constexpr
    _FIter
    lower_bound(_FIter, _FIter, const _Tp&, _Compare);

  template<typename _RAIter>
    constexpr
    void
    make_heap(_RAIter, _RAIter);

  template<typename _RAIter, typename _Compare>
    constexpr
    void
    make_heap(_RAIter, _RAIter, _Compare);

  template<typename _Tp>
    constexpr
    const _Tp&
    max(const _Tp&, const _Tp&);

  template<typename _Tp, typename _Compare>
    constexpr
    const _Tp&
    max(const _Tp&, const _Tp&, _Compare);




  template<typename _Tp>
    constexpr
    const _Tp&
    min(const _Tp&, const _Tp&);

  template<typename _Tp, typename _Compare>
    constexpr
    const _Tp&
    min(const _Tp&, const _Tp&, _Compare);




  template<typename _Tp>
    constexpr
    pair<const _Tp&, const _Tp&>
    minmax(const _Tp&, const _Tp&);

  template<typename _Tp, typename _Compare>
    constexpr
    pair<const _Tp&, const _Tp&>
    minmax(const _Tp&, const _Tp&, _Compare);

  template<typename _FIter>
    constexpr
    pair<_FIter, _FIter>
    minmax_element(_FIter, _FIter);

  template<typename _FIter, typename _Compare>
    constexpr
    pair<_FIter, _FIter>
    minmax_element(_FIter, _FIter, _Compare);

  template<typename _Tp>
    constexpr
    _Tp
    min(initializer_list<_Tp>);

  template<typename _Tp, typename _Compare>
    constexpr
    _Tp
    min(initializer_list<_Tp>, _Compare);

  template<typename _Tp>
    constexpr
    _Tp
    max(initializer_list<_Tp>);

  template<typename _Tp, typename _Compare>
    constexpr
    _Tp
    max(initializer_list<_Tp>, _Compare);

  template<typename _Tp>
    constexpr
    pair<_Tp, _Tp>
    minmax(initializer_list<_Tp>);

  template<typename _Tp, typename _Compare>
    constexpr
    pair<_Tp, _Tp>
    minmax(initializer_list<_Tp>, _Compare);




  template<typename _BIter>
    constexpr
    bool
    next_permutation(_BIter, _BIter);

  template<typename _BIter, typename _Compare>
    constexpr
    bool
    next_permutation(_BIter, _BIter, _Compare);


  template<typename _IIter, typename _Predicate>
    constexpr
    bool
    none_of(_IIter, _IIter, _Predicate);





  template<typename _IIter, typename _RAIter>
    constexpr
    _RAIter
    partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter);

  template<typename _IIter, typename _RAIter, typename _Compare>
    constexpr
    _RAIter
    partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare);




  template<typename _IIter, typename _OIter1,
    typename _OIter2, typename _Predicate>
    constexpr
    pair<_OIter1, _OIter2>
    partition_copy(_IIter, _IIter, _OIter1, _OIter2, _Predicate);

  template<typename _FIter, typename _Predicate>
    constexpr
    _FIter
    partition_point(_FIter, _FIter, _Predicate);


  template<typename _RAIter>
    constexpr
    void
    pop_heap(_RAIter, _RAIter);

  template<typename _RAIter, typename _Compare>
    constexpr
    void
    pop_heap(_RAIter, _RAIter, _Compare);

  template<typename _BIter>
    constexpr
    bool
    prev_permutation(_BIter, _BIter);

  template<typename _BIter, typename _Compare>
    constexpr
    bool
    prev_permutation(_BIter, _BIter, _Compare);

  template<typename _RAIter>
    constexpr
    void
    push_heap(_RAIter, _RAIter);

  template<typename _RAIter, typename _Compare>
    constexpr
    void
    push_heap(_RAIter, _RAIter, _Compare);



  template<typename _FIter, typename _Tp>
    constexpr
    _FIter
    remove(_FIter, _FIter, const _Tp&);

  template<typename _FIter, typename _Predicate>
    constexpr
    _FIter
    remove_if(_FIter, _FIter, _Predicate);

  template<typename _IIter, typename _OIter, typename _Tp>
    constexpr
    _OIter
    remove_copy(_IIter, _IIter, _OIter, const _Tp&);

  template<typename _IIter, typename _OIter, typename _Predicate>
    constexpr
    _OIter
    remove_copy_if(_IIter, _IIter, _OIter, _Predicate);



  template<typename _IIter, typename _OIter, typename _Tp>
    constexpr
    _OIter
    replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&);

  template<typename _Iter, typename _OIter, typename _Predicate, typename _Tp>
    constexpr
    _OIter
    replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&);



  template<typename _BIter>
    constexpr
    void
    reverse(_BIter, _BIter);

  template<typename _BIter, typename _OIter>
    constexpr
    _OIter
    reverse_copy(_BIter, _BIter, _OIter);

inline namespace _V2 {

  template<typename _FIter>
    constexpr
    _FIter
    rotate(_FIter, _FIter, _FIter);

}

  template<typename _FIter, typename _OIter>
    constexpr
    _OIter
    rotate_copy(_FIter, _FIter, _FIter, _OIter);
# 622 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/algorithmfwd.h" 3
  template<typename _RAIter, typename _UGenerator>
    void
    shuffle(_RAIter, _RAIter, _UGenerator&&);


  template<typename _RAIter>
    constexpr
    void
    sort_heap(_RAIter, _RAIter);

  template<typename _RAIter, typename _Compare>
    constexpr
    void
    sort_heap(_RAIter, _RAIter, _Compare);


  template<typename _BIter, typename _Predicate>
    _BIter
    stable_partition(_BIter, _BIter, _Predicate);
# 657 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/algorithmfwd.h" 3
  template<typename _FIter1, typename _FIter2>
    constexpr
    _FIter2
    swap_ranges(_FIter1, _FIter1, _FIter2);



  template<typename _FIter>
    constexpr
    _FIter
    unique(_FIter, _FIter);

  template<typename _FIter, typename _BinaryPredicate>
    constexpr
    _FIter
    unique(_FIter, _FIter, _BinaryPredicate);



  template<typename _FIter, typename _Tp>
    constexpr
    _FIter
    upper_bound(_FIter, _FIter, const _Tp&);

  template<typename _FIter, typename _Tp, typename _Compare>
    constexpr
    _FIter
    upper_bound(_FIter, _FIter, const _Tp&, _Compare);



  template<typename _FIter>
    constexpr
    _FIter
    adjacent_find(_FIter, _FIter);

  template<typename _FIter, typename _BinaryPredicate>
    constexpr
    _FIter
    adjacent_find(_FIter, _FIter, _BinaryPredicate);

  template<typename _IIter, typename _Tp>
    constexpr
    typename iterator_traits<_IIter>::difference_type
    count(_IIter, _IIter, const _Tp&);

  template<typename _IIter, typename _Predicate>
    constexpr
    typename iterator_traits<_IIter>::difference_type
    count_if(_IIter, _IIter, _Predicate);

  template<typename _IIter1, typename _IIter2>
    constexpr
    bool
    equal(_IIter1, _IIter1, _IIter2);

  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
    constexpr
    bool
    equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate);

  template<typename _IIter, typename _Tp>
    constexpr
    _IIter
    find(_IIter, _IIter, const _Tp&);

  template<typename _FIter1, typename _FIter2>
    constexpr
    _FIter1
    find_first_of(_FIter1, _FIter1, _FIter2, _FIter2);

  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
    constexpr
    _FIter1
    find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);

  template<typename _IIter, typename _Predicate>
    constexpr
    _IIter
    find_if(_IIter, _IIter, _Predicate);

  template<typename _IIter, typename _Funct>
    constexpr
    _Funct
    for_each(_IIter, _IIter, _Funct);

  template<typename _FIter, typename _Generator>
    constexpr
    void
    generate(_FIter, _FIter, _Generator);

  template<typename _OIter, typename _Size, typename _Generator>
    constexpr
    _OIter
    generate_n(_OIter, _Size, _Generator);

  template<typename _IIter1, typename _IIter2>
    constexpr
    bool
    lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2);

  template<typename _IIter1, typename _IIter2, typename _Compare>
    constexpr
    bool
    lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);

  template<typename _FIter>
    constexpr
    _FIter
    max_element(_FIter, _FIter);

  template<typename _FIter, typename _Compare>
    constexpr
    _FIter
    max_element(_FIter, _FIter, _Compare);

  template<typename _IIter1, typename _IIter2, typename _OIter>
    constexpr
    _OIter
    merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);

  template<typename _IIter1, typename _IIter2, typename _OIter,
    typename _Compare>
    constexpr
    _OIter
    merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);

  template<typename _FIter>
    constexpr
    _FIter
    min_element(_FIter, _FIter);

  template<typename _FIter, typename _Compare>
    constexpr
    _FIter
    min_element(_FIter, _FIter, _Compare);

  template<typename _IIter1, typename _IIter2>
    constexpr
    pair<_IIter1, _IIter2>
    mismatch(_IIter1, _IIter1, _IIter2);

  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
    constexpr
    pair<_IIter1, _IIter2>
    mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate);

  template<typename _RAIter>
    constexpr
    void
    nth_element(_RAIter, _RAIter, _RAIter);

  template<typename _RAIter, typename _Compare>
    constexpr
    void
    nth_element(_RAIter, _RAIter, _RAIter, _Compare);

  template<typename _RAIter>
    constexpr
    void
    partial_sort(_RAIter, _RAIter, _RAIter);

  template<typename _RAIter, typename _Compare>
    constexpr
    void
    partial_sort(_RAIter, _RAIter, _RAIter, _Compare);

  template<typename _BIter, typename _Predicate>
    constexpr
    _BIter
    partition(_BIter, _BIter, _Predicate);


  template<typename _RAIter>
    __attribute__ ((__deprecated__ ("use '" "std::shuffle" "' instead")))
    void
    random_shuffle(_RAIter, _RAIter);

  template<typename _RAIter, typename _Generator>
    __attribute__ ((__deprecated__ ("use '" "std::shuffle" "' instead")))
    void
    random_shuffle(_RAIter, _RAIter,

     _Generator&&);





  template<typename _FIter, typename _Tp>
    constexpr
    void
    replace(_FIter, _FIter, const _Tp&, const _Tp&);

  template<typename _FIter, typename _Predicate, typename _Tp>
    constexpr
    void
    replace_if(_FIter, _FIter, _Predicate, const _Tp&);

  template<typename _FIter1, typename _FIter2>
    constexpr
    _FIter1
    search(_FIter1, _FIter1, _FIter2, _FIter2);

  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
    constexpr
    _FIter1
    search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);

  template<typename _FIter, typename _Size, typename _Tp>
    constexpr
    _FIter
    search_n(_FIter, _FIter, _Size, const _Tp&);

  template<typename _FIter, typename _Size, typename _Tp,
    typename _BinaryPredicate>
    constexpr
    _FIter
    search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate);

  template<typename _IIter1, typename _IIter2, typename _OIter>
    constexpr
    _OIter
    set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);

  template<typename _IIter1, typename _IIter2, typename _OIter,
    typename _Compare>
    constexpr
    _OIter
    set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);

  template<typename _IIter1, typename _IIter2, typename _OIter>
    constexpr
    _OIter
    set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);

  template<typename _IIter1, typename _IIter2, typename _OIter,
    typename _Compare>
    constexpr
    _OIter
    set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);

  template<typename _IIter1, typename _IIter2, typename _OIter>
    constexpr
    _OIter
    set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);

  template<typename _IIter1, typename _IIter2, typename _OIter,
    typename _Compare>
    constexpr
    _OIter
    set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2,
        _OIter, _Compare);

  template<typename _IIter1, typename _IIter2, typename _OIter>
    constexpr
    _OIter
    set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);

  template<typename _IIter1, typename _IIter2, typename _OIter,
    typename _Compare>
    constexpr
    _OIter
    set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);

  template<typename _RAIter>
    constexpr
    void
    sort(_RAIter, _RAIter);

  template<typename _RAIter, typename _Compare>
    constexpr
    void
    sort(_RAIter, _RAIter, _Compare);

  template<typename _RAIter>
    void
    stable_sort(_RAIter, _RAIter);

  template<typename _RAIter, typename _Compare>
    void
    stable_sort(_RAIter, _RAIter, _Compare);

  template<typename _IIter, typename _OIter, typename _UnaryOperation>
    constexpr
    _OIter
    transform(_IIter, _IIter, _OIter, _UnaryOperation);

  template<typename _IIter1, typename _IIter2, typename _OIter,
    typename _BinaryOperation>
    constexpr
    _OIter
    transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation);

  template<typename _IIter, typename _OIter>
    constexpr
    _OIter
    unique_copy(_IIter, _IIter, _OIter);

  template<typename _IIter, typename _OIter, typename _BinaryPredicate>
    constexpr
    _OIter
    unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate);



}
# 60 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 2 3

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_heap.h" 1 3
# 63 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_heap.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{







  template<typename _RandomAccessIterator, typename _Distance,
    typename _Compare>
    constexpr
    _Distance
    __is_heap_until(_RandomAccessIterator __first, _Distance __n,
      _Compare& __comp)
    {
      _Distance __parent = 0;
      for (_Distance __child = 1; __child < __n; ++__child)
 {
   if (__comp(__first + __parent, __first + __child))
     return __child;
   if ((__child & 1) == 0)
     ++__parent;
 }
      return __n;
    }



  template<typename _RandomAccessIterator, typename _Distance>
    constexpr
    inline bool
    __is_heap(_RandomAccessIterator __first, _Distance __n)
    {
      __gnu_cxx::__ops::_Iter_less_iter __comp;
      return std::__is_heap_until(__first, __n, __comp) == __n;
    }

  template<typename _RandomAccessIterator, typename _Compare,
    typename _Distance>
    constexpr
    inline bool
    __is_heap(_RandomAccessIterator __first, _Compare __comp, _Distance __n)
    {
      typedef __decltype(__comp) _Cmp;
      __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp));
      return std::__is_heap_until(__first, __n, __cmp) == __n;
    }

  template<typename _RandomAccessIterator>
    constexpr
    inline bool
    __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
    { return std::__is_heap(__first, std::distance(__first, __last)); }

  template<typename _RandomAccessIterator, typename _Compare>
    constexpr
    inline bool
    __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
       _Compare __comp)
    {
      return std::__is_heap(__first, std::move(__comp),
       std::distance(__first, __last));
    }




  template<typename _RandomAccessIterator, typename _Distance, typename _Tp,
    typename _Compare>
    constexpr
    void
    __push_heap(_RandomAccessIterator __first,
  _Distance __holeIndex, _Distance __topIndex, _Tp __value,
  _Compare& __comp)
    {
      _Distance __parent = (__holeIndex - 1) / 2;
      while (__holeIndex > __topIndex && __comp(__first + __parent, __value))
 {
   *(__first + __holeIndex) = std::move(*(__first + __parent));
   __holeIndex = __parent;
   __parent = (__holeIndex - 1) / 2;
 }
      *(__first + __holeIndex) = std::move(__value);
    }
# 159 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator>
    constexpr
    inline void
    push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
   _ValueType;
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
   _DistanceType;





                                                     ;
                                                     ;
                                                  ;

      __gnu_cxx::__ops::_Iter_less_val __comp;
      _ValueType __value = std::move(*(__last - 1));
      std::__push_heap(__first, _DistanceType((__last - __first) - 1),
         _DistanceType(0), std::move(__value), __comp);
    }
# 195 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
    constexpr
    inline void
    push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
       _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
   _ValueType;
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
   _DistanceType;




                                                     ;
                                                                  ;
                                                               ;

      __decltype(__gnu_cxx::__ops::__iter_comp_val(std::move(__comp)))
 __cmp(std::move(__comp));
      _ValueType __value = std::move(*(__last - 1));
      std::__push_heap(__first, _DistanceType((__last - __first) - 1),
         _DistanceType(0), std::move(__value), __cmp);
    }

  template<typename _RandomAccessIterator, typename _Distance,
    typename _Tp, typename _Compare>
    constexpr
    void
    __adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex,
    _Distance __len, _Tp __value, _Compare __comp)
    {
      const _Distance __topIndex = __holeIndex;
      _Distance __secondChild = __holeIndex;
      while (__secondChild < (__len - 1) / 2)
 {
   __secondChild = 2 * (__secondChild + 1);
   if (__comp(__first + __secondChild,
       __first + (__secondChild - 1)))
     __secondChild--;
   *(__first + __holeIndex) = std::move(*(__first + __secondChild));
   __holeIndex = __secondChild;
 }
      if ((__len & 1) == 0 && __secondChild == (__len - 2) / 2)
 {
   __secondChild = 2 * (__secondChild + 1);
   *(__first + __holeIndex) = std::move(*(__first + (__secondChild - 1)));

   __holeIndex = __secondChild - 1;
 }
      __decltype(__gnu_cxx::__ops::__iter_comp_val(std::move(__comp)))
 __cmp(std::move(__comp));
      std::__push_heap(__first, __holeIndex, __topIndex,
         std::move(__value), __cmp);
    }

  template<typename _RandomAccessIterator, typename _Compare>
    constexpr
    inline void
    __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
        _RandomAccessIterator __result, _Compare& __comp)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
 _DistanceType;

      _ValueType __value = std::move(*__result);
      *__result = std::move(*__first);
      std::__adjust_heap(__first, _DistanceType(0),
    _DistanceType(__last - __first),
    std::move(__value), __comp);
    }
# 280 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator>
    constexpr
    inline void
    pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
    {





                                                         ;
                                                     ;
                                                     ;
                                              ;

      if (__last - __first > 1)
 {
   --__last;
   __gnu_cxx::__ops::_Iter_less_iter __comp;
   std::__pop_heap(__first, __last, __last, __comp);
 }
    }
# 314 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
    constexpr
    inline void
    pop_heap(_RandomAccessIterator __first,
      _RandomAccessIterator __last, _Compare __comp)
    {



                                                     ;
                                                                  ;
                                                         ;
                                                           ;

      if (__last - __first > 1)
 {
   typedef __decltype(__comp) _Cmp;
   __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp));
   --__last;
   std::__pop_heap(__first, __last, __last, __cmp);
 }
    }

  template<typename _RandomAccessIterator, typename _Compare>
    constexpr
    void
    __make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
  _Compare& __comp)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
   _ValueType;
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
   _DistanceType;

      if (__last - __first < 2)
 return;

      const _DistanceType __len = __last - __first;
      _DistanceType __parent = (__len - 2) / 2;
      while (true)
 {
   _ValueType __value = std::move(*(__first + __parent));
   std::__adjust_heap(__first, __parent, __len, std::move(__value),
        __comp);
   if (__parent == 0)
     return;
   __parent--;
 }
    }
# 372 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator>
    constexpr
    inline void
    make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
    {





                                                     ;
                                                     ;

      __gnu_cxx::__ops::_Iter_less_iter __comp;
      std::__make_heap(__first, __last, __comp);
    }
# 399 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
    constexpr
    inline void
    make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
       _Compare __comp)
    {



                                                     ;
                                                                  ;

      typedef __decltype(__comp) _Cmp;
      __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp));
      std::__make_heap(__first, __last, __cmp);
    }

  template<typename _RandomAccessIterator, typename _Compare>
    constexpr
    void
    __sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last,
  _Compare& __comp)
    {
      while (__last - __first > 1)
 {
   --__last;
   std::__pop_heap(__first, __last, __last, __comp);
 }
    }
# 437 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator>
    constexpr
    inline void
    sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
    {





                                                     ;
                                                     ;
                                              ;

      __gnu_cxx::__ops::_Iter_less_iter __comp;
      std::__sort_heap(__first, __last, __comp);
    }
# 465 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
    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);
    }
# 494 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator>
    [[__nodiscard__]] 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);
    }
# 523 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
    [[__nodiscard__]] 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);
    }
# 548 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator>
    [[__nodiscard__]] constexpr
    inline bool
    is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
    { return std::is_heap_until(__first, __last) == __last; }
# 562 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_heap.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
    [[__nodiscard__]] 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/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 2 3



# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/uniform_int_dist.h" 1 3
# 41 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/uniform_int_dist.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 52 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/uniform_int_dist.h" 3
  template<typename _Gen>
    concept uniform_random_bit_generator
      = invocable<_Gen&> && unsigned_integral<invoke_result_t<_Gen&>>
      && requires
      {
 { _Gen::min() } -> same_as<invoke_result_t<_Gen&>>;
 { _Gen::max() } -> same_as<invoke_result_t<_Gen&>>;
 requires bool_constant<(_Gen::min() < _Gen::max())>::value;
      };



  namespace __detail
  {



    template<typename _Tp>
      constexpr bool
      _Power_of_2(_Tp __x)
      {
 return ((__x - 1) & __x) == 0;
      }
  }
# 87 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/uniform_int_dist.h" 3
  template<typename _IntType = int>
    class uniform_int_distribution
    {
      static_assert(std::is_integral<_IntType>::value,
      "template argument must be an integral type");

    public:

      typedef _IntType result_type;

      struct param_type
      {
 typedef uniform_int_distribution<_IntType> distribution_type;

 param_type() : param_type(0) { }

 explicit
 param_type(_IntType __a,
     _IntType __b = __gnu_cxx::__int_traits<_IntType>::__max)
 : _M_a(__a), _M_b(__b)
 {
   do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(_M_a <= _M_b), false)) std::__glibcxx_assert_fail(); } while (false);
 }

 result_type
 a() const
 { return _M_a; }

 result_type
 b() const
 { return _M_b; }

 friend bool
 operator==(const param_type& __p1, const param_type& __p2)
 { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }

 friend bool
 operator!=(const param_type& __p1, const param_type& __p2)
 { return !(__p1 == __p2); }

      private:
 _IntType _M_a;
 _IntType _M_b;
      };

    public:



      uniform_int_distribution() : uniform_int_distribution(0) { }




      explicit
      uniform_int_distribution(_IntType __a,
          _IntType __b
     = __gnu_cxx::__int_traits<_IntType>::__max)
      : _M_param(__a, __b)
      { }

      explicit
      uniform_int_distribution(const param_type& __p)
      : _M_param(__p)
      { }






      void
      reset() { }

      result_type
      a() const
      { return _M_param.a(); }

      result_type
      b() const
      { return _M_param.b(); }




      param_type
      param() const
      { return _M_param; }





      void
      param(const param_type& __param)
      { _M_param = __param; }




      result_type
      min() const
      { return this->a(); }




      result_type
      max() const
      { return this->b(); }




      template<typename _UniformRandomBitGenerator>
 result_type
 operator()(_UniformRandomBitGenerator& __urng)
        { return this->operator()(__urng, _M_param); }

      template<typename _UniformRandomBitGenerator>
 result_type
 operator()(_UniformRandomBitGenerator& __urng,
     const param_type& __p);

      template<typename _ForwardIterator,
        typename _UniformRandomBitGenerator>
 void
 __generate(_ForwardIterator __f, _ForwardIterator __t,
     _UniformRandomBitGenerator& __urng)
 { this->__generate(__f, __t, __urng, _M_param); }

      template<typename _ForwardIterator,
        typename _UniformRandomBitGenerator>
 void
 __generate(_ForwardIterator __f, _ForwardIterator __t,
     _UniformRandomBitGenerator& __urng,
     const param_type& __p)
 { this->__generate_impl(__f, __t, __urng, __p); }

      template<typename _UniformRandomBitGenerator>
 void
 __generate(result_type* __f, result_type* __t,
     _UniformRandomBitGenerator& __urng,
     const param_type& __p)
 { this->__generate_impl(__f, __t, __urng, __p); }





      friend bool
      operator==(const uniform_int_distribution& __d1,
   const uniform_int_distribution& __d2)
      { return __d1._M_param == __d2._M_param; }

    private:
      template<typename _ForwardIterator,
        typename _UniformRandomBitGenerator>
 void
 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
   _UniformRandomBitGenerator& __urng,
   const param_type& __p);

      param_type _M_param;




      template<typename _Wp, typename _Urbg, typename _Up>
 static _Up
 _S_nd(_Urbg& __g, _Up __range)
 {
   using _Up_traits = __gnu_cxx::__int_traits<_Up>;
   using _Wp_traits = __gnu_cxx::__int_traits<_Wp>;
   static_assert(!_Up_traits::__is_signed, "U must be unsigned");
   static_assert(!_Wp_traits::__is_signed, "W must be unsigned");
   static_assert(_Wp_traits::__digits == (2 * _Up_traits::__digits),
   "W must be twice as wide as U");




   _Wp __product = _Wp(__g()) * _Wp(__range);
   _Up __low = _Up(__product);
   if (__low < __range)
     {
       _Up __threshold = -__range % __range;
       while (__low < __threshold)
  {
    __product = _Wp(__g()) * _Wp(__range);
    __low = _Up(__product);
  }
     }
   return __product >> _Up_traits::__digits;
 }
    };

  template<typename _IntType>
    template<typename _UniformRandomBitGenerator>
      typename uniform_int_distribution<_IntType>::result_type
      uniform_int_distribution<_IntType>::
      operator()(_UniformRandomBitGenerator& __urng,
   const param_type& __param)
      {
 typedef typename _UniformRandomBitGenerator::result_type _Gresult_type;
 typedef typename make_unsigned<result_type>::type __utype;
 typedef typename common_type<_Gresult_type, __utype>::type __uctype;

 constexpr __uctype __urngmin = _UniformRandomBitGenerator::min();
 constexpr __uctype __urngmax = _UniformRandomBitGenerator::max();
 static_assert( __urngmin < __urngmax,
     "Uniform random bit generator must define min() < max()");
 constexpr __uctype __urngrange = __urngmax - __urngmin;

 const __uctype __urange
   = __uctype(__param.b()) - __uctype(__param.a());

 __uctype __ret;
 if (__urngrange > __urange)
   {


     const __uctype __uerange = __urange + 1;



     if constexpr (__urngrange == 18446744073709551615UL)
       {


  long unsigned int __u64erange = __uerange;
  __ret = __extension__ _S_nd<unsigned __int128>(__urng,
              __u64erange);
       }
     else

     if constexpr (__urngrange == 4294967295U)
       {


  unsigned int __u32erange = __uerange;
  __ret = _S_nd<long unsigned int>(__urng, __u32erange);
       }
     else

       {

  const __uctype __scaling = __urngrange / __uerange;
  const __uctype __past = __uerange * __scaling;
  do
    __ret = __uctype(__urng()) - __urngmin;
  while (__ret >= __past);
  __ret /= __scaling;
       }
   }
 else if (__urngrange < __urange)
   {
# 359 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/uniform_int_dist.h" 3
     __uctype __tmp;
     do
       {
  const __uctype __uerngrange = __urngrange + 1;
  __tmp = (__uerngrange * operator()
    (__urng, param_type(0, __urange / __uerngrange)));
  __ret = __tmp + (__uctype(__urng()) - __urngmin);
       }
     while (__ret > __urange || __ret < __tmp);
   }
 else
   __ret = __uctype(__urng()) - __urngmin;

 return __ret + __param.a();
      }


  template<typename _IntType>
    template<typename _ForwardIterator,
      typename _UniformRandomBitGenerator>
      void
      uniform_int_distribution<_IntType>::
      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
        _UniformRandomBitGenerator& __urng,
        const param_type& __param)
      {

 typedef typename _UniformRandomBitGenerator::result_type _Gresult_type;
 typedef typename make_unsigned<result_type>::type __utype;
 typedef typename common_type<_Gresult_type, __utype>::type __uctype;

 static_assert( __urng.min() < __urng.max(),
     "Uniform random bit generator must define min() < max()");

 constexpr __uctype __urngmin = __urng.min();
 constexpr __uctype __urngmax = __urng.max();
 constexpr __uctype __urngrange = __urngmax - __urngmin;
 const __uctype __urange
   = __uctype(__param.b()) - __uctype(__param.a());

 __uctype __ret;

 if (__urngrange > __urange)
   {
     if (__detail::_Power_of_2(__urngrange + 1)
  && __detail::_Power_of_2(__urange + 1))
       {
  while (__f != __t)
    {
      __ret = __uctype(__urng()) - __urngmin;
      *__f++ = (__ret & __urange) + __param.a();
    }
       }
     else
       {

  const __uctype __uerange = __urange + 1;
  const __uctype __scaling = __urngrange / __uerange;
  const __uctype __past = __uerange * __scaling;
  while (__f != __t)
    {
      do
        __ret = __uctype(__urng()) - __urngmin;
      while (__ret >= __past);
      *__f++ = __ret / __scaling + __param.a();
    }
       }
   }
 else if (__urngrange < __urange)
   {
# 444 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/uniform_int_dist.h" 3
     __uctype __tmp;
     while (__f != __t)
       {
  do
    {
      constexpr __uctype __uerngrange = __urngrange + 1;
      __tmp = (__uerngrange * operator()
        (__urng, param_type(0, __urange / __uerngrange)));
      __ret = __tmp + (__uctype(__urng()) - __urngmin);
    }
  while (__ret > __urange || __ret < __tmp);
  *__f++ = __ret;
       }
   }
 else
   while (__f != __t)
     *__f++ = __uctype(__urng()) - __urngmin + __param.a();
      }




}
# 66 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 2 3





# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdlib" 1 3
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdlib" 3
# 72 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 2 3





namespace std __attribute__ ((__visibility__ ("default")))
{



  template<typename _Iterator, typename _Compare>
    constexpr
    void
    __move_median_to_first(_Iterator __result,_Iterator __a, _Iterator __b,
      _Iterator __c, _Compare __comp)
    {
      if (__comp(__a, __b))
 {
   if (__comp(__b, __c))
     std::iter_swap(__result, __b);
   else if (__comp(__a, __c))
     std::iter_swap(__result, __c);
   else
     std::iter_swap(__result, __a);
 }
      else if (__comp(__a, __c))
 std::iter_swap(__result, __a);
      else if (__comp(__b, __c))
 std::iter_swap(__result, __c);
      else
 std::iter_swap(__result, __b);
    }


  template<typename _InputIterator, typename _Predicate>
    constexpr
    inline _InputIterator
    __find_if_not(_InputIterator __first, _InputIterator __last,
    _Predicate __pred)
    {
      return std::__find_if(__first, __last,
       __gnu_cxx::__ops::__negate(__pred),
       std::__iterator_category(__first));
    }




  template<typename _InputIterator, typename _Predicate, typename _Distance>
    constexpr
    _InputIterator
    __find_if_not_n(_InputIterator __first, _Distance& __len, _Predicate __pred)
    {
      for (; __len; --__len, (void) ++__first)
 if (!__pred(__first))
   break;
      return __first;
    }
# 148 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Integer,
    typename _UnaryPredicate>
    constexpr
    _ForwardIterator
    __search_n_aux(_ForwardIterator __first, _ForwardIterator __last,
     _Integer __count, _UnaryPredicate __unary_pred,
     std::forward_iterator_tag)
    {
      __first = std::__find_if(__first, __last, __unary_pred);
      while (__first != __last)
 {
   typename iterator_traits<_ForwardIterator>::difference_type
     __n = __count;
   _ForwardIterator __i = __first;
   ++__i;
   while (__i != __last && __n != 1 && __unary_pred(__i))
     {
       ++__i;
       --__n;
     }
   if (__n == 1)
     return __first;
   if (__i == __last)
     return __last;
   __first = std::__find_if(++__i, __last, __unary_pred);
 }
      return __last;
    }





  template<typename _RandomAccessIter, typename _Integer,
    typename _UnaryPredicate>
    constexpr
    _RandomAccessIter
    __search_n_aux(_RandomAccessIter __first, _RandomAccessIter __last,
     _Integer __count, _UnaryPredicate __unary_pred,
     std::random_access_iterator_tag)
    {
      typedef typename std::iterator_traits<_RandomAccessIter>::difference_type
 _DistanceType;

      _DistanceType __tailSize = __last - __first;
      _DistanceType __remainder = __count;

      while (__remainder <= __tailSize)
 {
   __first += __remainder;
   __tailSize -= __remainder;


   _RandomAccessIter __backTrack = __first;
   while (__unary_pred(--__backTrack))
     {
       if (--__remainder == 0)
  return (__first - __count);
     }
   __remainder = __count + 1 - (__first - __backTrack);
 }
      return __last;
    }

  template<typename _ForwardIterator, typename _Integer,
    typename _UnaryPredicate>
    constexpr
    _ForwardIterator
    __search_n(_ForwardIterator __first, _ForwardIterator __last,
        _Integer __count,
        _UnaryPredicate __unary_pred)
    {
      if (__count <= 0)
 return __first;

      if (__count == 1)
 return std::__find_if(__first, __last, __unary_pred);

      return std::__search_n_aux(__first, __last, __count, __unary_pred,
     std::__iterator_category(__first));
    }


  template<typename _ForwardIterator1, typename _ForwardIterator2,
    typename _BinaryPredicate>
    constexpr
    _ForwardIterator1
    __find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
        _ForwardIterator2 __first2, _ForwardIterator2 __last2,
        forward_iterator_tag, forward_iterator_tag,
        _BinaryPredicate __comp)
    {
      if (__first2 == __last2)
 return __last1;

      _ForwardIterator1 __result = __last1;
      while (1)
 {
   _ForwardIterator1 __new_result
     = std::__search(__first1, __last1, __first2, __last2, __comp);
   if (__new_result == __last1)
     return __result;
   else
     {
       __result = __new_result;
       __first1 = __new_result;
       ++__first1;
     }
 }
    }


  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
    typename _BinaryPredicate>
    constexpr
    _BidirectionalIterator1
    __find_end(_BidirectionalIterator1 __first1,
        _BidirectionalIterator1 __last1,
        _BidirectionalIterator2 __first2,
        _BidirectionalIterator2 __last2,
        bidirectional_iterator_tag, bidirectional_iterator_tag,
        _BinaryPredicate __comp)
    {






      typedef reverse_iterator<_BidirectionalIterator1> _RevIterator1;
      typedef reverse_iterator<_BidirectionalIterator2> _RevIterator2;

      _RevIterator1 __rlast1(__first1);
      _RevIterator2 __rlast2(__first2);
      _RevIterator1 __rresult = std::__search(_RevIterator1(__last1), __rlast1,
           _RevIterator2(__last2), __rlast2,
           __comp);

      if (__rresult == __rlast1)
 return __last1;
      else
 {
   _BidirectionalIterator1 __result = __rresult.base();
   std::advance(__result, -std::distance(__first2, __last2));
   return __result;
 }
    }
# 322 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _ForwardIterator1, typename _ForwardIterator2>
    [[__nodiscard__]] constexpr
    inline _ForwardIterator1
    find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
      _ForwardIterator2 __first2, _ForwardIterator2 __last2)
    {






                                                       ;
                                                       ;

      return std::__find_end(__first1, __last1, __first2, __last2,
        std::__iterator_category(__first1),
        std::__iterator_category(__first2),
        __gnu_cxx::__ops::__iter_equal_to_iter());
    }
# 371 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _ForwardIterator1, typename _ForwardIterator2,
    typename _BinaryPredicate>
    [[__nodiscard__]] constexpr
    inline _ForwardIterator1
    find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
      _ForwardIterator2 __first2, _ForwardIterator2 __last2,
      _BinaryPredicate __comp)
    {






                                                       ;
                                                       ;

      return std::__find_end(__first1, __last1, __first2, __last2,
        std::__iterator_category(__first1),
        std::__iterator_category(__first2),
        __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }
# 407 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _Predicate>
    [[__nodiscard__]] constexpr
    inline bool
    all_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
    { return __last == std::find_if_not(__first, __last, __pred); }
# 425 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _Predicate>
    [[__nodiscard__]] constexpr
    inline bool
    none_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
    { return __last == std::find_if(__first, __last, __pred); }
# 444 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _Predicate>
    [[__nodiscard__]] constexpr
    inline bool
    any_of(_InputIterator __first, _InputIterator __last, _Predicate __pred)
    { return !std::none_of(__first, __last, __pred); }
# 460 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _Predicate>
    [[__nodiscard__]] constexpr
    inline _InputIterator
    find_if_not(_InputIterator __first, _InputIterator __last,
  _Predicate __pred)
    {




                                                     ;
      return std::__find_if_not(__first, __last,
    __gnu_cxx::__ops::__pred_iter(__pred));
    }
# 485 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _Predicate>
    [[__nodiscard__]] constexpr
    inline bool
    is_partitioned(_InputIterator __first, _InputIterator __last,
     _Predicate __pred)
    {
      __first = std::find_if_not(__first, __last, __pred);
      if (__first == __last)
 return true;
      ++__first;
      return std::none_of(__first, __last, __pred);
    }
# 507 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Predicate>
    [[__nodiscard__]] constexpr
    _ForwardIterator
    partition_point(_ForwardIterator __first, _ForwardIterator __last,
      _Predicate __pred)
    {






                                                     ;

      typedef typename iterator_traits<_ForwardIterator>::difference_type
 _DistanceType;

      _DistanceType __len = std::distance(__first, __last);

      while (__len > 0)
 {
   _DistanceType __half = __len >> 1;
   _ForwardIterator __middle = __first;
   std::advance(__middle, __half);
   if (__pred(*__middle))
     {
       __first = __middle;
       ++__first;
       __len = __len - __half - 1;
     }
   else
     __len = __half;
 }
      return __first;
    }


  template<typename _InputIterator, typename _OutputIterator,
    typename _Predicate>
    constexpr
    _OutputIterator
    __remove_copy_if(_InputIterator __first, _InputIterator __last,
       _OutputIterator __result, _Predicate __pred)
    {
      for (; __first != __last; ++__first)
 if (!__pred(__first))
   {
     *__result = *__first;
     ++__result;
   }
      return __result;
    }
# 574 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _OutputIterator, typename _Tp>
    constexpr
    inline _OutputIterator
    remove_copy(_InputIterator __first, _InputIterator __last,
  _OutputIterator __result, const _Tp& __value)
    {






                                                     ;

      return std::__remove_copy_if(__first, __last, __result,
 __gnu_cxx::__ops::__iter_equals_val(__value));
    }
# 607 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _OutputIterator,
    typename _Predicate>
    constexpr
    inline _OutputIterator
    remove_copy_if(_InputIterator __first, _InputIterator __last,
     _OutputIterator __result, _Predicate __pred)
    {






                                                     ;

      return std::__remove_copy_if(__first, __last, __result,
       __gnu_cxx::__ops::__pred_iter(__pred));
    }
# 642 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _OutputIterator,
    typename _Predicate>
    constexpr
    _OutputIterator
    copy_if(_InputIterator __first, _InputIterator __last,
     _OutputIterator __result, _Predicate __pred)
    {






                                                     ;

      for (; __first != __last; ++__first)
 if (__pred(*__first))
   {
     *__result = *__first;
     ++__result;
   }
      return __result;
    }

  template<typename _InputIterator, typename _Size, typename _OutputIterator>
    constexpr
    _OutputIterator
    __copy_n(_InputIterator __first, _Size __n,
      _OutputIterator __result, input_iterator_tag)
    {
      return std::__niter_wrap(__result,
          __copy_n_a(__first, __n,
       std::__niter_base(__result), true));
    }

  template<typename _RandomAccessIterator, typename _Size,
    typename _OutputIterator>
    constexpr
    inline _OutputIterator
    __copy_n(_RandomAccessIterator __first, _Size __n,
      _OutputIterator __result, random_access_iterator_tag)
    { return std::copy(__first, __first + __n, __result); }
# 698 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _Size, typename _OutputIterator>
    constexpr
    inline _OutputIterator
    copy_n(_InputIterator __first, _Size __n, _OutputIterator __result)
    {





      const auto __n2 = std::__size_to_integer(__n);
      if (__n2 <= 0)
 return __result;

                                                     ;
                                                      ;

      return std::__copy_n(__first, __n2, __result,
      std::__iterator_category(__first));
    }
# 734 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _OutputIterator1,
    typename _OutputIterator2, typename _Predicate>
    constexpr
    pair<_OutputIterator1, _OutputIterator2>
    partition_copy(_InputIterator __first, _InputIterator __last,
     _OutputIterator1 __out_true, _OutputIterator2 __out_false,
     _Predicate __pred)
    {
# 750 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
                                                     ;

      for (; __first != __last; ++__first)
 if (__pred(*__first))
   {
     *__out_true = *__first;
     ++__out_true;
   }
 else
   {
     *__out_false = *__first;
     ++__out_false;
   }

      return pair<_OutputIterator1, _OutputIterator2>(__out_true, __out_false);
    }
# 785 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Tp>
    [[__nodiscard__]] constexpr
    inline _ForwardIterator
    remove(_ForwardIterator __first, _ForwardIterator __last,
    const _Tp& __value)
    {





                                                     ;

      return std::__remove_if(__first, __last,
  __gnu_cxx::__ops::__iter_equals_val(__value));
    }
# 819 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Predicate>
    [[__nodiscard__]] constexpr
    inline _ForwardIterator
    remove_if(_ForwardIterator __first, _ForwardIterator __last,
       _Predicate __pred)
    {





                                                     ;

      return std::__remove_if(__first, __last,
         __gnu_cxx::__ops::__pred_iter(__pred));
    }

  template<typename _ForwardIterator, typename _BinaryPredicate>
    constexpr
    _ForwardIterator
    __adjacent_find(_ForwardIterator __first, _ForwardIterator __last,
      _BinaryPredicate __binary_pred)
    {
      if (__first == __last)
 return __last;
      _ForwardIterator __next = __first;
      while (++__next != __last)
 {
   if (__binary_pred(__first, __next))
     return __first;
   __first = __next;
 }
      return __last;
    }

  template<typename _ForwardIterator, typename _BinaryPredicate>
    constexpr
    _ForwardIterator
    __unique(_ForwardIterator __first, _ForwardIterator __last,
      _BinaryPredicate __binary_pred)
    {

      __first = std::__adjacent_find(__first, __last, __binary_pred);
      if (__first == __last)
 return __last;


      _ForwardIterator __dest = __first;
      ++__first;
      while (++__first != __last)
 if (!__binary_pred(__dest, __first))
   *++__dest = std::move(*__first);
      return ++__dest;
    }
# 888 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _ForwardIterator>
    [[__nodiscard__]] constexpr
    inline _ForwardIterator
    unique(_ForwardIterator __first, _ForwardIterator __last)
    {





                                                     ;

      return std::__unique(__first, __last,
      __gnu_cxx::__ops::__iter_equal_to_iter());
    }
# 919 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _BinaryPredicate>
    [[__nodiscard__]] constexpr
    inline _ForwardIterator
    unique(_ForwardIterator __first, _ForwardIterator __last,
    _BinaryPredicate __binary_pred)
    {






                                                     ;

      return std::__unique(__first, __last,
      __gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
    }







  template<typename _ForwardIterator, typename _OutputIterator,
    typename _BinaryPredicate>
    constexpr
    _OutputIterator
    __unique_copy(_ForwardIterator __first, _ForwardIterator __last,
    _OutputIterator __result, _BinaryPredicate __binary_pred,
    forward_iterator_tag, output_iterator_tag)
    {





      _ForwardIterator __next = __first;
      *__result = *__first;
      while (++__next != __last)
 if (!__binary_pred(__first, __next))
   {
     __first = __next;
     *++__result = *__first;
   }
      return ++__result;
    }







  template<typename _InputIterator, typename _OutputIterator,
    typename _BinaryPredicate>
    constexpr
    _OutputIterator
    __unique_copy(_InputIterator __first, _InputIterator __last,
    _OutputIterator __result, _BinaryPredicate __binary_pred,
    input_iterator_tag, output_iterator_tag)
    {





      typename iterator_traits<_InputIterator>::value_type __value = *__first;
      __decltype(__gnu_cxx::__ops::__iter_comp_val(__binary_pred))
 __rebound_pred
 = __gnu_cxx::__ops::__iter_comp_val(__binary_pred);
      *__result = __value;
      while (++__first != __last)
 if (!__rebound_pred(__first, __value))
   {
     __value = *__first;
     *++__result = __value;
   }
      return ++__result;
    }







  template<typename _InputIterator, typename _ForwardIterator,
    typename _BinaryPredicate>
    constexpr
    _ForwardIterator
    __unique_copy(_InputIterator __first, _InputIterator __last,
    _ForwardIterator __result, _BinaryPredicate __binary_pred,
    input_iterator_tag, forward_iterator_tag)
    {




      *__result = *__first;
      while (++__first != __last)
 if (!__binary_pred(__result, __first))
   *++__result = *__first;
      return ++__result;
    }






  template<typename _BidirectionalIterator>
    constexpr
    void
    __reverse(_BidirectionalIterator __first, _BidirectionalIterator __last,
       bidirectional_iterator_tag)
    {
      while (true)
 if (__first == __last || __first == --__last)
   return;
 else
   {
     std::iter_swap(__first, __last);
     ++__first;
   }
    }






  template<typename _RandomAccessIterator>
    constexpr
    void
    __reverse(_RandomAccessIterator __first, _RandomAccessIterator __last,
       random_access_iterator_tag)
    {
      if (__first == __last)
 return;
      --__last;
      while (__first < __last)
 {
   std::iter_swap(__first, __last);
   ++__first;
   --__last;
 }
    }
# 1080 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _BidirectionalIterator>
    constexpr
    inline void
    reverse(_BidirectionalIterator __first, _BidirectionalIterator __last)
    {



                                                     ;
      std::__reverse(__first, __last, std::__iterator_category(__first));
    }
# 1108 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _BidirectionalIterator, typename _OutputIterator>
    constexpr
    _OutputIterator
    reverse_copy(_BidirectionalIterator __first, _BidirectionalIterator __last,
   _OutputIterator __result)
    {





                                                     ;

      while (__first != __last)
 {
   --__last;
   *__result = *__last;
   ++__result;
 }
      return __result;
    }





  template<typename _EuclideanRingElement>
    constexpr
    _EuclideanRingElement
    __gcd(_EuclideanRingElement __m, _EuclideanRingElement __n)
    {
      while (__n != 0)
 {
   _EuclideanRingElement __t = __m % __n;
   __m = __n;
   __n = __t;
 }
      return __m;
    }

inline namespace _V2 {


  template<typename _ForwardIterator>
    constexpr
    _ForwardIterator
    __rotate(_ForwardIterator __first,
      _ForwardIterator __middle,
      _ForwardIterator __last,
      forward_iterator_tag)
    {
      if (__first == __middle)
 return __last;
      else if (__last == __middle)
 return __first;

      _ForwardIterator __first2 = __middle;
      do
 {
   std::iter_swap(__first, __first2);
   ++__first;
   ++__first2;
   if (__first == __middle)
     __middle = __first2;
 }
      while (__first2 != __last);

      _ForwardIterator __ret = __first;

      __first2 = __middle;

      while (__first2 != __last)
 {
   std::iter_swap(__first, __first2);
   ++__first;
   ++__first2;
   if (__first == __middle)
     __middle = __first2;
   else if (__first2 == __last)
     __first2 = __middle;
 }
      return __ret;
    }


  template<typename _BidirectionalIterator>
    constexpr
    _BidirectionalIterator
    __rotate(_BidirectionalIterator __first,
      _BidirectionalIterator __middle,
      _BidirectionalIterator __last,
       bidirectional_iterator_tag)
    {




      if (__first == __middle)
 return __last;
      else if (__last == __middle)
 return __first;

      std::__reverse(__first, __middle, bidirectional_iterator_tag());
      std::__reverse(__middle, __last, bidirectional_iterator_tag());

      while (__first != __middle && __middle != __last)
 {
   std::iter_swap(__first, --__last);
   ++__first;
 }

      if (__first == __middle)
 {
   std::__reverse(__middle, __last, bidirectional_iterator_tag());
   return __last;
 }
      else
 {
   std::__reverse(__first, __middle, bidirectional_iterator_tag());
   return __first;
 }
    }


  template<typename _RandomAccessIterator>
    constexpr
    _RandomAccessIterator
    __rotate(_RandomAccessIterator __first,
      _RandomAccessIterator __middle,
      _RandomAccessIterator __last,
      random_access_iterator_tag)
    {




      if (__first == __middle)
 return __last;
      else if (__last == __middle)
 return __first;

      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
 _Distance;
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;


      typedef typename make_unsigned<_Distance>::type _UDistance;




      _Distance __n = __last - __first;
      _Distance __k = __middle - __first;

      if (__k == __n - __k)
 {
   std::swap_ranges(__first, __middle, __middle);
   return __middle;
 }

      _RandomAccessIterator __p = __first;
      _RandomAccessIterator __ret = __first + (__last - __middle);

      for (;;)
 {
   if (__k < __n - __k)
     {
       if (__is_pod(_ValueType) && __k == 1)
  {
    _ValueType __t = std::move(*__p);
    std::move(__p + 1, __p + __n, __p);
    *(__p + __n - 1) = std::move(__t);
    return __ret;
  }
       _RandomAccessIterator __q = __p + __k;
       for (_Distance __i = 0; __i < __n - __k; ++ __i)
  {
    std::iter_swap(__p, __q);
    ++__p;
    ++__q;
  }
       __n = static_cast<_UDistance>(__n) % static_cast<_UDistance>(__k);
       if (__n == 0)
  return __ret;
       std::swap(__n, __k);
       __k = __n - __k;
     }
   else
     {
       __k = __n - __k;
       if (__is_pod(_ValueType) && __k == 1)
  {
    _ValueType __t = std::move(*(__p + __n - 1));
    std::move_backward(__p, __p + __n - 1, __p + __n);
    *__p = std::move(__t);
    return __ret;
  }
       _RandomAccessIterator __q = __p + __n;
       __p = __q - __k;
       for (_Distance __i = 0; __i < __n - __k; ++ __i)
  {
    --__p;
    --__q;
    std::iter_swap(__p, __q);
  }
       __n = static_cast<_UDistance>(__n) % static_cast<_UDistance>(__k);
       if (__n == 0)
  return __ret;
       std::swap(__n, __k);
     }
 }
    }
# 1345 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _ForwardIterator>
    constexpr
    inline _ForwardIterator
    rotate(_ForwardIterator __first, _ForwardIterator __middle,
    _ForwardIterator __last)
    {



                                                       ;
                                                      ;

      return std::__rotate(__first, __middle, __last,
      std::__iterator_category(__first));
    }

}
# 1383 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _OutputIterator>
    constexpr
    inline _OutputIterator
    rotate_copy(_ForwardIterator __first, _ForwardIterator __middle,
  _ForwardIterator __last, _OutputIterator __result)
    {




                                                       ;
                                                      ;

      return std::copy(__first, __middle,
         std::copy(__middle, __last, __result));
    }


  template<typename _ForwardIterator, typename _Predicate>
    constexpr
    _ForwardIterator
    __partition(_ForwardIterator __first, _ForwardIterator __last,
  _Predicate __pred, forward_iterator_tag)
    {
      if (__first == __last)
 return __first;

      while (__pred(*__first))
 if (++__first == __last)
   return __first;

      _ForwardIterator __next = __first;

      while (++__next != __last)
 if (__pred(*__next))
   {
     std::iter_swap(__first, __next);
     ++__first;
   }

      return __first;
    }


  template<typename _BidirectionalIterator, typename _Predicate>
    constexpr
    _BidirectionalIterator
    __partition(_BidirectionalIterator __first, _BidirectionalIterator __last,
  _Predicate __pred, bidirectional_iterator_tag)
    {
      while (true)
 {
   while (true)
     if (__first == __last)
       return __first;
     else if (__pred(*__first))
       ++__first;
     else
       break;
   --__last;
   while (true)
     if (__first == __last)
       return __first;
     else if (!bool(__pred(*__last)))
       --__last;
     else
       break;
   std::iter_swap(__first, __last);
   ++__first;
 }
    }
# 1464 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Pointer, typename _Predicate,
    typename _Distance>
    _ForwardIterator
    __stable_partition_adaptive(_ForwardIterator __first,
    _ForwardIterator __last,
    _Predicate __pred, _Distance __len,
    _Pointer __buffer,
    _Distance __buffer_size)
    {
      if (__len == 1)
 return __first;

      if (__len <= __buffer_size)
 {
   _ForwardIterator __result1 = __first;
   _Pointer __result2 = __buffer;




   *__result2 = std::move(*__first);
   ++__result2;
   ++__first;
   for (; __first != __last; ++__first)
     if (__pred(__first))
       {
  *__result1 = std::move(*__first);
  ++__result1;
       }
     else
       {
  *__result2 = std::move(*__first);
  ++__result2;
       }

   std::move(__buffer, __result2, __result1);
   return __result1;
 }

      _ForwardIterator __middle = __first;
      std::advance(__middle, __len / 2);
      _ForwardIterator __left_split =
 std::__stable_partition_adaptive(__first, __middle, __pred,
      __len / 2, __buffer,
      __buffer_size);



      _Distance __right_len = __len - __len / 2;
      _ForwardIterator __right_split =
 std::__find_if_not_n(__middle, __right_len, __pred);

      if (__right_len)
 __right_split =
   std::__stable_partition_adaptive(__right_split, __last, __pred,
        __right_len,
        __buffer, __buffer_size);

      return std::rotate(__left_split, __middle, __right_split);
    }

  template<typename _ForwardIterator, typename _Predicate>
    _ForwardIterator
    __stable_partition(_ForwardIterator __first, _ForwardIterator __last,
         _Predicate __pred)
    {
      __first = std::__find_if_not(__first, __last, __pred);

      if (__first == __last)
 return __first;

      typedef typename iterator_traits<_ForwardIterator>::value_type
 _ValueType;
      typedef typename iterator_traits<_ForwardIterator>::difference_type
 _DistanceType;

      _Temporary_buffer<_ForwardIterator, _ValueType>
 __buf(__first, std::distance(__first, __last));
      return
 std::__stable_partition_adaptive(__first, __last, __pred,
      _DistanceType(__buf.requested_size()),
      __buf.begin(),
      _DistanceType(__buf.size()));
    }
# 1566 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Predicate>
    inline _ForwardIterator
    stable_partition(_ForwardIterator __first, _ForwardIterator __last,
       _Predicate __pred)
    {





                                                     ;

      return std::__stable_partition(__first, __last,
         __gnu_cxx::__ops::__pred_iter(__pred));
    }





  template<typename _RandomAccessIterator, typename _Compare>
    constexpr
    void
    __heap_select(_RandomAccessIterator __first,
    _RandomAccessIterator __middle,
    _RandomAccessIterator __last, _Compare __comp)
    {
      std::__make_heap(__first, __middle, __comp);
      for (_RandomAccessIterator __i = __middle; __i < __last; ++__i)
 if (__comp(__i, __first))
   std::__pop_heap(__first, __middle, __i, __comp);
    }



  template<typename _InputIterator, typename _RandomAccessIterator,
    typename _Compare>
    constexpr
    _RandomAccessIterator
    __partial_sort_copy(_InputIterator __first, _InputIterator __last,
   _RandomAccessIterator __result_first,
   _RandomAccessIterator __result_last,
   _Compare __comp)
    {
      typedef typename iterator_traits<_InputIterator>::value_type
 _InputValueType;
      typedef iterator_traits<_RandomAccessIterator> _RItTraits;
      typedef typename _RItTraits::difference_type _DistanceType;

      if (__result_first == __result_last)
 return __result_last;
      _RandomAccessIterator __result_real_last = __result_first;
      while (__first != __last && __result_real_last != __result_last)
 {
   *__result_real_last = *__first;
   ++__result_real_last;
   ++__first;
 }

      std::__make_heap(__result_first, __result_real_last, __comp);
      while (__first != __last)
 {
   if (__comp(__first, __result_first))
     std::__adjust_heap(__result_first, _DistanceType(0),
          _DistanceType(__result_real_last
          - __result_first),
          _InputValueType(*__first), __comp);
   ++__first;
 }
      std::__sort_heap(__result_first, __result_real_last, __comp);
      return __result_real_last;
    }
# 1659 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _RandomAccessIterator>
    constexpr
    inline _RandomAccessIterator
    partial_sort_copy(_InputIterator __first, _InputIterator __last,
        _RandomAccessIterator __result_first,
        _RandomAccessIterator __result_last)
    {
# 1680 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
                                                     ;
                                                     ;
                                                                   ;

      return std::__partial_sort_copy(__first, __last,
          __result_first, __result_last,
          __gnu_cxx::__ops::__iter_less_iter());
    }
# 1709 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _RandomAccessIterator,
    typename _Compare>
    constexpr
    inline _RandomAccessIterator
    partial_sort_copy(_InputIterator __first, _InputIterator __last,
        _RandomAccessIterator __result_first,
        _RandomAccessIterator __result_last,
        _Compare __comp)
    {
# 1735 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
                                                     ;
                                                                  ;
                                                                   ;

      return std::__partial_sort_copy(__first, __last,
          __result_first, __result_last,
    __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }




  template<typename _RandomAccessIterator, typename _Compare>
    constexpr
    void
    __unguarded_linear_insert(_RandomAccessIterator __last,
         _Compare __comp)
    {
      typename iterator_traits<_RandomAccessIterator>::value_type
 __val = std::move(*__last);
      _RandomAccessIterator __next = __last;
      --__next;
      while (__comp(__val, __next))
 {
   *__last = std::move(*__next);
   __last = __next;
   --__next;
 }
      *__last = std::move(__val);
    }


  template<typename _RandomAccessIterator, typename _Compare>
    constexpr
    void
    __insertion_sort(_RandomAccessIterator __first,
       _RandomAccessIterator __last, _Compare __comp)
    {
      if (__first == __last) return;

      for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
 {
   if (__comp(__i, __first))
     {
       typename iterator_traits<_RandomAccessIterator>::value_type
  __val = std::move(*__i);
       std::move_backward(__first, __i, __i + 1);
       *__first = std::move(__val);
     }
   else
     std::__unguarded_linear_insert(__i,
    __gnu_cxx::__ops::__val_comp_iter(__comp));
 }
    }


  template<typename _RandomAccessIterator, typename _Compare>
    constexpr
    inline void
    __unguarded_insertion_sort(_RandomAccessIterator __first,
          _RandomAccessIterator __last, _Compare __comp)
    {
      for (_RandomAccessIterator __i = __first; __i != __last; ++__i)
 std::__unguarded_linear_insert(__i,
    __gnu_cxx::__ops::__val_comp_iter(__comp));
    }





  enum { _S_threshold = 16 };


  template<typename _RandomAccessIterator, typename _Compare>
    constexpr
    void
    __final_insertion_sort(_RandomAccessIterator __first,
      _RandomAccessIterator __last, _Compare __comp)
    {
      if (__last - __first > int(_S_threshold))
 {
   std::__insertion_sort(__first, __first + int(_S_threshold), __comp);
   std::__unguarded_insertion_sort(__first + int(_S_threshold), __last,
       __comp);
 }
      else
 std::__insertion_sort(__first, __last, __comp);
    }


  template<typename _RandomAccessIterator, typename _Compare>
    constexpr
    _RandomAccessIterator
    __unguarded_partition(_RandomAccessIterator __first,
     _RandomAccessIterator __last,
     _RandomAccessIterator __pivot, _Compare __comp)
    {
      while (true)
 {
   while (__comp(__first, __pivot))
     ++__first;
   --__last;
   while (__comp(__pivot, __last))
     --__last;
   if (!(__first < __last))
     return __first;
   std::iter_swap(__first, __last);
   ++__first;
 }
    }


  template<typename _RandomAccessIterator, typename _Compare>
    constexpr
    inline _RandomAccessIterator
    __unguarded_partition_pivot(_RandomAccessIterator __first,
    _RandomAccessIterator __last, _Compare __comp)
    {
      _RandomAccessIterator __mid = __first + (__last - __first) / 2;
      std::__move_median_to_first(__first, __first + 1, __mid, __last - 1,
      __comp);
      return std::__unguarded_partition(__first + 1, __last, __first, __comp);
    }

  template<typename _RandomAccessIterator, typename _Compare>
    constexpr
    inline void
    __partial_sort(_RandomAccessIterator __first,
     _RandomAccessIterator __middle,
     _RandomAccessIterator __last,
     _Compare __comp)
    {
      std::__heap_select(__first, __middle, __last, __comp);
      std::__sort_heap(__first, __middle, __comp);
    }


  template<typename _RandomAccessIterator, typename _Size, typename _Compare>
    constexpr
    void
    __introsort_loop(_RandomAccessIterator __first,
       _RandomAccessIterator __last,
       _Size __depth_limit, _Compare __comp)
    {
      while (__last - __first > int(_S_threshold))
 {
   if (__depth_limit == 0)
     {
       std::__partial_sort(__first, __last, __last, __comp);
       return;
     }
   --__depth_limit;
   _RandomAccessIterator __cut =
     std::__unguarded_partition_pivot(__first, __last, __comp);
   std::__introsort_loop(__cut, __last, __depth_limit, __comp);
   __last = __cut;
 }
    }



  template<typename _RandomAccessIterator, typename _Compare>
    constexpr
    inline void
    __sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
    _Compare __comp)
    {
      if (__first != __last)
 {
   std::__introsort_loop(__first, __last,
    std::__lg(__last - __first) * 2,
    __comp);
   std::__final_insertion_sort(__first, __last, __comp);
 }
    }

  template<typename _RandomAccessIterator, typename _Size, typename _Compare>
    constexpr
    void
    __introselect(_RandomAccessIterator __first, _RandomAccessIterator __nth,
    _RandomAccessIterator __last, _Size __depth_limit,
    _Compare __comp)
    {
      while (__last - __first > 3)
 {
   if (__depth_limit == 0)
     {
       std::__heap_select(__first, __nth + 1, __last, __comp);

       std::iter_swap(__first, __nth);
       return;
     }
   --__depth_limit;
   _RandomAccessIterator __cut =
     std::__unguarded_partition_pivot(__first, __last, __comp);
   if (__cut <= __nth)
     __first = __cut;
   else
     __last = __cut;
 }
      std::__insertion_sort(__first, __last, __comp);
    }
# 1960 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Tp, typename _Compare>
    [[__nodiscard__]] constexpr
    inline _ForwardIterator
    lower_bound(_ForwardIterator __first, _ForwardIterator __last,
  const _Tp& __val, _Compare __comp)
    {





                    ;

      return std::__lower_bound(__first, __last, __val,
    __gnu_cxx::__ops::__iter_comp_val(__comp));
    }

  template<typename _ForwardIterator, typename _Tp, typename _Compare>
    constexpr
    _ForwardIterator
    __upper_bound(_ForwardIterator __first, _ForwardIterator __last,
    const _Tp& __val, _Compare __comp)
    {
      typedef typename iterator_traits<_ForwardIterator>::difference_type
 _DistanceType;

      _DistanceType __len = std::distance(__first, __last);

      while (__len > 0)
 {
   _DistanceType __half = __len >> 1;
   _ForwardIterator __middle = __first;
   std::advance(__middle, __half);
   if (__comp(__val, __middle))
     __len = __half;
   else
     {
       __first = __middle;
       ++__first;
       __len = __len - __half - 1;
     }
 }
      return __first;
    }
# 2016 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Tp>
    [[__nodiscard__]] constexpr
    inline _ForwardIterator
    upper_bound(_ForwardIterator __first, _ForwardIterator __last,
  const _Tp& __val)
    {




                                                                  ;

      return std::__upper_bound(__first, __last, __val,
    __gnu_cxx::__ops::__val_less_iter());
    }
# 2047 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Tp, typename _Compare>
    [[__nodiscard__]] constexpr
    inline _ForwardIterator
    upper_bound(_ForwardIterator __first, _ForwardIterator __last,
  const _Tp& __val, _Compare __comp)
    {





                    ;

      return std::__upper_bound(__first, __last, __val,
    __gnu_cxx::__ops::__val_comp_iter(__comp));
    }

  template<typename _ForwardIterator, typename _Tp,
    typename _CompareItTp, typename _CompareTpIt>
    constexpr
    pair<_ForwardIterator, _ForwardIterator>
    __equal_range(_ForwardIterator __first, _ForwardIterator __last,
    const _Tp& __val,
    _CompareItTp __comp_it_val, _CompareTpIt __comp_val_it)
    {
      typedef typename iterator_traits<_ForwardIterator>::difference_type
 _DistanceType;

      _DistanceType __len = std::distance(__first, __last);

      while (__len > 0)
 {
   _DistanceType __half = __len >> 1;
   _ForwardIterator __middle = __first;
   std::advance(__middle, __half);
   if (__comp_it_val(__middle, __val))
     {
       __first = __middle;
       ++__first;
       __len = __len - __half - 1;
     }
   else if (__comp_val_it(__val, __middle))
     __len = __half;
   else
     {
       _ForwardIterator __left
  = std::__lower_bound(__first, __middle, __val, __comp_it_val);
       std::advance(__first, __len);
       _ForwardIterator __right
  = std::__upper_bound(++__middle, __first, __val, __comp_val_it);
       return pair<_ForwardIterator, _ForwardIterator>(__left, __right);
     }
 }
      return pair<_ForwardIterator, _ForwardIterator>(__first, __first);
    }
# 2120 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Tp>
    [[__nodiscard__]] constexpr
    inline pair<_ForwardIterator, _ForwardIterator>
    equal_range(_ForwardIterator __first, _ForwardIterator __last,
  const _Tp& __val)
    {






                                                                  ;
                                                                  ;

      return std::__equal_range(__first, __last, __val,
    __gnu_cxx::__ops::__iter_less_val(),
    __gnu_cxx::__ops::__val_less_iter());
    }
# 2157 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Tp, typename _Compare>
    [[__nodiscard__]] constexpr
    inline pair<_ForwardIterator, _ForwardIterator>
    equal_range(_ForwardIterator __first, _ForwardIterator __last,
  const _Tp& __val, _Compare __comp)
    {







                    ;

                    ;

      return std::__equal_range(__first, __last, __val,
    __gnu_cxx::__ops::__iter_comp_val(__comp),
    __gnu_cxx::__ops::__val_comp_iter(__comp));
    }
# 2191 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Tp>
    [[__nodiscard__]] constexpr
    bool
    binary_search(_ForwardIterator __first, _ForwardIterator __last,
    const _Tp& __val)
    {




                                                                  ;
                                                                  ;

      _ForwardIterator __i
 = std::__lower_bound(__first, __last, __val,
        __gnu_cxx::__ops::__iter_less_val());
      return __i != __last && !(__val < *__i);
    }
# 2225 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Tp, typename _Compare>
    [[__nodiscard__]] constexpr
    bool
    binary_search(_ForwardIterator __first, _ForwardIterator __last,
    const _Tp& __val, _Compare __comp)
    {





                    ;

                    ;

      _ForwardIterator __i
 = std::__lower_bound(__first, __last, __val,
        __gnu_cxx::__ops::__iter_comp_val(__comp));
      return __i != __last && !bool(__comp(__val, *__i));
    }




  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator, typename _Compare>
    void
    __move_merge_adaptive(_InputIterator1 __first1, _InputIterator1 __last1,
     _InputIterator2 __first2, _InputIterator2 __last2,
     _OutputIterator __result, _Compare __comp)
    {
      while (__first1 != __last1 && __first2 != __last2)
 {
   if (__comp(__first2, __first1))
     {
       *__result = std::move(*__first2);
       ++__first2;
     }
   else
     {
       *__result = std::move(*__first1);
       ++__first1;
     }
   ++__result;
 }
      if (__first1 != __last1)
 std::move(__first1, __last1, __result);
    }


  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
    typename _BidirectionalIterator3, typename _Compare>
    void
    __move_merge_adaptive_backward(_BidirectionalIterator1 __first1,
       _BidirectionalIterator1 __last1,
       _BidirectionalIterator2 __first2,
       _BidirectionalIterator2 __last2,
       _BidirectionalIterator3 __result,
       _Compare __comp)
    {
      if (__first1 == __last1)
 {
   std::move_backward(__first2, __last2, __result);
   return;
 }
      else if (__first2 == __last2)
 return;

      --__last1;
      --__last2;
      while (true)
 {
   if (__comp(__last2, __last1))
     {
       *--__result = std::move(*__last1);
       if (__first1 == __last1)
  {
    std::move_backward(__first2, ++__last2, __result);
    return;
  }
       --__last1;
     }
   else
     {
       *--__result = std::move(*__last2);
       if (__first2 == __last2)
  return;
       --__last2;
     }
 }
    }


  template<typename _BidirectionalIterator1, typename _BidirectionalIterator2,
    typename _Distance>
    _BidirectionalIterator1
    __rotate_adaptive(_BidirectionalIterator1 __first,
        _BidirectionalIterator1 __middle,
        _BidirectionalIterator1 __last,
        _Distance __len1, _Distance __len2,
        _BidirectionalIterator2 __buffer,
        _Distance __buffer_size)
    {
      _BidirectionalIterator2 __buffer_end;
      if (__len1 > __len2 && __len2 <= __buffer_size)
 {
   if (__len2)
     {
       __buffer_end = std::move(__middle, __last, __buffer);
       std::move_backward(__first, __middle, __last);
       return std::move(__buffer, __buffer_end, __first);
     }
   else
     return __first;
 }
      else if (__len1 <= __buffer_size)
 {
   if (__len1)
     {
       __buffer_end = std::move(__first, __middle, __buffer);
       std::move(__middle, __last, __first);
       return std::move_backward(__buffer, __buffer_end, __last);
     }
   else
     return __last;
 }
      else
 return std::rotate(__first, __middle, __last);
    }


  template<typename _BidirectionalIterator, typename _Distance,
    typename _Pointer, typename _Compare>
    void
    __merge_adaptive(_BidirectionalIterator __first,
       _BidirectionalIterator __middle,
       _BidirectionalIterator __last,
       _Distance __len1, _Distance __len2,
       _Pointer __buffer, _Compare __comp)
    {
      if (__len1 <= __len2)
 {
   _Pointer __buffer_end = std::move(__first, __middle, __buffer);
   std::__move_merge_adaptive(__buffer, __buffer_end, __middle, __last,
         __first, __comp);
 }
      else
 {
   _Pointer __buffer_end = std::move(__middle, __last, __buffer);
   std::__move_merge_adaptive_backward(__first, __middle, __buffer,
           __buffer_end, __last, __comp);
 }
    }

  template<typename _BidirectionalIterator, typename _Distance,
    typename _Pointer, typename _Compare>
    void
    __merge_adaptive_resize(_BidirectionalIterator __first,
       _BidirectionalIterator __middle,
       _BidirectionalIterator __last,
       _Distance __len1, _Distance __len2,
       _Pointer __buffer, _Distance __buffer_size,
       _Compare __comp)
    {
      if (__len1 <= __buffer_size || __len2 <= __buffer_size)
 std::__merge_adaptive(__first, __middle, __last,
         __len1, __len2, __buffer, __comp);
      else
 {
   _BidirectionalIterator __first_cut = __first;
   _BidirectionalIterator __second_cut = __middle;
   _Distance __len11 = 0;
   _Distance __len22 = 0;
   if (__len1 > __len2)
     {
       __len11 = __len1 / 2;
       std::advance(__first_cut, __len11);
       __second_cut
  = std::__lower_bound(__middle, __last, *__first_cut,
         __gnu_cxx::__ops::__iter_comp_val(__comp));
       __len22 = std::distance(__middle, __second_cut);
     }
   else
     {
       __len22 = __len2 / 2;
       std::advance(__second_cut, __len22);
       __first_cut
  = std::__upper_bound(__first, __middle, *__second_cut,
         __gnu_cxx::__ops::__val_comp_iter(__comp));
       __len11 = std::distance(__first, __first_cut);
     }

   _BidirectionalIterator __new_middle
     = std::__rotate_adaptive(__first_cut, __middle, __second_cut,
         _Distance(__len1 - __len11), __len22,
         __buffer, __buffer_size);
   std::__merge_adaptive_resize(__first, __first_cut, __new_middle,
           __len11, __len22,
           __buffer, __buffer_size, __comp);
   std::__merge_adaptive_resize(__new_middle, __second_cut, __last,
           _Distance(__len1 - __len11),
           _Distance(__len2 - __len22),
           __buffer, __buffer_size, __comp);
 }
    }


  template<typename _BidirectionalIterator, typename _Distance,
    typename _Compare>
    void
    __merge_without_buffer(_BidirectionalIterator __first,
      _BidirectionalIterator __middle,
      _BidirectionalIterator __last,
      _Distance __len1, _Distance __len2,
      _Compare __comp)
    {
      if (__len1 == 0 || __len2 == 0)
 return;

      if (__len1 + __len2 == 2)
 {
   if (__comp(__middle, __first))
     std::iter_swap(__first, __middle);
   return;
 }

      _BidirectionalIterator __first_cut = __first;
      _BidirectionalIterator __second_cut = __middle;
      _Distance __len11 = 0;
      _Distance __len22 = 0;
      if (__len1 > __len2)
 {
   __len11 = __len1 / 2;
   std::advance(__first_cut, __len11);
   __second_cut
     = std::__lower_bound(__middle, __last, *__first_cut,
     __gnu_cxx::__ops::__iter_comp_val(__comp));
   __len22 = std::distance(__middle, __second_cut);
 }
      else
 {
   __len22 = __len2 / 2;
   std::advance(__second_cut, __len22);
   __first_cut
     = std::__upper_bound(__first, __middle, *__second_cut,
     __gnu_cxx::__ops::__val_comp_iter(__comp));
   __len11 = std::distance(__first, __first_cut);
 }

      _BidirectionalIterator __new_middle
 = std::rotate(__first_cut, __middle, __second_cut);
      std::__merge_without_buffer(__first, __first_cut, __new_middle,
      __len11, __len22, __comp);
      std::__merge_without_buffer(__new_middle, __second_cut, __last,
      __len1 - __len11, __len2 - __len22, __comp);
    }

  template<typename _BidirectionalIterator, typename _Compare>
    void
    __inplace_merge(_BidirectionalIterator __first,
      _BidirectionalIterator __middle,
      _BidirectionalIterator __last,
      _Compare __comp)
    {
      typedef typename iterator_traits<_BidirectionalIterator>::value_type
   _ValueType;
      typedef typename iterator_traits<_BidirectionalIterator>::difference_type
   _DistanceType;

      if (__first == __middle || __middle == __last)
 return;

      const _DistanceType __len1 = std::distance(__first, __middle);
      const _DistanceType __len2 = std::distance(__middle, __last);


      typedef _Temporary_buffer<_BidirectionalIterator, _ValueType> _TmpBuf;


      _TmpBuf __buf(__first, std::min(__len1, __len2));

      if (__builtin_expect(__buf.size() == __buf.requested_size(), true))
 std::__merge_adaptive
   (__first, __middle, __last, __len1, __len2, __buf.begin(), __comp);
      else if (__builtin_expect(__buf.begin() == 0, false))
 std::__merge_without_buffer
   (__first, __middle, __last, __len1, __len2, __comp);
      else
 std::__merge_adaptive_resize
   (__first, __middle, __last, __len1, __len2, __buf.begin(),
    _DistanceType(__buf.size()), __comp);




    }
# 2540 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _BidirectionalIterator>
    inline void
    inplace_merge(_BidirectionalIterator __first,
    _BidirectionalIterator __middle,
    _BidirectionalIterator __last)
    {





                                                  ;
                                                 ;
                                                     ;

      std::__inplace_merge(__first, __middle, __last,
      __gnu_cxx::__ops::__iter_less_iter());
    }
# 2581 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _BidirectionalIterator, typename _Compare>
    inline void
    inplace_merge(_BidirectionalIterator __first,
    _BidirectionalIterator __middle,
    _BidirectionalIterator __last,
    _Compare __comp)
    {






                                                               ;
                                                              ;
                                                                  ;

      std::__inplace_merge(__first, __middle, __last,
      __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }



  template<typename _InputIterator, typename _OutputIterator,
    typename _Compare>
    _OutputIterator
    __move_merge(_InputIterator __first1, _InputIterator __last1,
   _InputIterator __first2, _InputIterator __last2,
   _OutputIterator __result, _Compare __comp)
    {
      while (__first1 != __last1 && __first2 != __last2)
 {
   if (__comp(__first2, __first1))
     {
       *__result = std::move(*__first2);
       ++__first2;
     }
   else
     {
       *__result = std::move(*__first1);
       ++__first1;
     }
   ++__result;
 }
      return std::move(__first2, __last2, std::move(__first1, __last1, __result));


    }

  template<typename _RandomAccessIterator1, typename _RandomAccessIterator2,
    typename _Distance, typename _Compare>
    void
    __merge_sort_loop(_RandomAccessIterator1 __first,
        _RandomAccessIterator1 __last,
        _RandomAccessIterator2 __result, _Distance __step_size,
        _Compare __comp)
    {
      const _Distance __two_step = 2 * __step_size;

      while (__last - __first >= __two_step)
 {
   __result = std::__move_merge(__first, __first + __step_size,
           __first + __step_size,
           __first + __two_step,
           __result, __comp);
   __first += __two_step;
 }
      __step_size = std::min(_Distance(__last - __first), __step_size);

      std::__move_merge(__first, __first + __step_size,
   __first + __step_size, __last, __result, __comp);
    }

  template<typename _RandomAccessIterator, typename _Distance,
    typename _Compare>
    constexpr
    void
    __chunk_insertion_sort(_RandomAccessIterator __first,
      _RandomAccessIterator __last,
      _Distance __chunk_size, _Compare __comp)
    {
      while (__last - __first >= __chunk_size)
 {
   std::__insertion_sort(__first, __first + __chunk_size, __comp);
   __first += __chunk_size;
 }
      std::__insertion_sort(__first, __last, __comp);
    }

  enum { _S_chunk_size = 7 };

  template<typename _RandomAccessIterator, typename _Pointer, typename _Compare>
    void
    __merge_sort_with_buffer(_RandomAccessIterator __first,
        _RandomAccessIterator __last,
        _Pointer __buffer, _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
 _Distance;

      const _Distance __len = __last - __first;
      const _Pointer __buffer_last = __buffer + __len;

      _Distance __step_size = _S_chunk_size;
      std::__chunk_insertion_sort(__first, __last, __step_size, __comp);

      while (__step_size < __len)
 {
   std::__merge_sort_loop(__first, __last, __buffer,
     __step_size, __comp);
   __step_size *= 2;
   std::__merge_sort_loop(__buffer, __buffer_last, __first,
     __step_size, __comp);
   __step_size *= 2;
 }
    }

  template<typename _RandomAccessIterator, typename _Pointer, typename _Compare>
    void
    __stable_sort_adaptive(_RandomAccessIterator __first,
      _RandomAccessIterator __middle,
      _RandomAccessIterator __last,
      _Pointer __buffer, _Compare __comp)
    {
      std::__merge_sort_with_buffer(__first, __middle, __buffer, __comp);
      std::__merge_sort_with_buffer(__middle, __last, __buffer, __comp);

      std::__merge_adaptive(__first, __middle, __last,
       __middle - __first, __last - __middle,
       __buffer, __comp);
    }

  template<typename _RandomAccessIterator, typename _Pointer,
    typename _Distance, typename _Compare>
    void
    __stable_sort_adaptive_resize(_RandomAccessIterator __first,
      _RandomAccessIterator __last,
      _Pointer __buffer, _Distance __buffer_size,
      _Compare __comp)
    {
      const _Distance __len = (__last - __first + 1) / 2;
      const _RandomAccessIterator __middle = __first + __len;
      if (__len > __buffer_size)
 {
   std::__stable_sort_adaptive_resize(__first, __middle, __buffer,
          __buffer_size, __comp);
   std::__stable_sort_adaptive_resize(__middle, __last, __buffer,
          __buffer_size, __comp);
   std::__merge_adaptive_resize(__first, __middle, __last,
           _Distance(__middle - __first),
           _Distance(__last - __middle),
           __buffer, __buffer_size,
           __comp);
 }
      else
 std::__stable_sort_adaptive(__first, __middle, __last,
        __buffer, __comp);
    }


  template<typename _RandomAccessIterator, typename _Compare>
    void
    __inplace_stable_sort(_RandomAccessIterator __first,
     _RandomAccessIterator __last, _Compare __comp)
    {
      if (__last - __first < 15)
 {
   std::__insertion_sort(__first, __last, __comp);
   return;
 }
      _RandomAccessIterator __middle = __first + (__last - __first) / 2;
      std::__inplace_stable_sort(__first, __middle, __comp);
      std::__inplace_stable_sort(__middle, __last, __comp);
      std::__merge_without_buffer(__first, __middle, __last,
      __middle - __first,
      __last - __middle,
      __comp);
    }
# 2767 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _Compare>
    constexpr
    bool
    __includes(_InputIterator1 __first1, _InputIterator1 __last1,
        _InputIterator2 __first2, _InputIterator2 __last2,
        _Compare __comp)
    {
      while (__first1 != __last1 && __first2 != __last2)
 {
   if (__comp(__first2, __first1))
     return false;
   if (!__comp(__first1, __first2))
     ++__first2;
   ++__first1;
 }

      return __first2 == __last2;
    }
# 2805 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2>
    [[__nodiscard__]] constexpr
    inline bool
    includes(_InputIterator1 __first1, _InputIterator1 __last1,
      _InputIterator2 __first2, _InputIterator2 __last2)
    {
# 2820 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
                                                                ;
                                                                ;
                                                        ;
                                                        ;

      return std::__includes(__first1, __last1, __first2, __last2,
        __gnu_cxx::__ops::__iter_less_iter());
    }
# 2850 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _Compare>
    [[__nodiscard__]] constexpr
    inline bool
    includes(_InputIterator1 __first1, _InputIterator1 __last1,
      _InputIterator2 __first2, _InputIterator2 __last2,
      _Compare __comp)
    {
# 2867 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
                                                                             ;
                                                                             ;
                                                                     ;
                                                                     ;

      return std::__includes(__first1, __last1, __first2, __last2,
        __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }
# 2886 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _BidirectionalIterator, typename _Compare>
    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;
     }
 }
    }
# 2936 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _BidirectionalIterator>
    constexpr
    inline bool
    next_permutation(_BidirectionalIterator __first,
       _BidirectionalIterator __last)
    {





                                                     ;
                                                     ;

      return std::__next_permutation
 (__first, __last, __gnu_cxx::__ops::__iter_less_iter());
    }
# 2969 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _BidirectionalIterator, typename _Compare>
    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<typename _BidirectionalIterator, typename _Compare>
    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;
     }
 }
    }
# 3039 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _BidirectionalIterator>
    constexpr
    inline bool
    prev_permutation(_BidirectionalIterator __first,
       _BidirectionalIterator __last)
    {





                                                     ;
                                                     ;

      return std::__prev_permutation(__first, __last,
         __gnu_cxx::__ops::__iter_less_iter());
    }
# 3072 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _BidirectionalIterator, typename _Compare>
    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<typename _InputIterator, typename _OutputIterator,
    typename _Predicate, typename _Tp>
    constexpr
    _OutputIterator
    __replace_copy_if(_InputIterator __first, _InputIterator __last,
        _OutputIterator __result,
        _Predicate __pred, const _Tp& __new_value)
    {
      for (; __first != __last; ++__first, (void)++__result)
 if (__pred(__first))
   *__result = __new_value;
 else
   *__result = *__first;
      return __result;
    }
# 3124 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _OutputIterator, typename _Tp>
    constexpr
    inline _OutputIterator
    replace_copy(_InputIterator __first, _InputIterator __last,
   _OutputIterator __result,
   const _Tp& __old_value, const _Tp& __new_value)
    {






                                                     ;

      return std::__replace_copy_if(__first, __last, __result,
   __gnu_cxx::__ops::__iter_equals_val(__old_value),
           __new_value);
    }
# 3159 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _OutputIterator,
    typename _Predicate, typename _Tp>
    constexpr
    inline _OutputIterator
    replace_copy_if(_InputIterator __first, _InputIterator __last,
      _OutputIterator __result,
      _Predicate __pred, const _Tp& __new_value)
    {






                                                     ;

      return std::__replace_copy_if(__first, __last, __result,
    __gnu_cxx::__ops::__pred_iter(__pred),
           __new_value);
    }
# 3188 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _ForwardIterator>
    [[__nodiscard__]] constexpr
    inline bool
    is_sorted(_ForwardIterator __first, _ForwardIterator __last)
    { return std::is_sorted_until(__first, __last) == __last; }
# 3203 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Compare>
    [[__nodiscard__]] constexpr
    inline bool
    is_sorted(_ForwardIterator __first, _ForwardIterator __last,
       _Compare __comp)
    { return std::is_sorted_until(__first, __last, __comp) == __last; }

  template<typename _ForwardIterator, typename _Compare>
    constexpr
    _ForwardIterator
    __is_sorted_until(_ForwardIterator __first, _ForwardIterator __last,
        _Compare __comp)
    {
      if (__first == __last)
 return __last;

      _ForwardIterator __next = __first;
      for (++__next; __next != __last; __first = __next, (void)++__next)
 if (__comp(__next, __first))
   return __next;
      return __next;
    }
# 3234 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _ForwardIterator>
    [[__nodiscard__]] constexpr
    inline _ForwardIterator
    is_sorted_until(_ForwardIterator __first, _ForwardIterator __last)
    {




                                                     ;
                                                     ;

      return std::__is_sorted_until(__first, __last,
        __gnu_cxx::__ops::__iter_less_iter());
    }
# 3259 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Compare>
    [[__nodiscard__]] constexpr
    inline _ForwardIterator
    is_sorted_until(_ForwardIterator __first, _ForwardIterator __last,
      _Compare __comp)
    {





                                                     ;
                                                                  ;

      return std::__is_sorted_until(__first, __last,
        __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }
# 3285 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _Tp>
    [[__nodiscard__]] constexpr
    inline pair<const _Tp&, const _Tp&>
    minmax(const _Tp& __a, const _Tp& __b)
    {



      return __b < __a ? pair<const _Tp&, const _Tp&>(__b, __a)
         : pair<const _Tp&, const _Tp&>(__a, __b);
    }
# 3306 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _Tp, typename _Compare>
    [[__nodiscard__]] constexpr
    inline pair<const _Tp&, const _Tp&>
    minmax(const _Tp& __a, const _Tp& __b, _Compare __comp)
    {
      return __comp(__b, __a) ? pair<const _Tp&, const _Tp&>(__b, __a)
         : pair<const _Tp&, const _Tp&>(__a, __b);
    }

  template<typename _ForwardIterator, typename _Compare>
    constexpr
    pair<_ForwardIterator, _ForwardIterator>
    __minmax_element(_ForwardIterator __first, _ForwardIterator __last,
       _Compare __comp)
    {
      _ForwardIterator __next = __first;
      if (__first == __last
   || ++__next == __last)
 return std::make_pair(__first, __first);

      _ForwardIterator __min{}, __max{};
      if (__comp(__next, __first))
 {
   __min = __next;
   __max = __first;
 }
      else
 {
   __min = __first;
   __max = __next;
 }

      __first = __next;
      ++__first;

      while (__first != __last)
 {
   __next = __first;
   if (++__next == __last)
     {
       if (__comp(__first, __min))
  __min = __first;
       else if (!__comp(__first, __max))
  __max = __first;
       break;
     }

   if (__comp(__next, __first))
     {
       if (__comp(__next, __min))
  __min = __next;
       if (!__comp(__first, __max))
  __max = __first;
     }
   else
     {
       if (__comp(__first, __min))
  __min = __first;
       if (!__comp(__next, __max))
  __max = __next;
     }

   __first = __next;
   ++__first;
 }

      return std::make_pair(__min, __max);
    }
# 3386 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _ForwardIterator>
    [[__nodiscard__]] constexpr
    inline pair<_ForwardIterator, _ForwardIterator>
    minmax_element(_ForwardIterator __first, _ForwardIterator __last)
    {




                                                     ;
                                                     ;

      return std::__minmax_element(__first, __last,
       __gnu_cxx::__ops::__iter_less_iter());
    }
# 3414 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Compare>
    [[__nodiscard__]] constexpr
    inline pair<_ForwardIterator, _ForwardIterator>
    minmax_element(_ForwardIterator __first, _ForwardIterator __last,
     _Compare __comp)
    {





                                                     ;
                                                                  ;

      return std::__minmax_element(__first, __last,
       __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }

  template<typename _Tp>
    [[__nodiscard__]] constexpr
    inline pair<_Tp, _Tp>
    minmax(initializer_list<_Tp> __l)
    {
                                                            ;
      pair<const _Tp*, const _Tp*> __p =
 std::__minmax_element(__l.begin(), __l.end(),
         __gnu_cxx::__ops::__iter_less_iter());
      return std::make_pair(*__p.first, *__p.second);
    }

  template<typename _Tp, typename _Compare>
    [[__nodiscard__]] constexpr
    inline pair<_Tp, _Tp>
    minmax(initializer_list<_Tp> __l, _Compare __comp)
    {
                                                                         ;
      pair<const _Tp*, const _Tp*> __p =
 std::__minmax_element(__l.begin(), __l.end(),
         __gnu_cxx::__ops::__iter_comp_iter(__comp));
      return std::make_pair(*__p.first, *__p.second);
    }
# 3470 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _ForwardIterator1, typename _ForwardIterator2,
    typename _BinaryPredicate>
    [[__nodiscard__]] constexpr
    inline bool
    is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
     _ForwardIterator2 __first2, _BinaryPredicate __pred)
    {






                                                       ;

      return std::__is_permutation(__first1, __last1, __first2,
       __gnu_cxx::__ops::__iter_comp_iter(__pred));
    }


  template<typename _ForwardIterator1, typename _ForwardIterator2,
    typename _BinaryPredicate>
    constexpr
    bool
    __is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
       _ForwardIterator2 __first2, _ForwardIterator2 __last2,
       _BinaryPredicate __pred)
    {
      using _Cat1
 = typename iterator_traits<_ForwardIterator1>::iterator_category;
      using _Cat2
 = typename iterator_traits<_ForwardIterator2>::iterator_category;
      using _It1_is_RA = is_same<_Cat1, random_access_iterator_tag>;
      using _It2_is_RA = is_same<_Cat2, random_access_iterator_tag>;
      constexpr bool __ra_iters = _It1_is_RA() && _It2_is_RA();
      if (__ra_iters)
 {
   auto __d1 = std::distance(__first1, __last1);
   auto __d2 = std::distance(__first2, __last2);
   if (__d1 != __d2)
     return false;
 }



      for (; __first1 != __last1 && __first2 != __last2;
   ++__first1, (void)++__first2)
 if (!__pred(__first1, __first2))
   break;

      if (__ra_iters)
 {
   if (__first1 == __last1)
     return true;
 }
      else
 {
   auto __d1 = std::distance(__first1, __last1);
   auto __d2 = std::distance(__first2, __last2);
   if (__d1 == 0 && __d2 == 0)
     return true;
   if (__d1 != __d2)
     return false;
 }

      for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan)
 {
   if (__scan != std::__find_if(__first1, __scan,
   __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)))
     continue;

   auto __matches = std::__count_if(__first2, __last2,
  __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan));
   if (0 == __matches
       || std::__count_if(__scan, __last1,
   __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))
       != __matches)
     return false;
 }
      return true;
    }
# 3565 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _ForwardIterator1, typename _ForwardIterator2>
    [[__nodiscard__]] constexpr
    inline bool
    is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
     _ForwardIterator2 __first2, _ForwardIterator2 __last2)
    {
                                                       ;
                                                       ;

      return
 std::__is_permutation(__first1, __last1, __first2, __last2,
         __gnu_cxx::__ops::__iter_equal_to_iter());
    }
# 3593 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _ForwardIterator1, typename _ForwardIterator2,
    typename _BinaryPredicate>
    [[__nodiscard__]] constexpr
    inline bool
    is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
     _ForwardIterator2 __first2, _ForwardIterator2 __last2,
     _BinaryPredicate __pred)
    {
                                                       ;
                                                       ;

      return std::__is_permutation(__first1, __last1, __first2, __last2,
       __gnu_cxx::__ops::__iter_comp_iter(__pred));
    }
# 3621 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _Tp>
    [[nodiscard]] constexpr const _Tp&
    clamp(const _Tp& __val, const _Tp& __lo, const _Tp& __hi)
    {
      do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(!(__hi < __lo)), false)) std::__glibcxx_assert_fail(); } while (false);
      return std::min(std::max(__val, __lo), __hi);
    }
# 3641 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _Tp, typename _Compare>
    [[nodiscard]] constexpr const _Tp&
    clamp(const _Tp& __val, const _Tp& __lo, const _Tp& __hi, _Compare __comp)
    {
      do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(!__comp(__hi, __lo)), false)) std::__glibcxx_assert_fail(); } while (false);
      return std::min(std::max(__val, __lo, __comp), __hi, __comp);
    }
# 3671 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _IntType, typename _UniformRandomBitGenerator>
    pair<_IntType, _IntType>
    __gen_two_uniform_ints(_IntType __b0, _IntType __b1,
      _UniformRandomBitGenerator&& __g)
    {
      _IntType __x
 = uniform_int_distribution<_IntType>{0, (__b0 * __b1) - 1}(__g);
      return std::make_pair(__x / __b1, __x % __b1);
    }
# 3693 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator,
    typename _UniformRandomNumberGenerator>
    void
    shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
     _UniformRandomNumberGenerator&& __g)
    {



                                                     ;

      if (__first == __last)
 return;

      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
 _DistanceType;

      typedef typename std::make_unsigned<_DistanceType>::type __ud_type;
      typedef typename std::uniform_int_distribution<__ud_type> __distr_type;
      typedef typename __distr_type::param_type __p_type;

      typedef typename remove_reference<_UniformRandomNumberGenerator>::type
 _Gen;
      typedef typename common_type<typename _Gen::result_type, __ud_type>::type
 __uc_type;

      const __uc_type __urngrange = __g.max() - __g.min();
      const __uc_type __urange = __uc_type(__last - __first);

      if (__urngrange / __urange >= __urange)

      {
 _RandomAccessIterator __i = __first + 1;





 if ((__urange % 2) == 0)
 {
   __distr_type __d{0, 1};
   std::iter_swap(__i++, __first + __d(__g));
 }





 while (__i != __last)
 {
   const __uc_type __swap_range = __uc_type(__i - __first) + 1;

   const pair<__uc_type, __uc_type> __pospos =
     __gen_two_uniform_ints(__swap_range, __swap_range + 1, __g);

   std::iter_swap(__i++, __first + __pospos.first);
   std::iter_swap(__i++, __first + __pospos.second);
 }

 return;
      }

      __distr_type __d;

      for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
 std::iter_swap(__i, __first + __d(__g, __p_type(0, __i - __first)));
    }
# 3776 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _Function>
    constexpr
    _Function
    for_each(_InputIterator __first, _InputIterator __last, _Function __f)
    {


                                                     ;
      for (; __first != __last; ++__first)
 __f(*__first);
      return __f;
    }
# 3802 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _Size, typename _Function>
    constexpr
    _InputIterator
    for_each_n(_InputIterator __first, _Size __n, _Function __f)
    {
      auto __n2 = std::__size_to_integer(__n);
      using _Cat = typename iterator_traits<_InputIterator>::iterator_category;
      if constexpr (is_base_of_v<random_access_iterator_tag, _Cat>)
 {
   if (__n2 <= 0)
     return __first;
   auto __last = __first + __n2;
   std::for_each(__first, __last, std::move(__f));
   return __last;
 }
      else
 {
   while (__n2-->0)
     {
       __f(*__first);
       ++__first;
     }
   return __first;
 }
    }
# 3838 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _Tp>
    constexpr
    inline _InputIterator
    find(_InputIterator __first, _InputIterator __last,
  const _Tp& __val)
    {




                                                     ;
      return std::__find_if(__first, __last,
       __gnu_cxx::__ops::__iter_equals_val(__val));
    }
# 3863 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _Predicate>
    [[__nodiscard__]] constexpr
    inline _InputIterator
    find_if(_InputIterator __first, _InputIterator __last,
     _Predicate __pred)
    {




                                                     ;

      return std::__find_if(__first, __last,
       __gnu_cxx::__ops::__pred_iter(__pred));
    }
# 3895 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _ForwardIterator>
    [[__nodiscard__]] constexpr
    _InputIterator
    find_first_of(_InputIterator __first1, _InputIterator __last1,
    _ForwardIterator __first2, _ForwardIterator __last2)
    {






                                                       ;
                                                       ;

      for (; __first1 != __last1; ++__first1)
 for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
   if (*__first1 == *__iter)
     return __first1;
      return __last1;
    }
# 3936 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _ForwardIterator,
    typename _BinaryPredicate>
    [[__nodiscard__]] constexpr
    _InputIterator
    find_first_of(_InputIterator __first1, _InputIterator __last1,
    _ForwardIterator __first2, _ForwardIterator __last2,
    _BinaryPredicate __comp)
    {






                                                       ;
                                                       ;

      for (; __first1 != __last1; ++__first1)
 for (_ForwardIterator __iter = __first2; __iter != __last2; ++__iter)
   if (__comp(*__first1, *__iter))
     return __first1;
      return __last1;
    }
# 3969 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _ForwardIterator>
    [[__nodiscard__]] constexpr
    inline _ForwardIterator
    adjacent_find(_ForwardIterator __first, _ForwardIterator __last)
    {




                                                     ;

      return std::__adjacent_find(__first, __last,
      __gnu_cxx::__ops::__iter_equal_to_iter());
    }
# 3995 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _BinaryPredicate>
    [[__nodiscard__]] constexpr
    inline _ForwardIterator
    adjacent_find(_ForwardIterator __first, _ForwardIterator __last,
    _BinaryPredicate __binary_pred)
    {





                                                     ;

      return std::__adjacent_find(__first, __last,
   __gnu_cxx::__ops::__iter_comp_iter(__binary_pred));
    }
# 4021 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _Tp>
    [[__nodiscard__]] constexpr
    inline typename iterator_traits<_InputIterator>::difference_type
    count(_InputIterator __first, _InputIterator __last, const _Tp& __value)
    {




                                                     ;

      return std::__count_if(__first, __last,
        __gnu_cxx::__ops::__iter_equals_val(__value));
    }
# 4045 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _Predicate>
    [[__nodiscard__]] constexpr
    inline typename iterator_traits<_InputIterator>::difference_type
    count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
    {




                                                     ;

      return std::__count_if(__first, __last,
        __gnu_cxx::__ops::__pred_iter(__pred));
    }
# 4086 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _ForwardIterator1, typename _ForwardIterator2>
    [[__nodiscard__]] constexpr
    inline _ForwardIterator1
    search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
    _ForwardIterator2 __first2, _ForwardIterator2 __last2)
    {






                                                       ;
                                                       ;

      return std::__search(__first1, __last1, __first2, __last2,
      __gnu_cxx::__ops::__iter_equal_to_iter());
    }
# 4120 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Integer, typename _Tp>
    [[__nodiscard__]] constexpr
    inline _ForwardIterator
    search_n(_ForwardIterator __first, _ForwardIterator __last,
      _Integer __count, const _Tp& __val)
    {




                                                     ;

      return std::__search_n(__first, __last, __count,
        __gnu_cxx::__ops::__iter_equals_val(__val));
    }
# 4154 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Integer, typename _Tp,
    typename _BinaryPredicate>
    [[__nodiscard__]] constexpr
    inline _ForwardIterator
    search_n(_ForwardIterator __first, _ForwardIterator __last,
      _Integer __count, const _Tp& __val,
      _BinaryPredicate __binary_pred)
    {




                                                     ;

      return std::__search_n(__first, __last, __count,
  __gnu_cxx::__ops::__iter_comp_val(__binary_pred, __val));
    }
# 4180 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Searcher>
    [[__nodiscard__]] constexpr
    inline _ForwardIterator
    search(_ForwardIterator __first, _ForwardIterator __last,
    const _Searcher& __searcher)
    { return __searcher(__first, __last).first; }
# 4204 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _OutputIterator,
    typename _UnaryOperation>
    constexpr
    _OutputIterator
    transform(_InputIterator __first, _InputIterator __last,
       _OutputIterator __result, _UnaryOperation __unary_op)
    {





                                                     ;

      for (; __first != __last; ++__first, (void)++__result)
 *__result = __unary_op(*__first);
      return __result;
    }
# 4242 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator, typename _BinaryOperation>
    constexpr
    _OutputIterator
    transform(_InputIterator1 __first1, _InputIterator1 __last1,
       _InputIterator2 __first2, _OutputIterator __result,
       _BinaryOperation __binary_op)
    {






                                                       ;

      for (; __first1 != __last1; ++__first1, (void)++__first2, ++__result)
 *__result = __binary_op(*__first1, *__first2);
      return __result;
    }
# 4276 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Tp>
    constexpr
    void
    replace(_ForwardIterator __first, _ForwardIterator __last,
     const _Tp& __old_value, const _Tp& __new_value)
    {







                                                     ;

      for (; __first != __last; ++__first)
 if (*__first == __old_value)
   *__first = __new_value;
    }
# 4309 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Predicate, typename _Tp>
    constexpr
    void
    replace_if(_ForwardIterator __first, _ForwardIterator __last,
        _Predicate __pred, const _Tp& __new_value)
    {







                                                     ;

      for (; __first != __last; ++__first)
 if (__pred(*__first))
   *__first = __new_value;
    }
# 4341 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Generator>
    constexpr
    void
    generate(_ForwardIterator __first, _ForwardIterator __last,
      _Generator __gen)
    {




                                                     ;

      for (; __first != __last; ++__first)
 *__first = __gen();
    }
# 4374 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _OutputIterator, typename _Size, typename _Generator>
    constexpr
    _OutputIterator
    generate_n(_OutputIterator __first, _Size __n, _Generator __gen)
    {





      typedef __decltype(std::__size_to_integer(__n)) _IntSize;
      for (_IntSize __niter = std::__size_to_integer(__n);
    __niter > 0; --__niter, (void) ++__first)
 *__first = __gen();
      return __first;
    }
# 4409 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _OutputIterator>
    constexpr
    inline _OutputIterator
    unique_copy(_InputIterator __first, _InputIterator __last,
  _OutputIterator __result)
    {






                                                     ;

      if (__first == __last)
 return __result;
      return std::__unique_copy(__first, __last, __result,
    __gnu_cxx::__ops::__iter_equal_to_iter(),
    std::__iterator_category(__first),
    std::__iterator_category(__result));
    }
# 4449 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _InputIterator, typename _OutputIterator,
    typename _BinaryPredicate>
    constexpr
    inline _OutputIterator
    unique_copy(_InputIterator __first, _InputIterator __last,
  _OutputIterator __result,
  _BinaryPredicate __binary_pred)
    {




                                                     ;

      if (__first == __last)
 return __result;
      return std::__unique_copy(__first, __last, __result,
   __gnu_cxx::__ops::__iter_comp_iter(__binary_pred),
    std::__iterator_category(__first),
    std::__iterator_category(__result));
    }
# 4488 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator>
    __attribute__ ((__deprecated__ ("use '" "std::shuffle" "' instead")))
    inline void
    random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last)
    {



                                                     ;

      if (__first != __last)
 for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
   {

     _RandomAccessIterator __j = __first
     + std::rand() % ((__i - __first) + 1);
     if (__i != __j)
       std::iter_swap(__i, __j);
   }
    }
# 4527 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator, typename _RandomNumberGenerator>
    __attribute__ ((__deprecated__ ("use '" "std::shuffle" "' instead")))
    void
    random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,

     _RandomNumberGenerator&& __rand)



    {



                                                     ;

      if (__first == __last)
 return;
      for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
 {
   _RandomAccessIterator __j = __first + __rand((__i - __first) + 1);
   if (__i != __j)
     std::iter_swap(__i, __j);
 }
    }
# 4569 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Predicate>
    constexpr
    inline _ForwardIterator
    partition(_ForwardIterator __first, _ForwardIterator __last,
       _Predicate __pred)
    {





                                                     ;

      return std::__partition(__first, __last, __pred,
         std::__iterator_category(__first));
    }
# 4604 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator>
    constexpr
    inline void
    partial_sort(_RandomAccessIterator __first,
   _RandomAccessIterator __middle,
   _RandomAccessIterator __last)
    {





                                                       ;
                                                      ;
                                                     ;

      std::__partial_sort(__first, __middle, __last,
     __gnu_cxx::__ops::__iter_less_iter());
    }
# 4643 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
    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));
    }
# 4680 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator>
    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());
    }
# 4720 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
    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));
    }
# 4758 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator>
    constexpr
    inline void
    sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
    {





                                                     ;
                                                     ;

      std::__sort(__first, __last, __gnu_cxx::__ops::__iter_less_iter());
    }
# 4789 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
    constexpr
    inline void
    sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
  _Compare __comp)
    {






                                                     ;
                                                                  ;

      std::__sort(__first, __last, __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }

  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator, typename _Compare>
    constexpr
    _OutputIterator
    __merge(_InputIterator1 __first1, _InputIterator1 __last1,
     _InputIterator2 __first2, _InputIterator2 __last2,
     _OutputIterator __result, _Compare __comp)
    {
      while (__first1 != __last1 && __first2 != __last2)
 {
   if (__comp(__first2, __first1))
     {
       *__result = *__first2;
       ++__first2;
     }
   else
     {
       *__result = *__first1;
       ++__first1;
     }
   ++__result;
 }
      return std::copy(__first2, __last2,
         std::copy(__first1, __last1, __result));
    }
# 4852 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator>
    constexpr
    inline _OutputIterator
    merge(_InputIterator1 __first1, _InputIterator1 __last1,
   _InputIterator2 __first2, _InputIterator2 __last2,
   _OutputIterator __result)
    {
# 4870 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
                                                                ;
                                                                ;
                                                        ;
                                                        ;

      return std::__merge(__first1, __last1,
         __first2, __last2, __result,
         __gnu_cxx::__ops::__iter_less_iter());
    }
# 4903 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator, typename _Compare>
    constexpr
    inline _OutputIterator
    merge(_InputIterator1 __first1, _InputIterator1 __last1,
   _InputIterator2 __first2, _InputIterator2 __last2,
   _OutputIterator __result, _Compare __comp)
    {
# 4921 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
                                                                             ;
                                                                             ;
                                                                     ;
                                                                     ;

      return std::__merge(__first1, __last1,
    __first2, __last2, __result,
    __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }

  template<typename _RandomAccessIterator, typename _Compare>
    inline void
    __stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
    _Compare __comp)
    {
      typedef typename iterator_traits<_RandomAccessIterator>::value_type
 _ValueType;
      typedef typename iterator_traits<_RandomAccessIterator>::difference_type
 _DistanceType;

      if (__first == __last)
 return;


      typedef _Temporary_buffer<_RandomAccessIterator, _ValueType> _TmpBuf;


      _TmpBuf __buf(__first, (__last - __first + 1) / 2);

      if (__builtin_expect(__buf.requested_size() == __buf.size(), true))
 std::__stable_sort_adaptive(__first,
        __first + _DistanceType(__buf.size()),
        __last, __buf.begin(), __comp);
      else if (__builtin_expect(__buf.begin() == 0, false))
 std::__inplace_stable_sort(__first, __last, __comp);
      else
 std::__stable_sort_adaptive_resize(__first, __last, __buf.begin(),
        _DistanceType(__buf.size()), __comp);



    }
# 4981 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator>
    inline void
    stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
    {





                                                     ;
                                                     ;

      std::__stable_sort(__first, __last,
        __gnu_cxx::__ops::__iter_less_iter());
    }
# 5015 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _RandomAccessIterator, typename _Compare>
    inline void
    stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last,
  _Compare __comp)
    {






                                                     ;
                                                                  ;

      std::__stable_sort(__first, __last,
        __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }

  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator,
    typename _Compare>
    constexpr
    _OutputIterator
    __set_union(_InputIterator1 __first1, _InputIterator1 __last1,
  _InputIterator2 __first2, _InputIterator2 __last2,
  _OutputIterator __result, _Compare __comp)
    {
      while (__first1 != __last1 && __first2 != __last2)
 {
   if (__comp(__first1, __first2))
     {
       *__result = *__first1;
       ++__first1;
     }
   else if (__comp(__first2, __first1))
     {
       *__result = *__first2;
       ++__first2;
     }
   else
     {
       *__result = *__first1;
       ++__first1;
       ++__first2;
     }
   ++__result;
 }
      return std::copy(__first2, __last2,
         std::copy(__first1, __last1, __result));
    }
# 5085 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator>
    constexpr
    inline _OutputIterator
    set_union(_InputIterator1 __first1, _InputIterator1 __last1,
       _InputIterator2 __first2, _InputIterator2 __last2,
       _OutputIterator __result)
    {
# 5106 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
                                                                ;
                                                                ;
                                                        ;
                                                        ;

      return std::__set_union(__first1, __last1,
    __first2, __last2, __result,
    __gnu_cxx::__ops::__iter_less_iter());
    }
# 5136 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator, typename _Compare>
    constexpr
    inline _OutputIterator
    set_union(_InputIterator1 __first1, _InputIterator1 __last1,
       _InputIterator2 __first2, _InputIterator2 __last2,
       _OutputIterator __result, _Compare __comp)
    {
# 5157 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
                                                                             ;
                                                                             ;
                                                                     ;
                                                                     ;

      return std::__set_union(__first1, __last1,
    __first2, __last2, __result,
    __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }

  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator,
    typename _Compare>
    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;
    }
# 5209 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator>
    constexpr
    inline _OutputIterator
    set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
       _InputIterator2 __first2, _InputIterator2 __last2,
       _OutputIterator __result)
    {
# 5228 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
                                                                ;
                                                                ;
                                                        ;
                                                        ;

      return std::__set_intersection(__first1, __last1,
         __first2, __last2, __result,
         __gnu_cxx::__ops::__iter_less_iter());
    }
# 5259 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator, typename _Compare>
    constexpr
    inline _OutputIterator
    set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
       _InputIterator2 __first2, _InputIterator2 __last2,
       _OutputIterator __result, _Compare __comp)
    {
# 5278 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
                                                                             ;
                                                                             ;
                                                                     ;
                                                                     ;

      return std::__set_intersection(__first1, __last1,
    __first2, __last2, __result,
    __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }

  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator,
    typename _Compare>
    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);
    }
# 5334 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator>
    constexpr
    inline _OutputIterator
    set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
     _InputIterator2 __first2, _InputIterator2 __last2,
     _OutputIterator __result)
    {
# 5353 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
                                                                ;
                                                                ;
                                                        ;
                                                        ;

      return std::__set_difference(__first1, __last1,
       __first2, __last2, __result,
       __gnu_cxx::__ops::__iter_less_iter());
    }
# 5386 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator, typename _Compare>
    constexpr
    inline _OutputIterator
    set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
     _InputIterator2 __first2, _InputIterator2 __last2,
     _OutputIterator __result, _Compare __comp)
    {
# 5405 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
                                                                             ;
                                                                             ;
                                                                     ;
                                                                     ;

      return std::__set_difference(__first1, __last1,
       __first2, __last2, __result,
       __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }

  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator,
    typename _Compare>
    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));
    }
# 5467 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator>
    constexpr
    inline _OutputIterator
    set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
        _InputIterator2 __first2, _InputIterator2 __last2,
        _OutputIterator __result)
    {
# 5488 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
                                                                ;
                                                                ;
                                                        ;
                                                        ;

      return std::__set_symmetric_difference(__first1, __last1,
     __first2, __last2, __result,
     __gnu_cxx::__ops::__iter_less_iter());
    }
# 5519 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _InputIterator1, typename _InputIterator2,
    typename _OutputIterator, typename _Compare>
    constexpr
    inline _OutputIterator
    set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
        _InputIterator2 __first2, _InputIterator2 __last2,
        _OutputIterator __result,
        _Compare __comp)
    {
# 5541 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
                                                                             ;
                                                                             ;
                                                                     ;
                                                                     ;

      return std::__set_symmetric_difference(__first1, __last1,
    __first2, __last2, __result,
    __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }

  template<typename _ForwardIterator, typename _Compare>
    constexpr
    _ForwardIterator
    __min_element(_ForwardIterator __first, _ForwardIterator __last,
    _Compare __comp)
    {
      if (__first == __last)
 return __first;
      _ForwardIterator __result = __first;
      while (++__first != __last)
 if (__comp(__first, __result))
   __result = __first;
      return __result;
    }
# 5573 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _ForwardIterator>
    [[__nodiscard__]] constexpr
    _ForwardIterator
    inline min_element(_ForwardIterator __first, _ForwardIterator __last)
    {




                                                     ;
                                                     ;

      return std::__min_element(__first, __last,
    __gnu_cxx::__ops::__iter_less_iter());
    }
# 5598 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Compare>
    [[__nodiscard__]] constexpr
    inline _ForwardIterator
    min_element(_ForwardIterator __first, _ForwardIterator __last,
  _Compare __comp)
    {





                                                     ;
                                                                  ;

      return std::__min_element(__first, __last,
    __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }

  template<typename _ForwardIterator, typename _Compare>
    constexpr
    _ForwardIterator
    __max_element(_ForwardIterator __first, _ForwardIterator __last,
    _Compare __comp)
    {
      if (__first == __last) return __first;
      _ForwardIterator __result = __first;
      while (++__first != __last)
 if (__comp(__result, __first))
   __result = __first;
      return __result;
    }
# 5637 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _ForwardIterator>
    [[__nodiscard__]] constexpr
    inline _ForwardIterator
    max_element(_ForwardIterator __first, _ForwardIterator __last)
    {




                                                     ;
                                                     ;

      return std::__max_element(__first, __last,
    __gnu_cxx::__ops::__iter_less_iter());
    }
# 5662 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_algo.h" 3
  template<typename _ForwardIterator, typename _Compare>
    [[__nodiscard__]] constexpr
    inline _ForwardIterator
    max_element(_ForwardIterator __first, _ForwardIterator __last,
  _Compare __comp)
    {





                                                     ;
                                                                  ;

      return std::__max_element(__first, __last,
    __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }



  template<typename _Tp>
    constexpr
    inline _Tp
    min(initializer_list<_Tp> __l)
    {
                                                            ;
      return *std::__min_element(__l.begin(), __l.end(),
   __gnu_cxx::__ops::__iter_less_iter());
    }

  template<typename _Tp, typename _Compare>
    constexpr
    inline _Tp
    min(initializer_list<_Tp> __l, _Compare __comp)
    {
                                                                         ;
      return *std::__min_element(__l.begin(), __l.end(),
   __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }

  template<typename _Tp>
    constexpr
    inline _Tp
    max(initializer_list<_Tp> __l)
    {
                                                            ;
      return *std::__max_element(__l.begin(), __l.end(),
   __gnu_cxx::__ops::__iter_less_iter());
    }

  template<typename _Tp, typename _Compare>
    constexpr
    inline _Tp
    max(initializer_list<_Tp> __l, _Compare __comp)
    {
                                                                         ;
      return *std::__max_element(__l.begin(), __l.end(),
   __gnu_cxx::__ops::__iter_comp_iter(__comp));
    }




  template<typename _InputIterator, typename _RandomAccessIterator,
           typename _Size, typename _UniformRandomBitGenerator>
    _RandomAccessIterator
    __sample(_InputIterator __first, _InputIterator __last, input_iterator_tag,
      _RandomAccessIterator __out, random_access_iterator_tag,
      _Size __n, _UniformRandomBitGenerator&& __g)
    {
      using __distrib_type = uniform_int_distribution<_Size>;
      using __param_type = typename __distrib_type::param_type;
      __distrib_type __d{};
      _Size __sample_sz = 0;
      while (__first != __last && __sample_sz != __n)
 {
   __out[__sample_sz++] = *__first;
   ++__first;
 }
      for (auto __pop_sz = __sample_sz; __first != __last;
   ++__first, (void) ++__pop_sz)
 {
   const auto __k = __d(__g, __param_type{0, __pop_sz});
   if (__k < __n)
     __out[__k] = *__first;
 }
      return __out + __sample_sz;
    }


  template<typename _ForwardIterator, typename _OutputIterator, typename _Cat,
           typename _Size, typename _UniformRandomBitGenerator>
    _OutputIterator
    __sample(_ForwardIterator __first, _ForwardIterator __last,
      forward_iterator_tag,
      _OutputIterator __out, _Cat,
      _Size __n, _UniformRandomBitGenerator&& __g)
    {
      using __distrib_type = uniform_int_distribution<_Size>;
      using __param_type = typename __distrib_type::param_type;
      using _USize = make_unsigned_t<_Size>;
      using _Gen = remove_reference_t<_UniformRandomBitGenerator>;
      using __uc_type = common_type_t<typename _Gen::result_type, _USize>;

      if (__first == __last)
 return __out;

      __distrib_type __d{};
      _Size __unsampled_sz = std::distance(__first, __last);
      __n = std::min(__n, __unsampled_sz);




      const __uc_type __urngrange = __g.max() - __g.min();
      if (__urngrange / __uc_type(__unsampled_sz) >= __uc_type(__unsampled_sz))


        {
   while (__n != 0 && __unsampled_sz >= 2)
     {
       const pair<_Size, _Size> __p =
  __gen_two_uniform_ints(__unsampled_sz, __unsampled_sz - 1, __g);

       --__unsampled_sz;
       if (__p.first < __n)
  {
    *__out++ = *__first;
    --__n;
  }

       ++__first;

       if (__n == 0) break;

       --__unsampled_sz;
       if (__p.second < __n)
  {
    *__out++ = *__first;
    --__n;
  }

       ++__first;
     }
        }



      for (; __n != 0; ++__first)
 if (__d(__g, __param_type{0, --__unsampled_sz}) < __n)
   {
     *__out++ = *__first;
     --__n;
   }
      return __out;
    }




  template<typename _PopulationIterator, typename _SampleIterator,
           typename _Distance, typename _UniformRandomBitGenerator>
    _SampleIterator
    sample(_PopulationIterator __first, _PopulationIterator __last,
    _SampleIterator __out, _Distance __n,
    _UniformRandomBitGenerator&& __g)
    {
      using __pop_cat = typename
 std::iterator_traits<_PopulationIterator>::iterator_category;
      using __samp_cat = typename
 std::iterator_traits<_SampleIterator>::iterator_category;

      static_assert(
   __or_<is_convertible<__pop_cat, forward_iterator_tag>,
  is_convertible<__samp_cat, random_access_iterator_tag>>::value,
   "output range must use a RandomAccessIterator when input range"
   " does not meet the ForwardIterator requirements");

      static_assert(is_integral<_Distance>::value,
      "sample size must be an integer type");

      typename iterator_traits<_PopulationIterator>::difference_type __d = __n;
      return std::
 __sample(__first, __last, __pop_cat{}, __out, __samp_cat{}, __d,
   std::forward<_UniformRandomBitGenerator>(__g));
    }




}
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unicode.h" 2 3




namespace std __attribute__ ((__visibility__ ("default")))
{

namespace __unicode
{

  constexpr bool
  __is_scalar_value(char32_t __c)
  {
    if (__c < 0xD800) [[likely]]
      return true;
    return 0xDFFF < __c && __c <= 0x10FFFF;
  }


  template<typename _CharT>
    constexpr bool
    __is_single_code_unit(char32_t __c)
    {
      if constexpr (__gnu_cxx::__int_traits<_CharT>::__max <= 0xFF)
 return __c < 0x7F;
      else
 return __c < __gnu_cxx::__int_traits<_CharT>::__max
         && __is_scalar_value(__c);
    }



  struct _Repl
  {
    constexpr char32_t
    operator()() const noexcept
    { return 0xFFFD; }
  };

  struct _Null_sentinel_t
  {
    template<input_iterator _It>
      requires default_initializable<iter_value_t<_It>>
 && equality_comparable_with<iter_reference_t<_It>, iter_value_t<_It>>
      friend constexpr auto
      operator==(_It __it, _Null_sentinel_t)
      { return *__it == iter_value_t<_It>{}; }
  };

  template<typename _FromFmt, typename _ToFmt,
    input_iterator _Iter, sentinel_for<_Iter> _Sent = _Iter,
    typename _ErrorHandler = _Repl>
    requires convertible_to<iter_value_t<_Iter>, _FromFmt>
    class _Utf_iterator
    {
      static_assert(forward_iterator<_Iter> || noexcept(_ErrorHandler()()));

    public:
      using value_type = _ToFmt;
      using difference_type = iter_difference_t<_Iter>;
      using reference = value_type;
      using iterator_concept
 = std::__detail::__clamp_iter_cat<__iter_category_t<_Iter>,
       bidirectional_iterator_tag>;

      constexpr _Utf_iterator() = default;

      constexpr
      _Utf_iterator(_Iter __first, _Iter __it, _Sent __last)
      requires bidirectional_iterator<_Iter>
      : _M_first_and_curr{__first, __it}, _M_last(__last)
      {
 if (_M_curr() != _M_last)
   _M_read();
 else
   _M_buf = {};
      }

      constexpr
      _Utf_iterator(_Iter __it, _Sent __last)
      requires (!bidirectional_iterator<_Iter>)
      : _M_first_and_curr{__it}, _M_last(__last)
      {
 if (_M_curr() != _M_last)
   _M_read();
 else
   _M_buf = {};
      }

      template<class _Iter2, class _Sent2>
 requires convertible_to<_Iter2, _Iter> && convertible_to<_Sent2, _Sent>
 constexpr
 _Utf_iterator(const _Utf_iterator<_FromFmt, _ToFmt, _Iter2, _Sent2,
       _ErrorHandler>& __other)
 : _M_buf(__other._M_buf), _M_first_and_curr(__other._M_first_and_curr),
   _M_buf_index(__other._M_buf_index), _M_buf_last(__other._M_buf_last),
   _M_last(__other._M_last)
 { }

      [[nodiscard]]
      constexpr _Iter
      begin() const requires bidirectional_iterator<_Iter>
      { return _M_first(); }

      [[nodiscard]]
      constexpr _Sent
      end() const { return _M_last; }

      [[nodiscard]]
      constexpr _Iter
      base() const requires forward_iterator<_Iter>
      { return _M_curr(); }

      [[nodiscard]]
      constexpr value_type
      operator*() const { return _M_buf[_M_buf_index]; }

      constexpr _Utf_iterator&
      operator++()
      {
 if (_M_buf_index + 1 == _M_buf_last && _M_curr() != _M_last)
   {
     if constexpr (forward_iterator<_Iter>)
       std::advance(_M_curr(), _M_to_increment);
     if (_M_curr() == _M_last)
       _M_buf_index = 0;
     else
       _M_read();
   }
 else if (_M_buf_index + 1 < _M_buf_last)
   ++_M_buf_index;
 return *this;
      }

      constexpr _Utf_iterator
      operator++(int)
      {
 auto __tmp = *this;
 ++*this;
 return __tmp;
      }

      constexpr _Utf_iterator&
      operator--() requires bidirectional_iterator<_Iter>
      {
 if (!_M_buf_index && _M_curr() != _M_first())
   _M_read_reverse();
 else if (_M_buf_index)
   --_M_buf_index;
 return *this;
      }

      constexpr _Utf_iterator
      operator--(int)
      {
 auto __tmp = *this;
 --*this;
 return __tmp;
      }

      [[nodiscard]]
      friend constexpr bool
      operator==(_Utf_iterator __lhs, _Utf_iterator __rhs)
      requires forward_iterator<_Iter> || requires (_Iter __i) { __i != __i; }
      {
 if constexpr (forward_iterator<_Iter>)
   return __lhs._M_curr() == __rhs._M_curr()
     && __lhs._M_buf_index == __rhs._M_buf_index;
 else if (__lhs._M_curr() != __rhs._M_curr())
   return false;
 else if (__lhs._M_buf_index == __rhs._M_buf_index
     && __lhs._M_buf_last == __rhs._M_buf_last)
   return true;
 else
   return __lhs._M_buf_index == __lhs._M_buf_last
     && __rhs._M_buf_index == __rhs._M_buf_last;
      }

      [[nodiscard]]
      friend constexpr bool
      operator==(_Utf_iterator __lhs, _Sent __rhs)
      {
 if constexpr (forward_iterator<_Iter>)
   return __lhs._M_curr() == __rhs;
 else
   return __lhs._M_curr() == __rhs
     && __lhs._M_buf_index == __lhs._M_buf_last;
      }

    private:
      constexpr void
      _M_read()
      {
 if constexpr (sizeof(_FromFmt) == sizeof(uint8_t))
   _M_read_utf8();
 else if constexpr (sizeof(_FromFmt) == sizeof(uint16_t))
   _M_read_utf16();
 else
   {
     static_assert(sizeof(_FromFmt) == sizeof(uint32_t));
     _M_read_utf32();
   }
      }

      constexpr void
      _M_read_reverse();

      template<typename>
 struct _Guard
 {
   _Guard(void*, _Iter&) { }
 };

      template<typename _It> requires forward_iterator<_It>
 struct _Guard<_It>
 {
   constexpr ~_Guard() { _M_this->_M_curr() = std::move(_M_orig); }
   _Utf_iterator* _M_this;
   _It _M_orig;
 };

      constexpr void
      _M_read_utf8()
      {
 _Guard<_Iter> __g{this, _M_curr()};
 char32_t __c{};
 const uint8_t __lo_bound = 0x80, __hi_bound = 0xBF;
 uint8_t __u = *_M_curr()++;
 uint8_t __to_incr = 1;
 auto __incr = [&, this] {
   ++__to_incr;
   return ++_M_curr();
 };

 if (__u <= 0x7F) [[likely]]
   __c = __u;
 else if (__u < 0xC2) [[unlikely]]
   __c = _S_error();
 else if (_M_curr() == _M_last) [[unlikely]]
   __c = _S_error();
 else if (__u <= 0xDF)
   {
     __c = __u & 0x1F;
     __u = *_M_curr();

     if (__u < __lo_bound || __u > __hi_bound) [[unlikely]]
       __c = _S_error();
     else
       {
  __c = (__c << 6) | (__u & 0x3F);
  __incr();
       }
   }
 else if (__u <= 0xEF)
   {
     const uint8_t __lo_bound_2 = __u == 0xE0 ? 0xA0 : __lo_bound;
     const uint8_t __hi_bound_2 = __u == 0xED ? 0x9F : __hi_bound;

     __c = __u & 0x0F;
     __u = *_M_curr();

     if (__u < __lo_bound_2 || __u > __hi_bound_2) [[unlikely]]
       __c = _S_error();
     else if (__incr() == _M_last) [[unlikely]]
       __c = _S_error();
     else
       {
  __c = (__c << 6) | (__u & 0x3F);
  __u = *_M_curr();

  if (__u < __lo_bound || __u > __hi_bound) [[unlikely]]
    __c = _S_error();
  else
    {
      __c = (__c << 6) | (__u & 0x3F);
      __incr();
    }
       }
   }
 else if (__u <= 0xF4)
   {
     const uint8_t __lo_bound_2 = __u == 0xF0 ? 0x90 : __lo_bound;
     const uint8_t __hi_bound_2 = __u == 0xF4 ? 0x8F : __hi_bound;

     __c = __u & 0x07;
     __u = *_M_curr();

     if (__u < __lo_bound_2 || __u > __hi_bound_2) [[unlikely]]
       __c = _S_error();
     else if (__incr() == _M_last) [[unlikely]]
       __c = _S_error();
     else
       {
  __c = (__c << 6) | (__u & 0x3F);
  __u = *_M_curr();

  if (__u < __lo_bound || __u > __hi_bound) [[unlikely]]
    __c = _S_error();
  else if (__incr() == _M_last) [[unlikely]]
    __c = _S_error();
  else
    {
      __c = (__c << 6) | (__u & 0x3F);
      __u = *_M_curr();

      if (__u < __lo_bound || __u > __hi_bound) [[unlikely]]
        __c = _S_error();
      else
        {
   __c = (__c << 6) | (__u & 0x3F);
   __incr();
        }
    }
       }
   }
 else [[unlikely]]
   __c = _S_error();

 _M_update(__c, __to_incr);
      }

      constexpr void
      _M_read_utf16()
      {
 _Guard<_Iter> __g{this, _M_curr()};
 char32_t __c{};
 uint16_t __u = *_M_curr()++;
 uint8_t __to_incr = 1;

 if (__u < 0xD800 || __u > 0xDFFF) [[likely]]
   __c = __u;
 else if (__u < 0xDC00 && _M_curr() != _M_last)
   {
     uint16_t __u2 = *_M_curr();
     if (__u2 < 0xDC00 || __u2 > 0xDFFF) [[unlikely]]
       __c = _S_error();
     else
       {
  ++_M_curr();
  __to_incr = 2;
  uint32_t __x = (__u & 0x3F) << 10 | __u2 & 0x3FF;
  uint32_t __w = (__u >> 6) & 0x1F;
  __c = (__w + 1) << 16 | __x;
       }
   }
 else
   __c = _S_error();

 _M_update(__c, __to_incr);
      }

      constexpr void
      _M_read_utf32()
      {
 _Guard<_Iter> __g{this, _M_curr()};
 char32_t __c = *_M_curr()++;
 if (!__is_scalar_value(__c)) [[unlikely]]
   __c = _S_error();
 _M_update(__c, 1);
      }


      constexpr void
      _M_update(char32_t __c, uint8_t __to_incr)
      {
 _M_to_increment = __to_incr;
 _M_buf_index = 0;
 if constexpr (sizeof(_ToFmt) == sizeof(uint32_t))
   {
     _M_buf[0] = __c;
     _M_buf_last = 1;
   }
 else if constexpr (sizeof(_ToFmt) == sizeof(uint16_t))
   {
     if (__is_single_code_unit<_ToFmt>(__c))
       {
  _M_buf[0] = __c;
  _M_buf[1] = 0;
  _M_buf_last = 1;
       }
     else
       {

  const char32_t __lead_offset = 0xD800 - (0x10000 >> 10);
  char16_t __lead = __lead_offset + (__c >> 10);
  char16_t __trail = 0xDC00 + (__c & 0x3FF);
  _M_buf[0] = __lead;
  _M_buf[1] = __trail;
  _M_buf_last = 2;
       }
   }
 else
   {
     static_assert(sizeof(_ToFmt) == 1);
     int __bits = std::bit_width((uint32_t)__c);
     if (__bits <= 7) [[likely]]
       {
  _M_buf[0] = __c;
  _M_buf[1] = _M_buf[2] = _M_buf[3] = 0;
  _M_buf_last = 1;
       }
     else if (__bits <= 11)
       {
  _M_buf[0] = 0xC0 | (__c >> 6);
  _M_buf[1] = 0x80 | (__c & 0x3F);
  _M_buf[2] = _M_buf[3] = 0;
  _M_buf_last = 2;
       }
     else if (__bits <= 16)
       {
  _M_buf[0] = 0xE0 | (__c >> 12);
  _M_buf[1] = 0x80 | ((__c >> 6) & 0x3F);
  _M_buf[2] = 0x80 | (__c & 0x3F);
  _M_buf[3] = 0;
  _M_buf_last = 3;
       }
     else
       {
  _M_buf[0] = 0xF0 | ((__c >> 18) & 0x07);
  _M_buf[1] = 0x80 | ((__c >> 12) & 0x3F);
  _M_buf[2] = 0x80 | ((__c >> 6) & 0x3F);
  _M_buf[3] = 0x80 | (__c & 0x3F);
  _M_buf_last = 4;
       }
   }
      }

      constexpr char32_t
      _S_error()
      {
 char32_t __c = _ErrorHandler()();
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__is_scalar_value(__c)), false)) std::__glibcxx_assert_fail(); } while (false);
 return __c;
      }

      constexpr _Iter
      _M_first() const requires bidirectional_iterator<_Iter>
      { return _M_first_and_curr._M_first; }

      constexpr _Iter&
      _M_curr() { return _M_first_and_curr._M_curr; }

      constexpr _Iter
      _M_curr() const { return _M_first_and_curr._M_curr; }

      array<value_type, 4 / sizeof(_ToFmt)> _M_buf;

      template<typename _It>
 struct _First_and_curr
 {
   _First_and_curr() = default;

   constexpr
   _First_and_curr(_It __curr) : _M_curr(__curr) { }

   template<convertible_to<_It> _It2>
     constexpr
     _First_and_curr(const _First_and_curr<_It2>& __other)
     : _M_curr(__other._M_curr) { }

   _It _M_curr;
 };

      template<typename _It> requires bidirectional_iterator<_It>
 struct _First_and_curr<_It>
 {
   _First_and_curr() = default;

   constexpr
   _First_and_curr(_It __first, _It __curr)
   : _M_first(__first), _M_curr(__curr) { }

   template<convertible_to<_It> _It2>
     constexpr
     _First_and_curr(const _First_and_curr<_It2>& __other)
     : _M_first(__other._M_first), _M_curr(__other._M_curr) { }

   _It _M_first;
   _It _M_curr;
 };

      _First_and_curr<_Iter> _M_first_and_curr;

      uint8_t _M_buf_index = 0;
      uint8_t _M_buf_last = 0;
      uint8_t _M_to_increment = 0;

      [[no_unique_address]] _Sent _M_last;

      template<typename _FromFmt2, typename _ToFmt2,
        input_iterator _Iter2, sentinel_for<_Iter2> _Sent2,
        typename _ErrHandler>
 requires convertible_to<iter_value_t<_Iter2>, _FromFmt2>
 friend class _Utf_iterator;
    };

  template<typename _ToFormat, ranges::input_range _Range>
    class _Utf_view
    : public ranges::view_interface<_Utf_view<_ToFormat, _Range>>
    {
      using _Iterator = _Utf_iterator<ranges::range_value_t<_Range>,
          _ToFormat, ranges::iterator_t<_Range>,
          ranges::sentinel_t<_Range>>;

      template<typename _Iter, typename _Sent>
 constexpr auto
 _M_begin(_Iter __first, _Sent __last)
 {
   if constexpr (bidirectional_iterator<_Iter>)
     return _Iterator(__first, __first, __last);
   else
     return _Iterator(__first, __last);
 }

      template<typename _Iter, typename _Sent>
 constexpr auto
 _M_end(_Iter __first, _Sent __last)
 {
   if constexpr (!is_same_v<_Iter, _Sent>)
     return __last;
   else if constexpr (bidirectional_iterator<_Iter>)
     return _Iterator(__first, __last, __last);
   else
     return _Iterator(__last, __last);
 }

      _Range _M_base;

    public:
      constexpr explicit
      _Utf_view(_Range&& __r) : _M_base(std::forward<_Range>(__r)) { }

      constexpr auto begin()
      { return _M_begin(ranges::begin(_M_base), ranges::end(_M_base)); }

      constexpr auto end()
      { return _M_end(ranges::begin(_M_base), ranges::end(_M_base)); }

      constexpr bool empty() const { return ranges::empty(_M_base); }
    };


  template<typename _View>
    using _Utf8_view = _Utf_view<char8_t, _View>;




  template<typename _View>
    using _Utf16_view = _Utf_view<char16_t, _View>;
  template<typename _View>
    using _Utf32_view = _Utf_view<char32_t, _View>;

inline namespace __v15_1_0
{

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unicode-data.h" 1 3
# 38 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unicode-data.h" 3
  inline constexpr char32_t __width_edges[] = {
    0x1100, 0x1160, 0x231a, 0x231c, 0x2329, 0x232b, 0x23e9, 0x23ed,
    0x23f0, 0x23f1, 0x23f3, 0x23f4, 0x25fd, 0x25ff, 0x2614, 0x2616,
    0x2648, 0x2654, 0x267f, 0x2680, 0x2693, 0x2694, 0x26a1, 0x26a2,
    0x26aa, 0x26ac, 0x26bd, 0x26bf, 0x26c4, 0x26c6, 0x26ce, 0x26cf,
    0x26d4, 0x26d5, 0x26ea, 0x26eb, 0x26f2, 0x26f4, 0x26f5, 0x26f6,
    0x26fa, 0x26fb, 0x26fd, 0x26fe, 0x2705, 0x2706, 0x270a, 0x270c,
    0x2728, 0x2729, 0x274c, 0x274d, 0x274e, 0x274f, 0x2753, 0x2756,
    0x2757, 0x2758, 0x2795, 0x2798, 0x27b0, 0x27b1, 0x27bf, 0x27c0,
    0x2b1b, 0x2b1d, 0x2b50, 0x2b51, 0x2b55, 0x2b56, 0x2e80, 0x2e9a,
    0x2e9b, 0x2ef4, 0x2f00, 0x2fd6, 0x2ff0, 0x303f, 0x3041, 0x3097,
    0x3099, 0x3100, 0x3105, 0x3130, 0x3131, 0x318f, 0x3190, 0x31e4,
    0x31ef, 0x321f, 0x3220, 0x3248, 0x3250, 0xa48d, 0xa490, 0xa4c7,
    0xa960, 0xa97d, 0xac00, 0xd7a4, 0xf900, 0xfb00, 0xfe10, 0xfe1a,
    0xfe30, 0xfe53, 0xfe54, 0xfe67, 0xfe68, 0xfe6c, 0xff01, 0xff61,
    0xffe0, 0xffe7, 0x16fe0, 0x16fe5, 0x16ff0, 0x16ff2, 0x17000, 0x187f8,
    0x18800, 0x18cd6, 0x18d00, 0x18d09, 0x1aff0, 0x1aff4, 0x1aff5, 0x1affc,
    0x1affd, 0x1afff, 0x1b000, 0x1b123, 0x1b132, 0x1b133, 0x1b150, 0x1b153,
    0x1b155, 0x1b156, 0x1b164, 0x1b168, 0x1b170, 0x1b2fc, 0x1f004, 0x1f005,
    0x1f0cf, 0x1f0d0, 0x1f18e, 0x1f18f, 0x1f191, 0x1f19b, 0x1f200, 0x1f203,
    0x1f210, 0x1f23c, 0x1f240, 0x1f249, 0x1f250, 0x1f252, 0x1f260, 0x1f266,
    0x1f300, 0x1f650, 0x1f680, 0x1f6c6, 0x1f6cc, 0x1f6cd, 0x1f6d0, 0x1f6d3,
    0x1f6d5, 0x1f6d8, 0x1f6dc, 0x1f6e0, 0x1f6eb, 0x1f6ed, 0x1f6f4, 0x1f6fd,
    0x1f7e0, 0x1f7ec, 0x1f7f0, 0x1f7f1, 0x1f900, 0x1fa00, 0x1fa70, 0x1fa7d,
    0x1fa80, 0x1fa89, 0x1fa90, 0x1fabe, 0x1fabf, 0x1fac6, 0x1face, 0x1fadc,
    0x1fae0, 0x1fae9, 0x1faf0, 0x1faf9, 0x20000, 0x2fffe, 0x30000, 0x3fffe,
  };

  enum class _Gcb_property {
    _Gcb_Other = 0,
    _Gcb_Control = 1,
    _Gcb_LF = 2,
    _Gcb_CR = 3,
    _Gcb_Extend = 4,
    _Gcb_Prepend = 5,
    _Gcb_SpacingMark = 6,
    _Gcb_L = 7,
    _Gcb_V = 8,
    _Gcb_T = 9,
    _Gcb_ZWJ = 10,
    _Gcb_LV = 11,
    _Gcb_LVT = 12,
    _Gcb_Regional_Indicator = 13,
  };




  inline constexpr int __gcb_shift_bits = 0x4;
  inline constexpr uint32_t __gcb_edges[] = {
    0x1, 0xa2, 0xb1, 0xd3, 0xe1, 0x200,
    0x7f1, 0xa00, 0xad1, 0xae0, 0x3004, 0x3700,
    0x4834, 0x48a0, 0x5914, 0x5be0, 0x5bf4, 0x5c00,
    0x5c14, 0x5c30, 0x5c44, 0x5c60, 0x5c74, 0x5c80,
    0x6005, 0x6060, 0x6104, 0x61b0, 0x61c1, 0x61d0,
    0x64b4, 0x6600, 0x6704, 0x6710, 0x6d64, 0x6dd5,
    0x6de0, 0x6df4, 0x6e50, 0x6e74, 0x6e90, 0x6ea4,
    0x6ee0, 0x70f5, 0x7100, 0x7114, 0x7120, 0x7304,
    0x74b0, 0x7a64, 0x7b10, 0x7eb4, 0x7f40, 0x7fd4,
    0x7fe0, 0x8164, 0x81a0, 0x81b4, 0x8240, 0x8254,
    0x8280, 0x8294, 0x82e0, 0x8594, 0x85c0, 0x8905,
    0x8920, 0x8984, 0x8a00, 0x8ca4, 0x8e25, 0x8e34,
    0x9036, 0x9040, 0x93a4, 0x93b6, 0x93c4, 0x93d0,
    0x93e6, 0x9414, 0x9496, 0x94d4, 0x94e6, 0x9500,
    0x9514, 0x9580, 0x9624, 0x9640, 0x9814, 0x9826,
    0x9840, 0x9bc4, 0x9bd0, 0x9be4, 0x9bf6, 0x9c14,
    0x9c50, 0x9c76, 0x9c90, 0x9cb6, 0x9cd4, 0x9ce0,
    0x9d74, 0x9d80, 0x9e24, 0x9e40, 0x9fe4, 0x9ff0,
    0xa014, 0xa036, 0xa040, 0xa3c4, 0xa3d0, 0xa3e6,
    0xa414, 0xa430, 0xa474, 0xa490, 0xa4b4, 0xa4e0,
    0xa514, 0xa520, 0xa704, 0xa720, 0xa754, 0xa760,
    0xa814, 0xa836, 0xa840, 0xabc4, 0xabd0, 0xabe6,
    0xac14, 0xac60, 0xac74, 0xac96, 0xaca0, 0xacb6,
    0xacd4, 0xace0, 0xae24, 0xae40, 0xafa4, 0xb000,
    0xb014, 0xb026, 0xb040, 0xb3c4, 0xb3d0, 0xb3e4,
    0xb406, 0xb414, 0xb450, 0xb476, 0xb490, 0xb4b6,
    0xb4d4, 0xb4e0, 0xb554, 0xb580, 0xb624, 0xb640,
    0xb824, 0xb830, 0xbbe4, 0xbbf6, 0xbc04, 0xbc16,
    0xbc30, 0xbc66, 0xbc90, 0xbca6, 0xbcd4, 0xbce0,
    0xbd74, 0xbd80, 0xc004, 0xc016, 0xc044, 0xc050,
    0xc3c4, 0xc3d0, 0xc3e4, 0xc416, 0xc450, 0xc464,
    0xc490, 0xc4a4, 0xc4e0, 0xc554, 0xc570, 0xc624,
    0xc640, 0xc814, 0xc826, 0xc840, 0xcbc4, 0xcbd0,
    0xcbe6, 0xcbf4, 0xcc06, 0xcc24, 0xcc36, 0xcc50,
    0xcc64, 0xcc76, 0xcc90, 0xcca6, 0xccc4, 0xcce0,
    0xcd54, 0xcd70, 0xce24, 0xce40, 0xcf36, 0xcf40,
    0xd004, 0xd026, 0xd040, 0xd3b4, 0xd3d0, 0xd3e4,
    0xd3f6, 0xd414, 0xd450, 0xd466, 0xd490, 0xd4a6,
    0xd4d4, 0xd4e5, 0xd4f0, 0xd574, 0xd580, 0xd624,
    0xd640, 0xd814, 0xd826, 0xd840, 0xdca4, 0xdcb0,
    0xdcf4, 0xdd06, 0xdd24, 0xdd50, 0xdd64, 0xdd70,
    0xdd86, 0xddf4, 0xde00, 0xdf26, 0xdf40, 0xe314,
    0xe320, 0xe336, 0xe344, 0xe3b0, 0xe474, 0xe4f0,
    0xeb14, 0xeb20, 0xeb36, 0xeb44, 0xebd0, 0xec84,
    0xecf0, 0xf184, 0xf1a0, 0xf354, 0xf360, 0xf374,
    0xf380, 0xf394, 0xf3a0, 0xf3e6, 0xf400, 0xf714,
    0xf7f6, 0xf804, 0xf850, 0xf864, 0xf880, 0xf8d4,
    0xf980, 0xf994, 0xfbd0, 0xfc64, 0xfc70, 0x102d4,
    0x10316, 0x10324, 0x10380, 0x10394, 0x103b6, 0x103d4,
    0x103f0, 0x10566, 0x10584, 0x105a0, 0x105e4, 0x10610,
    0x10714, 0x10750, 0x10824, 0x10830, 0x10846, 0x10854,
    0x10870, 0x108d4, 0x108e0, 0x109d4, 0x109e0, 0x11007,
    0x11608, 0x11a89, 0x12000, 0x135d4, 0x13600, 0x17124,
    0x17156, 0x17160, 0x17324, 0x17346, 0x17350, 0x17524,
    0x17540, 0x17724, 0x17740, 0x17b44, 0x17b66, 0x17b74,
    0x17be6, 0x17c64, 0x17c76, 0x17c94, 0x17d40, 0x17dd4,
    0x17de0, 0x180b4, 0x180e1, 0x180f4, 0x18100, 0x18854,
    0x18870, 0x18a94, 0x18aa0, 0x19204, 0x19236, 0x19274,
    0x19296, 0x192c0, 0x19306, 0x19324, 0x19336, 0x19394,
    0x193c0, 0x1a174, 0x1a196, 0x1a1b4, 0x1a1c0, 0x1a556,
    0x1a564, 0x1a576, 0x1a584, 0x1a5f0, 0x1a604, 0x1a610,
    0x1a624, 0x1a630, 0x1a654, 0x1a6d6, 0x1a734, 0x1a7d0,
    0x1a7f4, 0x1a800, 0x1ab04, 0x1acf0, 0x1b004, 0x1b046,
    0x1b050, 0x1b344, 0x1b3b6, 0x1b3c4, 0x1b3d6, 0x1b424,
    0x1b436, 0x1b450, 0x1b6b4, 0x1b740, 0x1b804, 0x1b826,
    0x1b830, 0x1ba16, 0x1ba24, 0x1ba66, 0x1ba84, 0x1baa6,
    0x1bab4, 0x1bae0, 0x1be64, 0x1be76, 0x1be84, 0x1bea6,
    0x1bed4, 0x1bee6, 0x1bef4, 0x1bf26, 0x1bf40, 0x1c246,
    0x1c2c4, 0x1c346, 0x1c364, 0x1c380, 0x1cd04, 0x1cd30,
    0x1cd44, 0x1ce16, 0x1ce24, 0x1ce90, 0x1ced4, 0x1cee0,
    0x1cf44, 0x1cf50, 0x1cf76, 0x1cf84, 0x1cfa0, 0x1dc04,
    0x1e000, 0x200b1, 0x200c4, 0x200da, 0x200e1, 0x20100,
    0x20281, 0x202f0, 0x20601, 0x20700, 0x20d04, 0x20f10,
    0x2cef4, 0x2cf20, 0x2d7f4, 0x2d800, 0x2de04, 0x2e000,
    0x302a4, 0x30300, 0x30994, 0x309b0, 0xa66f4, 0xa6730,
    0xa6744, 0xa67e0, 0xa69e4, 0xa6a00, 0xa6f04, 0xa6f20,
    0xa8024, 0xa8030, 0xa8064, 0xa8070, 0xa80b4, 0xa80c0,
    0xa8236, 0xa8254, 0xa8276, 0xa8280, 0xa82c4, 0xa82d0,
    0xa8806, 0xa8820, 0xa8b46, 0xa8c44, 0xa8c60, 0xa8e04,
    0xa8f20, 0xa8ff4, 0xa9000, 0xa9264, 0xa92e0, 0xa9474,
    0xa9526, 0xa9540, 0xa9607, 0xa97d0, 0xa9804, 0xa9836,
    0xa9840, 0xa9b34, 0xa9b46, 0xa9b64, 0xa9ba6, 0xa9bc4,
    0xa9be6, 0xa9c10, 0xa9e54, 0xa9e60, 0xaa294, 0xaa2f6,
    0xaa314, 0xaa336, 0xaa354, 0xaa370, 0xaa434, 0xaa440,
    0xaa4c4, 0xaa4d6, 0xaa4e0, 0xaa7c4, 0xaa7d0, 0xaab04,
    0xaab10, 0xaab24, 0xaab50, 0xaab74, 0xaab90, 0xaabe4,
    0xaac00, 0xaac14, 0xaac20, 0xaaeb6, 0xaaec4, 0xaaee6,
    0xaaf00, 0xaaf56, 0xaaf64, 0xaaf70, 0xabe36, 0xabe54,
    0xabe66, 0xabe84, 0xabe96, 0xabeb0, 0xabec6, 0xabed4,
    0xabee0, 0xac00b, 0xac01c, 0xac1cb, 0xac1dc, 0xac38b,
    0xac39c, 0xac54b, 0xac55c, 0xac70b, 0xac71c, 0xac8cb,
    0xac8dc, 0xaca8b, 0xaca9c, 0xacc4b, 0xacc5c, 0xace0b,
    0xace1c, 0xacfcb, 0xacfdc, 0xad18b, 0xad19c, 0xad34b,
    0xad35c, 0xad50b, 0xad51c, 0xad6cb, 0xad6dc, 0xad88b,
    0xad89c, 0xada4b, 0xada5c, 0xadc0b, 0xadc1c, 0xaddcb,
    0xadddc, 0xadf8b, 0xadf9c, 0xae14b, 0xae15c, 0xae30b,
    0xae31c, 0xae4cb, 0xae4dc, 0xae68b, 0xae69c, 0xae84b,
    0xae85c, 0xaea0b, 0xaea1c, 0xaebcb, 0xaebdc, 0xaed8b,
    0xaed9c, 0xaef4b, 0xaef5c, 0xaf10b, 0xaf11c, 0xaf2cb,
    0xaf2dc, 0xaf48b, 0xaf49c, 0xaf64b, 0xaf65c, 0xaf80b,
    0xaf81c, 0xaf9cb, 0xaf9dc, 0xafb8b, 0xafb9c, 0xafd4b,
    0xafd5c, 0xaff0b, 0xaff1c, 0xb00cb, 0xb00dc, 0xb028b,
    0xb029c, 0xb044b, 0xb045c, 0xb060b, 0xb061c, 0xb07cb,
    0xb07dc, 0xb098b, 0xb099c, 0xb0b4b, 0xb0b5c, 0xb0d0b,
    0xb0d1c, 0xb0ecb, 0xb0edc, 0xb108b, 0xb109c, 0xb124b,
    0xb125c, 0xb140b, 0xb141c, 0xb15cb, 0xb15dc, 0xb178b,
    0xb179c, 0xb194b, 0xb195c, 0xb1b0b, 0xb1b1c, 0xb1ccb,
    0xb1cdc, 0xb1e8b, 0xb1e9c, 0xb204b, 0xb205c, 0xb220b,
    0xb221c, 0xb23cb, 0xb23dc, 0xb258b, 0xb259c, 0xb274b,
    0xb275c, 0xb290b, 0xb291c, 0xb2acb, 0xb2adc, 0xb2c8b,
    0xb2c9c, 0xb2e4b, 0xb2e5c, 0xb300b, 0xb301c, 0xb31cb,
    0xb31dc, 0xb338b, 0xb339c, 0xb354b, 0xb355c, 0xb370b,
    0xb371c, 0xb38cb, 0xb38dc, 0xb3a8b, 0xb3a9c, 0xb3c4b,
    0xb3c5c, 0xb3e0b, 0xb3e1c, 0xb3fcb, 0xb3fdc, 0xb418b,
    0xb419c, 0xb434b, 0xb435c, 0xb450b, 0xb451c, 0xb46cb,
    0xb46dc, 0xb488b, 0xb489c, 0xb4a4b, 0xb4a5c, 0xb4c0b,
    0xb4c1c, 0xb4dcb, 0xb4ddc, 0xb4f8b, 0xb4f9c, 0xb514b,
    0xb515c, 0xb530b, 0xb531c, 0xb54cb, 0xb54dc, 0xb568b,
    0xb569c, 0xb584b, 0xb585c, 0xb5a0b, 0xb5a1c, 0xb5bcb,
    0xb5bdc, 0xb5d8b, 0xb5d9c, 0xb5f4b, 0xb5f5c, 0xb610b,
    0xb611c, 0xb62cb, 0xb62dc, 0xb648b, 0xb649c, 0xb664b,
    0xb665c, 0xb680b, 0xb681c, 0xb69cb, 0xb69dc, 0xb6b8b,
    0xb6b9c, 0xb6d4b, 0xb6d5c, 0xb6f0b, 0xb6f1c, 0xb70cb,
    0xb70dc, 0xb728b, 0xb729c, 0xb744b, 0xb745c, 0xb760b,
    0xb761c, 0xb77cb, 0xb77dc, 0xb798b, 0xb799c, 0xb7b4b,
    0xb7b5c, 0xb7d0b, 0xb7d1c, 0xb7ecb, 0xb7edc, 0xb808b,
    0xb809c, 0xb824b, 0xb825c, 0xb840b, 0xb841c, 0xb85cb,
    0xb85dc, 0xb878b, 0xb879c, 0xb894b, 0xb895c, 0xb8b0b,
    0xb8b1c, 0xb8ccb, 0xb8cdc, 0xb8e8b, 0xb8e9c, 0xb904b,
    0xb905c, 0xb920b, 0xb921c, 0xb93cb, 0xb93dc, 0xb958b,
    0xb959c, 0xb974b, 0xb975c, 0xb990b, 0xb991c, 0xb9acb,
    0xb9adc, 0xb9c8b, 0xb9c9c, 0xb9e4b, 0xb9e5c, 0xba00b,
    0xba01c, 0xba1cb, 0xba1dc, 0xba38b, 0xba39c, 0xba54b,
    0xba55c, 0xba70b, 0xba71c, 0xba8cb, 0xba8dc, 0xbaa8b,
    0xbaa9c, 0xbac4b, 0xbac5c, 0xbae0b, 0xbae1c, 0xbafcb,
    0xbafdc, 0xbb18b, 0xbb19c, 0xbb34b, 0xbb35c, 0xbb50b,
    0xbb51c, 0xbb6cb, 0xbb6dc, 0xbb88b, 0xbb89c, 0xbba4b,
    0xbba5c, 0xbbc0b, 0xbbc1c, 0xbbdcb, 0xbbddc, 0xbbf8b,
    0xbbf9c, 0xbc14b, 0xbc15c, 0xbc30b, 0xbc31c, 0xbc4cb,
    0xbc4dc, 0xbc68b, 0xbc69c, 0xbc84b, 0xbc85c, 0xbca0b,
    0xbca1c, 0xbcbcb, 0xbcbdc, 0xbcd8b, 0xbcd9c, 0xbcf4b,
    0xbcf5c, 0xbd10b, 0xbd11c, 0xbd2cb, 0xbd2dc, 0xbd48b,
    0xbd49c, 0xbd64b, 0xbd65c, 0xbd80b, 0xbd81c, 0xbd9cb,
    0xbd9dc, 0xbdb8b, 0xbdb9c, 0xbdd4b, 0xbdd5c, 0xbdf0b,
    0xbdf1c, 0xbe0cb, 0xbe0dc, 0xbe28b, 0xbe29c, 0xbe44b,
    0xbe45c, 0xbe60b, 0xbe61c, 0xbe7cb, 0xbe7dc, 0xbe98b,
    0xbe99c, 0xbeb4b, 0xbeb5c, 0xbed0b, 0xbed1c, 0xbeecb,
    0xbeedc, 0xbf08b, 0xbf09c, 0xbf24b, 0xbf25c, 0xbf40b,
    0xbf41c, 0xbf5cb, 0xbf5dc, 0xbf78b, 0xbf79c, 0xbf94b,
    0xbf95c, 0xbfb0b, 0xbfb1c, 0xbfccb, 0xbfcdc, 0xbfe8b,
    0xbfe9c, 0xc004b, 0xc005c, 0xc020b, 0xc021c, 0xc03cb,
    0xc03dc, 0xc058b, 0xc059c, 0xc074b, 0xc075c, 0xc090b,
    0xc091c, 0xc0acb, 0xc0adc, 0xc0c8b, 0xc0c9c, 0xc0e4b,
    0xc0e5c, 0xc100b, 0xc101c, 0xc11cb, 0xc11dc, 0xc138b,
    0xc139c, 0xc154b, 0xc155c, 0xc170b, 0xc171c, 0xc18cb,
    0xc18dc, 0xc1a8b, 0xc1a9c, 0xc1c4b, 0xc1c5c, 0xc1e0b,
    0xc1e1c, 0xc1fcb, 0xc1fdc, 0xc218b, 0xc219c, 0xc234b,
    0xc235c, 0xc250b, 0xc251c, 0xc26cb, 0xc26dc, 0xc288b,
    0xc289c, 0xc2a4b, 0xc2a5c, 0xc2c0b, 0xc2c1c, 0xc2dcb,
    0xc2ddc, 0xc2f8b, 0xc2f9c, 0xc314b, 0xc315c, 0xc330b,
    0xc331c, 0xc34cb, 0xc34dc, 0xc368b, 0xc369c, 0xc384b,
    0xc385c, 0xc3a0b, 0xc3a1c, 0xc3bcb, 0xc3bdc, 0xc3d8b,
    0xc3d9c, 0xc3f4b, 0xc3f5c, 0xc410b, 0xc411c, 0xc42cb,
    0xc42dc, 0xc448b, 0xc449c, 0xc464b, 0xc465c, 0xc480b,
    0xc481c, 0xc49cb, 0xc49dc, 0xc4b8b, 0xc4b9c, 0xc4d4b,
    0xc4d5c, 0xc4f0b, 0xc4f1c, 0xc50cb, 0xc50dc, 0xc528b,
    0xc529c, 0xc544b, 0xc545c, 0xc560b, 0xc561c, 0xc57cb,
    0xc57dc, 0xc598b, 0xc599c, 0xc5b4b, 0xc5b5c, 0xc5d0b,
    0xc5d1c, 0xc5ecb, 0xc5edc, 0xc608b, 0xc609c, 0xc624b,
    0xc625c, 0xc640b, 0xc641c, 0xc65cb, 0xc65dc, 0xc678b,
    0xc679c, 0xc694b, 0xc695c, 0xc6b0b, 0xc6b1c, 0xc6ccb,
    0xc6cdc, 0xc6e8b, 0xc6e9c, 0xc704b, 0xc705c, 0xc720b,
    0xc721c, 0xc73cb, 0xc73dc, 0xc758b, 0xc759c, 0xc774b,
    0xc775c, 0xc790b, 0xc791c, 0xc7acb, 0xc7adc, 0xc7c8b,
    0xc7c9c, 0xc7e4b, 0xc7e5c, 0xc800b, 0xc801c, 0xc81cb,
    0xc81dc, 0xc838b, 0xc839c, 0xc854b, 0xc855c, 0xc870b,
    0xc871c, 0xc88cb, 0xc88dc, 0xc8a8b, 0xc8a9c, 0xc8c4b,
    0xc8c5c, 0xc8e0b, 0xc8e1c, 0xc8fcb, 0xc8fdc, 0xc918b,
    0xc919c, 0xc934b, 0xc935c, 0xc950b, 0xc951c, 0xc96cb,
    0xc96dc, 0xc988b, 0xc989c, 0xc9a4b, 0xc9a5c, 0xc9c0b,
    0xc9c1c, 0xc9dcb, 0xc9ddc, 0xc9f8b, 0xc9f9c, 0xca14b,
    0xca15c, 0xca30b, 0xca31c, 0xca4cb, 0xca4dc, 0xca68b,
    0xca69c, 0xca84b, 0xca85c, 0xcaa0b, 0xcaa1c, 0xcabcb,
    0xcabdc, 0xcad8b, 0xcad9c, 0xcaf4b, 0xcaf5c, 0xcb10b,
    0xcb11c, 0xcb2cb, 0xcb2dc, 0xcb48b, 0xcb49c, 0xcb64b,
    0xcb65c, 0xcb80b, 0xcb81c, 0xcb9cb, 0xcb9dc, 0xcbb8b,
    0xcbb9c, 0xcbd4b, 0xcbd5c, 0xcbf0b, 0xcbf1c, 0xcc0cb,
    0xcc0dc, 0xcc28b, 0xcc29c, 0xcc44b, 0xcc45c, 0xcc60b,
    0xcc61c, 0xcc7cb, 0xcc7dc, 0xcc98b, 0xcc99c, 0xccb4b,
    0xccb5c, 0xccd0b, 0xccd1c, 0xccecb, 0xccedc, 0xcd08b,
    0xcd09c, 0xcd24b, 0xcd25c, 0xcd40b, 0xcd41c, 0xcd5cb,
    0xcd5dc, 0xcd78b, 0xcd79c, 0xcd94b, 0xcd95c, 0xcdb0b,
    0xcdb1c, 0xcdccb, 0xcdcdc, 0xcde8b, 0xcde9c, 0xce04b,
    0xce05c, 0xce20b, 0xce21c, 0xce3cb, 0xce3dc, 0xce58b,
    0xce59c, 0xce74b, 0xce75c, 0xce90b, 0xce91c, 0xceacb,
    0xceadc, 0xcec8b, 0xcec9c, 0xcee4b, 0xcee5c, 0xcf00b,
    0xcf01c, 0xcf1cb, 0xcf1dc, 0xcf38b, 0xcf39c, 0xcf54b,
    0xcf55c, 0xcf70b, 0xcf71c, 0xcf8cb, 0xcf8dc, 0xcfa8b,
    0xcfa9c, 0xcfc4b, 0xcfc5c, 0xcfe0b, 0xcfe1c, 0xcffcb,
    0xcffdc, 0xd018b, 0xd019c, 0xd034b, 0xd035c, 0xd050b,
    0xd051c, 0xd06cb, 0xd06dc, 0xd088b, 0xd089c, 0xd0a4b,
    0xd0a5c, 0xd0c0b, 0xd0c1c, 0xd0dcb, 0xd0ddc, 0xd0f8b,
    0xd0f9c, 0xd114b, 0xd115c, 0xd130b, 0xd131c, 0xd14cb,
    0xd14dc, 0xd168b, 0xd169c, 0xd184b, 0xd185c, 0xd1a0b,
    0xd1a1c, 0xd1bcb, 0xd1bdc, 0xd1d8b, 0xd1d9c, 0xd1f4b,
    0xd1f5c, 0xd210b, 0xd211c, 0xd22cb, 0xd22dc, 0xd248b,
    0xd249c, 0xd264b, 0xd265c, 0xd280b, 0xd281c, 0xd29cb,
    0xd29dc, 0xd2b8b, 0xd2b9c, 0xd2d4b, 0xd2d5c, 0xd2f0b,
    0xd2f1c, 0xd30cb, 0xd30dc, 0xd328b, 0xd329c, 0xd344b,
    0xd345c, 0xd360b, 0xd361c, 0xd37cb, 0xd37dc, 0xd398b,
    0xd399c, 0xd3b4b, 0xd3b5c, 0xd3d0b, 0xd3d1c, 0xd3ecb,
    0xd3edc, 0xd408b, 0xd409c, 0xd424b, 0xd425c, 0xd440b,
    0xd441c, 0xd45cb, 0xd45dc, 0xd478b, 0xd479c, 0xd494b,
    0xd495c, 0xd4b0b, 0xd4b1c, 0xd4ccb, 0xd4cdc, 0xd4e8b,
    0xd4e9c, 0xd504b, 0xd505c, 0xd520b, 0xd521c, 0xd53cb,
    0xd53dc, 0xd558b, 0xd559c, 0xd574b, 0xd575c, 0xd590b,
    0xd591c, 0xd5acb, 0xd5adc, 0xd5c8b, 0xd5c9c, 0xd5e4b,
    0xd5e5c, 0xd600b, 0xd601c, 0xd61cb, 0xd61dc, 0xd638b,
    0xd639c, 0xd654b, 0xd655c, 0xd670b, 0xd671c, 0xd68cb,
    0xd68dc, 0xd6a8b, 0xd6a9c, 0xd6c4b, 0xd6c5c, 0xd6e0b,
    0xd6e1c, 0xd6fcb, 0xd6fdc, 0xd718b, 0xd719c, 0xd734b,
    0xd735c, 0xd750b, 0xd751c, 0xd76cb, 0xd76dc, 0xd788b,
    0xd789c, 0xd7a40, 0xd7b08, 0xd7c70, 0xd7cb9, 0xd7fc0,
    0xfb1e4, 0xfb1f0, 0xfe004, 0xfe100, 0xfe204, 0xfe300,
    0xfeff1, 0xff000, 0xff9e4, 0xffa00, 0xfff01, 0xfffc0,
    0x101fd4, 0x101fe0, 0x102e04, 0x102e10, 0x103764, 0x1037b0,
    0x10a014, 0x10a040, 0x10a054, 0x10a070, 0x10a0c4, 0x10a100,
    0x10a384, 0x10a3b0, 0x10a3f4, 0x10a400, 0x10ae54, 0x10ae70,
    0x10d244, 0x10d280, 0x10eab4, 0x10ead0, 0x10efd4, 0x10f000,
    0x10f464, 0x10f510, 0x10f824, 0x10f860, 0x110006, 0x110014,
    0x110026, 0x110030, 0x110384, 0x110470, 0x110704, 0x110710,
    0x110734, 0x110750, 0x1107f4, 0x110826, 0x110830, 0x110b06,
    0x110b34, 0x110b76, 0x110b94, 0x110bb0, 0x110bd5, 0x110be0,
    0x110c24, 0x110c30, 0x110cd5, 0x110ce0, 0x111004, 0x111030,
    0x111274, 0x1112c6, 0x1112d4, 0x111350, 0x111456, 0x111470,
    0x111734, 0x111740, 0x111804, 0x111826, 0x111830, 0x111b36,
    0x111b64, 0x111bf6, 0x111c10, 0x111c25, 0x111c40, 0x111c94,
    0x111cd0, 0x111ce6, 0x111cf4, 0x111d00, 0x1122c6, 0x1122f4,
    0x112326, 0x112344, 0x112356, 0x112364, 0x112380, 0x1123e4,
    0x1123f0, 0x112414, 0x112420, 0x112df4, 0x112e06, 0x112e34,
    0x112eb0, 0x113004, 0x113026, 0x113040, 0x1133b4, 0x1133d0,
    0x1133e4, 0x1133f6, 0x113404, 0x113416, 0x113450, 0x113476,
    0x113490, 0x1134b6, 0x1134e0, 0x113574, 0x113580, 0x113626,
    0x113640, 0x113664, 0x1136d0, 0x113704, 0x113750, 0x114356,
    0x114384, 0x114406, 0x114424, 0x114456, 0x114464, 0x114470,
    0x1145e4, 0x1145f0, 0x114b04, 0x114b16, 0x114b34, 0x114b96,
    0x114ba4, 0x114bb6, 0x114bd4, 0x114be6, 0x114bf4, 0x114c16,
    0x114c24, 0x114c40, 0x115af4, 0x115b06, 0x115b24, 0x115b60,
    0x115b86, 0x115bc4, 0x115be6, 0x115bf4, 0x115c10, 0x115dc4,
    0x115de0, 0x116306, 0x116334, 0x1163b6, 0x1163d4, 0x1163e6,
    0x1163f4, 0x116410, 0x116ab4, 0x116ac6, 0x116ad4, 0x116ae6,
    0x116b04, 0x116b66, 0x116b74, 0x116b80, 0x1171d4, 0x117200,
    0x117224, 0x117266, 0x117274, 0x1172c0, 0x1182c6, 0x1182f4,
    0x118386, 0x118394, 0x1183b0, 0x119304, 0x119316, 0x119360,
    0x119376, 0x119390, 0x1193b4, 0x1193d6, 0x1193e4, 0x1193f5,
    0x119406, 0x119415, 0x119426, 0x119434, 0x119440, 0x119d16,
    0x119d44, 0x119d80, 0x119da4, 0x119dc6, 0x119e04, 0x119e10,
    0x119e46, 0x119e50, 0x11a014, 0x11a0b0, 0x11a334, 0x11a396,
    0x11a3a5, 0x11a3b4, 0x11a3f0, 0x11a474, 0x11a480, 0x11a514,
    0x11a576, 0x11a594, 0x11a5c0, 0x11a845, 0x11a8a4, 0x11a976,
    0x11a984, 0x11a9a0, 0x11c2f6, 0x11c304, 0x11c370, 0x11c384,
    0x11c3e6, 0x11c3f4, 0x11c400, 0x11c924, 0x11ca80, 0x11ca96,
    0x11caa4, 0x11cb16, 0x11cb24, 0x11cb46, 0x11cb54, 0x11cb70,
    0x11d314, 0x11d370, 0x11d3a4, 0x11d3b0, 0x11d3c4, 0x11d3e0,
    0x11d3f4, 0x11d465, 0x11d474, 0x11d480, 0x11d8a6, 0x11d8f0,
    0x11d904, 0x11d920, 0x11d936, 0x11d954, 0x11d966, 0x11d974,
    0x11d980, 0x11ef34, 0x11ef56, 0x11ef70, 0x11f004, 0x11f025,
    0x11f036, 0x11f040, 0x11f346, 0x11f364, 0x11f3b0, 0x11f3e6,
    0x11f404, 0x11f416, 0x11f424, 0x11f430, 0x134301, 0x134404,
    0x134410, 0x134474, 0x134560, 0x16af04, 0x16af50, 0x16b304,
    0x16b370, 0x16f4f4, 0x16f500, 0x16f516, 0x16f880, 0x16f8f4,
    0x16f930, 0x16fe44, 0x16fe50, 0x16ff06, 0x16ff20, 0x1bc9d4,
    0x1bc9f0, 0x1bca01, 0x1bca40, 0x1cf004, 0x1cf2e0, 0x1cf304,
    0x1cf470, 0x1d1654, 0x1d1666, 0x1d1674, 0x1d16a0, 0x1d16d6,
    0x1d16e4, 0x1d1731, 0x1d17b4, 0x1d1830, 0x1d1854, 0x1d18c0,
    0x1d1aa4, 0x1d1ae0, 0x1d2424, 0x1d2450, 0x1da004, 0x1da370,
    0x1da3b4, 0x1da6d0, 0x1da754, 0x1da760, 0x1da844, 0x1da850,
    0x1da9b4, 0x1daa00, 0x1daa14, 0x1dab00, 0x1e0004, 0x1e0070,
    0x1e0084, 0x1e0190, 0x1e01b4, 0x1e0220, 0x1e0234, 0x1e0250,
    0x1e0264, 0x1e02b0, 0x1e08f4, 0x1e0900, 0x1e1304, 0x1e1370,
    0x1e2ae4, 0x1e2af0, 0x1e2ec4, 0x1e2f00, 0x1e4ec4, 0x1e4f00,
    0x1e8d04, 0x1e8d70, 0x1e9444, 0x1e94b0, 0x1f1e6d, 0x1f2000,
    0x1f3fb4, 0x1f4000, 0xe00001, 0xe00204, 0xe00801, 0xe01004,
    0xe01f01, 0xe10000,
  };

  inline constexpr char32_t __incb_linkers[] = {
    0x094d, 0x09cd, 0x0acd, 0x0b4d, 0x0c4d, 0x0d4d,
  };

  enum class _InCB { _Consonant = 1, _Extend = 2 };




  inline constexpr uint32_t __incb_edges[] = {
    0xc02, 0xd3c, 0xd42, 0xdc0, 0x120e, 0x1220,
    0x1646, 0x16f8, 0x16fe, 0x1700, 0x1706, 0x170c,
    0x1712, 0x1718, 0x171e, 0x1720, 0x1842, 0x186c,
    0x192e, 0x1980, 0x19c2, 0x19c4, 0x1b5a, 0x1b74,
    0x1b7e, 0x1b94, 0x1b9e, 0x1ba4, 0x1baa, 0x1bb8,
    0x1c46, 0x1c48, 0x1cc2, 0x1d2c, 0x1fae, 0x1fd0,
    0x1ff6, 0x1ff8, 0x205a, 0x2068, 0x206e, 0x2090,
    0x2096, 0x20a0, 0x20a6, 0x20b8, 0x2166, 0x2170,
    0x2262, 0x2280, 0x232a, 0x2388, 0x238e, 0x2400,
    0x2455, 0x24e8, 0x24f2, 0x24f4, 0x2546, 0x2554,
    0x2561, 0x2580, 0x25e1, 0x2600, 0x2655, 0x26a4,
    0x26a9, 0x26c4, 0x26c9, 0x26cc, 0x26d9, 0x26e8,
    0x26f2, 0x26f4, 0x2771, 0x2778, 0x277d, 0x2780,
    0x27c1, 0x27c8, 0x27fa, 0x27fc, 0x28f2, 0x28f4,
    0x2a55, 0x2aa4, 0x2aa9, 0x2ac4, 0x2ac9, 0x2ad0,
    0x2ad5, 0x2ae8, 0x2af2, 0x2af4, 0x2be5, 0x2be8,
    0x2c55, 0x2ca4, 0x2ca9, 0x2cc4, 0x2cc9, 0x2cd0,
    0x2cd5, 0x2ce8, 0x2cf2, 0x2cf4, 0x2d71, 0x2d78,
    0x2d7d, 0x2d80, 0x2dc5, 0x2dc8, 0x3055, 0x30a4,
    0x30a9, 0x30e8, 0x30f2, 0x30f4, 0x3156, 0x315c,
    0x3161, 0x316c, 0x32f2, 0x32f4, 0x3455, 0x34ee,
    0x34f4, 0x38e2, 0x38ec, 0x3922, 0x3930, 0x3ae2,
    0x3aec, 0x3b22, 0x3b30, 0x3c62, 0x3c68, 0x3cd6,
    0x3cd8, 0x3cde, 0x3ce0, 0x3ce6, 0x3ce8, 0x3dc6,
    0x3dcc, 0x3dd2, 0x3dd4, 0x3dea, 0x3df8, 0x3e02,
    0x3e04, 0x3e0a, 0x3e14, 0x3e1a, 0x3e20, 0x3f1a,
    0x3f1c, 0x40de, 0x40e0, 0x40e6, 0x40ec, 0x4236,
    0x4238, 0x4d76, 0x4d80, 0x5c52, 0x5c54, 0x5f4a,
    0x5f4c, 0x5f76, 0x5f78, 0x62a6, 0x62a8, 0x64e6,
    0x64f0, 0x685e, 0x6864, 0x6982, 0x6984, 0x69d6,
    0x69f4, 0x69fe, 0x6a00, 0x6ac2, 0x6af8, 0x6afe,
    0x6b3c, 0x6cd2, 0x6cd4, 0x6dae, 0x6dd0, 0x6eae,
    0x6eb0, 0x6f9a, 0x6f9c, 0x70de, 0x70e0, 0x7342,
    0x734c, 0x7352, 0x7384, 0x738a, 0x73a4, 0x73b6,
    0x73b8, 0x73d2, 0x73d4, 0x73e2, 0x73e8, 0x7702,
    0x7800, 0x8036, 0x8038, 0x8342, 0x8374, 0x8386,
    0x8388, 0x8396, 0x83c4, 0xb3be, 0xb3c8, 0xb5fe,
    0xb600, 0xb782, 0xb800, 0xc0aa, 0xc0c0, 0xc266,
    0xc26c, 0x299be, 0x299c0, 0x299d2, 0x299f8, 0x29a7a,
    0x29a80, 0x29bc2, 0x29bc8, 0x2a0b2, 0x2a0b4, 0x2a382,
    0x2a3c8, 0x2a4ae, 0x2a4b8, 0x2a6ce, 0x2a6d0, 0x2aac2,
    0x2aac4, 0x2aaca, 0x2aad4, 0x2aade, 0x2aae4, 0x2aafa,
    0x2ab00, 0x2ab06, 0x2ab08, 0x2abda, 0x2abdc, 0x2afb6,
    0x2afb8, 0x3ec7a, 0x3ec7c, 0x3f882, 0x3f8c0, 0x407f6,
    0x407f8, 0x40b82, 0x40b84, 0x40dda, 0x40dec, 0x42836,
    0x42838, 0x4283e, 0x42840, 0x428e2, 0x428ec, 0x428fe,
    0x42900, 0x42b96, 0x42b9c, 0x43492, 0x434a0, 0x43aae,
    0x43ab4, 0x43bf6, 0x43c00, 0x43d1a, 0x43d44, 0x43e0a,
    0x43e18, 0x441c2, 0x441c4, 0x441fe, 0x44200, 0x442ea,
    0x442ec, 0x44402, 0x4440c, 0x444ce, 0x444d4, 0x445ce,
    0x445d0, 0x4472a, 0x4472c, 0x448da, 0x448dc, 0x44ba6,
    0x44bac, 0x44cee, 0x44cf4, 0x44d9a, 0x44db4, 0x44dc2,
    0x44dd4, 0x4511a, 0x4511c, 0x4517a, 0x4517c, 0x4530e,
    0x45310, 0x45702, 0x45704, 0x45ade, 0x45ae0, 0x45cae,
    0x45cb0, 0x460ea, 0x460ec, 0x464fa, 0x464fc, 0x4650e,
    0x46510, 0x468d2, 0x468d4, 0x4691e, 0x46920, 0x46a66,
    0x46a68, 0x4750a, 0x4750c, 0x47512, 0x47518, 0x4765e,
    0x47660, 0x47d0a, 0x47d0c, 0x5abc2, 0x5abd4, 0x5acc2,
    0x5acdc, 0x6f27a, 0x6f27c, 0x74596, 0x74598, 0x7459e,
    0x745a8, 0x745ba, 0x745cc, 0x745ee, 0x7460c, 0x74616,
    0x74630, 0x746aa, 0x746b8, 0x7490a, 0x74914, 0x78002,
    0x7801c, 0x78022, 0x78064, 0x7806e, 0x78088, 0x7808e,
    0x78094, 0x7809a, 0x780ac, 0x7823e, 0x78240, 0x784c2,
    0x784dc, 0x78aba, 0x78abc, 0x78bb2, 0x78bc0, 0x793b2,
    0x793c0, 0x7a342, 0x7a35c, 0x7a512, 0x7a52c,
  };



  inline constexpr char32_t __xpicto_edges[] = {
    0xa9, 0xaa, 0xae, 0xaf, 0x203c, 0x203d, 0x2049, 0x204a,
    0x2122, 0x2123, 0x2139, 0x213a, 0x2194, 0x219a, 0x21a9, 0x21ab,
    0x231a, 0x231c, 0x2328, 0x2329, 0x2388, 0x2389, 0x23cf, 0x23d0,
    0x23e9, 0x23f4, 0x23f8, 0x23fb, 0x24c2, 0x24c3, 0x25aa, 0x25ac,
    0x25b6, 0x25b7, 0x25c0, 0x25c1, 0x25fb, 0x25ff, 0x2600, 0x2606,
    0x2607, 0x2613, 0x2614, 0x2686, 0x2690, 0x2706, 0x2708, 0x2713,
    0x2714, 0x2715, 0x2716, 0x2717, 0x271d, 0x271e, 0x2721, 0x2722,
    0x2728, 0x2729, 0x2733, 0x2735, 0x2744, 0x2745, 0x2747, 0x2748,
    0x274c, 0x274d, 0x274e, 0x274f, 0x2753, 0x2756, 0x2757, 0x2758,
    0x2763, 0x2768, 0x2795, 0x2798, 0x27a1, 0x27a2, 0x27b0, 0x27b1,
    0x27bf, 0x27c0, 0x2934, 0x2936, 0x2b05, 0x2b08, 0x2b1b, 0x2b1d,
    0x2b50, 0x2b51, 0x2b55, 0x2b56, 0x3030, 0x3031, 0x303d, 0x303e,
    0x3297, 0x3298, 0x3299, 0x329a, 0x1f000, 0x1f100, 0x1f10d, 0x1f110,
    0x1f12f, 0x1f130, 0x1f16c, 0x1f172, 0x1f17e, 0x1f180, 0x1f18e, 0x1f18f,
    0x1f191, 0x1f19b, 0x1f1ad, 0x1f1e6, 0x1f201, 0x1f210, 0x1f21a, 0x1f21b,
    0x1f22f, 0x1f230, 0x1f232, 0x1f23b, 0x1f23c, 0x1f240, 0x1f249, 0x1f3fb,
    0x1f400, 0x1f53e, 0x1f546, 0x1f650, 0x1f680, 0x1f700, 0x1f774, 0x1f780,
    0x1f7d5, 0x1f800, 0x1f80c, 0x1f810, 0x1f848, 0x1f850, 0x1f85a, 0x1f860,
    0x1f888, 0x1f890, 0x1f8ae, 0x1f900, 0x1f90c, 0x1f93b, 0x1f93c, 0x1f946,
    0x1f947, 0x1fb00, 0x1fc00, 0x1fffe,
  };
# 597 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unicode.h" 2 3





  constexpr int
  __field_width(char32_t __c) noexcept
  {
    if (__c < __width_edges[0]) [[likely]]
      return 1;

    auto* __p = std::upper_bound(__width_edges, std::end(__width_edges), __c);
    return (__p - __width_edges) % 2 + 1;
  }


  constexpr _Gcb_property
  __grapheme_cluster_break_property(char32_t __c) noexcept
  {
    constexpr uint32_t __mask = (1 << __gcb_shift_bits) - 1;
    auto* __end = std::end(__gcb_edges);
    auto* __p = std::lower_bound(__gcb_edges, __end,
     (__c << __gcb_shift_bits) | __mask);
    return _Gcb_property(__p[-1] & __mask);
  }

  constexpr bool
  __is_incb_linker(char32_t __c) noexcept
  {
    const auto __end = std::end(__incb_linkers);

    return std::find(__incb_linkers, __end, __c) != __end;
  }


  constexpr _InCB
  __incb_property(char32_t __c) noexcept
  {
    if ((__c << 2) < __incb_edges[0]) [[likely]]
      return _InCB(0);

    constexpr uint32_t __mask = 0x3;
    auto* __end = std::end(__incb_edges);
    auto* __p = std::lower_bound(__incb_edges, __end, (__c << 2) | __mask);
    return _InCB(__p[-1] & __mask);
  }

  constexpr bool
  __is_extended_pictographic(char32_t __c)
  {
    if (__c < __xpicto_edges[0]) [[likely]]
      return 0;

    auto* __p = std::upper_bound(__xpicto_edges, std::end(__xpicto_edges), __c);
    return (__p - __xpicto_edges) % 2;
  }

  struct _Grapheme_cluster_iterator_base
  {
    char32_t _M_c;
    _Gcb_property _M_prop;
    enum class _XPicto : unsigned char { _Init, _Zwj, _Matched, _Failed };
    _XPicto _M_xpicto_seq_state = _XPicto::_Init;
    unsigned char _M_RI_count = 0;
    bool _M_incb_linker_seen = false;

    constexpr void
    _M_reset(char32_t __c, _Gcb_property __p)
    {
      _M_c = __c;
      _M_prop = __p;
      _M_xpicto_seq_state = _XPicto::_Init;
      _M_RI_count = 0;
      _M_incb_linker_seen = false;
    }

    constexpr void
    _M_update_xpicto_seq_state(char32_t __c, _Gcb_property __p)
    {
      if (_M_xpicto_seq_state == _XPicto::_Failed)
 return;

      auto __next_state = _XPicto::_Failed;
      if (_M_xpicto_seq_state != _XPicto::_Zwj)
 {
   if (__p == _Gcb_property::_Gcb_ZWJ)
     {
       if (_M_xpicto_seq_state == _XPicto::_Matched)
  __next_state = _XPicto::_Zwj;


       else if (__is_extended_pictographic(_M_c))
  __next_state = _XPicto::_Zwj;
     }
   else if (__p == _Gcb_property::_Gcb_Extend)
     __next_state = _M_xpicto_seq_state;
 }
      else
 {


   if (__p == _Gcb_property::_Gcb_Other
  && __is_extended_pictographic(__c))
     __next_state = _XPicto::_Matched;
 }
      _M_xpicto_seq_state = __next_state;
    }

    constexpr void
    _M_update_ri_count(_Gcb_property __p)
    {
      if (__p == _Gcb_property::_Gcb_Regional_Indicator)
 ++_M_RI_count;
      else
 _M_RI_count = 0;
    }

    constexpr void
    _M_update_incb_state(char32_t __c, _Gcb_property)
    {
      if (__is_incb_linker(__c))
 _M_incb_linker_seen = true;
    }
  };


  template<ranges::forward_range _View> requires ranges::view<_View>
    class _Grapheme_cluster_view
    : public ranges::view_interface<_Grapheme_cluster_view<_View>>
    {
    public:

      constexpr
      _Grapheme_cluster_view(_View __v)
      : _M_begin(_Utf32_view<_View>(std::move(__v)).begin())
      { }

      constexpr auto begin() const { return _M_begin; }
      constexpr auto end() const { return _M_begin.end(); }

    private:
      struct _Iterator : private _Grapheme_cluster_iterator_base
      {
      private:

 using _U32_iterator = ranges::iterator_t<_Utf32_view<_View>>;

      public:





 using value_type = char32_t;
 using iterator_concept = forward_iterator_tag;
 using difference_type = ptrdiff_t;

 constexpr
 _Iterator(_U32_iterator __i)
 : _M_base(__i)
 {
   if (__i != __i.end())
     {
       _M_c = *__i;
       _M_prop = __grapheme_cluster_break_property(_M_c);
     }
 }


 constexpr value_type
 operator*() const
 { return _M_c; }

 constexpr auto
 operator->() const
 { return &_M_c; }


 constexpr _Iterator&
 operator++()
 {
   const auto __end = _M_base.end();
   if (_M_base != __end)
     {
       auto __p_prev = _M_prop;
       auto __it = _M_base;
       while (++__it != __end)
  {
    char32_t __c = *__it;
    auto __p = __grapheme_cluster_break_property(*__it);
    _M_update_xpicto_seq_state(__c, __p);
    _M_update_ri_count(__p);
    _M_update_incb_state(__c, __p);
    if (_M_is_break(__p_prev, __p, __it))
      {

        _M_reset(__c, __p);
        break;
      }
    __p_prev = __p;
  }
       _M_base = __it;
     }
   return *this;
 }

 constexpr _Iterator
 operator++(int)
 {
   auto __tmp = *this;
   ++*this;
   return __tmp;
 }

 constexpr bool
 operator==(const _Iterator& __i) const
 { return _M_base == __i._M_base; }


 constexpr bool
 operator==(const ranges::sentinel_t<_View>& __i) const
 { return _M_base == __i; }


 constexpr auto base() const { return _M_base.base(); }


 constexpr auto end() const { return _M_base.end(); }


 constexpr int
 width() const noexcept
 { return __field_width(_M_c); }

      private:
 _U32_iterator _M_base;






 constexpr bool
 _M_is_break(_Gcb_property __p1, _Gcb_property __p2,
      _U32_iterator __curr) const
 {
   using enum _Gcb_property;

   if (__p1 == _Gcb_Control || __p1 == _Gcb_LF)
     return true;

   if (__p1 == _Gcb_CR)
     return __p2 != _Gcb_LF;


   if (__p2 == _Gcb_Control || __p2 == _Gcb_CR || __p2 == _Gcb_LF)
     return true;


   if (__p1 == _Gcb_L)
     switch (__p2)
     {
       case _Gcb_L:
       case _Gcb_V:
       case _Gcb_LV:
       case _Gcb_LVT:
  return false;
       default:
  return true;
       }


   if (__p1 == _Gcb_LV || __p1 == _Gcb_V)
     switch (__p2)
     {
       case _Gcb_V:
       case _Gcb_T:
  return false;
       default:
  return true;
       }


   if (__p1 == _Gcb_LVT || __p1 == _Gcb_T)
     return __p2 != _Gcb_T;


   if (__p2 == _Gcb_Extend || __p2 == _Gcb_ZWJ)
     return false;





   if (__p2 == _Gcb_SpacingMark)
     return false;

   if (__p1 == _Gcb_Prepend)
     return false;




   if (_M_incb_linker_seen
  && __incb_property(_M_c) == _InCB::_Consonant
  && __incb_property(*__curr) == _InCB::_Consonant)
     {


       bool __have_linker = false;
       auto __it = _M_base;
       while (++__it != __curr)
  {
    if (__is_incb_linker(*__it))
      __have_linker = true;
    else
      {
        auto __incb = __incb_property(*__it);
        if (__incb == _InCB::_Consonant)
   __have_linker = false;
        else if (__incb != _InCB::_Extend)
   break;
      }
  }
       if (__it == __curr && __have_linker)
  return false;
     }




   if (__p1 == _Gcb_ZWJ && _M_xpicto_seq_state == _XPicto::_Matched)
     return false;





   if (__p1 == _Gcb_property::_Gcb_Regional_Indicator && __p1 == __p2)
     return (_M_RI_count & 1) == 0;


   return true;
 }
      };

      _Iterator _M_begin;
    };

}


  template<typename _CharT>
    constexpr size_t
    __field_width(basic_string_view<_CharT> __s)
    {
      if (__s.empty()) [[unlikely]]
 return 0;
      _Grapheme_cluster_view<basic_string_view<_CharT>> __gc(__s);
      auto __it = __gc.begin();
      const auto __end = __gc.end();
      size_t __n = __it.width();
      while (++__it != __end)
 __n += __it.width();
      return __n;
    }



  template<typename _CharT>
    constexpr size_t
    __truncate(basic_string_view<_CharT>& __s, size_t __max)
    {
      if (__s.empty()) [[unlikely]]
 return 0;

      _Grapheme_cluster_view<basic_string_view<_CharT>> __gc(__s);
      auto __it = __gc.begin();
      const auto __end = __gc.end();
      size_t __n = __it.width();
      if (__n > __max)
 {
   __s = {};
   return 0;
 }
      while (++__it != __end)
 {
   size_t __n2 = __n + __it.width();
   if (__n2 > __max)
     {
       __s = basic_string_view<_CharT>(__s.begin(), __it.base());
       return __n;
     }
   __n = __n2;
 }
      return __n;
    }

  template<typename _CharT>
    consteval bool
    __literal_encoding_is_unicode()
    {
      if constexpr (is_same_v<_CharT, char16_t>)
 return true;
      else if constexpr (is_same_v<_CharT, char32_t>)
   return true;

      else if constexpr (is_same_v<_CharT, char8_t>)
 return true;


      const char* __enc = "";
# 1046 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unicode.h" 3
      if constexpr (is_same_v<_CharT, char>)
 __enc = "UTF-8";

      else
 __enc = "UTF-32";


      string_view __s(__enc);
      if (__s == "UTF-8")
 return true;
      else if constexpr (!is_same_v<_CharT, char>)
 return __s == "UTF-16" || __s == "UTF-32";


      return false;
    }

  consteval bool
  __literal_encoding_is_utf8()
  { return __literal_encoding_is_unicode<char>(); }

  consteval bool
  __literal_encoding_is_extended_ascii()
  {
    return '0' == 0x30 && 'A' == 0x41 && 'Z' == 0x5a
      && 'a' == 0x61 && 'z' == 0x7a;
  }


  constexpr bool
  __charset_alias_match(string_view __a, string_view __b)
  {

    auto __map = [](char __c, bool& __num) -> unsigned char {
      if (__c == '0') [[unlikely]]
 return __num ? 0 : 127;
      const auto __v = __detail::__from_chars_alnum_to_val(__c);
      __num = __v < 10;
      return __v;
    };

    auto __ptr_a = __a.begin(), __end_a = __a.end();
    auto __ptr_b = __b.begin(), __end_b = __b.end();
    bool __num_a = false, __num_b = false;

    while (true)
      {

 unsigned char __val_a{}, __val_b{};
 while (__ptr_a != __end_a
   && (__val_a = __map(*__ptr_a, __num_a)) == 127)
   ++__ptr_a;
 while (__ptr_b != __end_b
   && (__val_b = __map(*__ptr_b, __num_b)) == 127)
   ++__ptr_b;

 if (__ptr_a == __end_a)
   return __ptr_b == __end_b;
 else if (__ptr_b == __end_b)
   return false;
 else if (__val_a != __val_b)
   return false;
 ++__ptr_a;
 ++__ptr_b;
      }
    return true;
  }

}

namespace ranges
{
  template<typename _To, typename _Range>
    inline constexpr bool
    enable_borrowed_range<std::__unicode::_Utf_view<_To, _Range>>
      = enable_borrowed_range<_Range>;

  template<typename _Range>
    inline constexpr bool
    enable_borrowed_range<std::__unicode::_Grapheme_cluster_view<_Range>>
      = enable_borrowed_range<_Range>;
}


}
# 59 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/format" 2 3




# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cctype" 1 3
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cctype" 3
# 64 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/format" 2 3


namespace std __attribute__ ((__visibility__ ("default")))
{



  template<typename _Out, typename _CharT> class basic_format_context;


  template<typename _CharT, typename... _Args> struct basic_format_string;


namespace __format
{

  template<typename _CharT> class _Sink;

  template<typename _CharT>
    class _Sink_iter;

  template<typename _CharT>
    using __format_context = basic_format_context<_Sink_iter<_CharT>, _CharT>;

  template<typename _CharT>
    struct _Runtime_format_string
    {
      [[__gnu__::__always_inline__]]
      _Runtime_format_string(basic_string_view<_CharT> __s) noexcept
      : _M_str(__s) { }

      _Runtime_format_string(const _Runtime_format_string&) = delete;
      void operator=(const _Runtime_format_string&) = delete;

    private:
      basic_string_view<_CharT> _M_str;

      template<typename, typename...> friend struct std::basic_format_string;
    };
}


  using format_context = __format::__format_context<char>;

  using wformat_context = __format::__format_context<wchar_t>;



  template<typename _Context> class basic_format_args;
  using format_args = basic_format_args<format_context>;

  using wformat_args = basic_format_args<wformat_context>;




  template<typename _Context>
    class basic_format_arg;





  template<typename _CharT, typename... _Args>
    struct basic_format_string
    {
      template<typename _Tp>
 requires convertible_to<const _Tp&, basic_string_view<_CharT>>
 consteval
 basic_format_string(const _Tp& __s);

      [[__gnu__::__always_inline__]]
      basic_format_string(__format::_Runtime_format_string<_CharT> __s) noexcept
      : _M_str(__s._M_str)
      { }

      [[__gnu__::__always_inline__]]
      constexpr basic_string_view<_CharT>
      get() const noexcept
      { return _M_str; }

    private:
      basic_string_view<_CharT> _M_str;
    };

  template<typename... _Args>
    using format_string = basic_format_string<char, type_identity_t<_Args>...>;


  template<typename... _Args>
    using wformat_string
      = basic_format_string<wchar_t, type_identity_t<_Args>...>;
# 175 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/format" 3
  template<typename _Tp, typename _CharT = char>
    struct formatter
    {
      formatter() = delete;
      formatter(const formatter&) = delete;
      formatter& operator=(const formatter&) = delete;
    };


  class format_error : public runtime_error
  {
  public:
    explicit format_error(const string& __what) : runtime_error(__what) { }
    explicit format_error(const char* __what) : runtime_error(__what) { }
  };


  [[noreturn]]
  inline void
  __throw_format_error(const char* __what)
  { (throw (format_error(__what))); }

namespace __format
{


  [[noreturn]]
  inline void
  __unmatched_left_brace_in_format_string()
  { __throw_format_error("format error: unmatched '{' in format string"); }

  [[noreturn]]
  inline void
  __unmatched_right_brace_in_format_string()
  { __throw_format_error("format error: unmatched '}' in format string"); }

  [[noreturn]]
  inline void
  __conflicting_indexing_in_format_string()
  { __throw_format_error("format error: conflicting indexing style in format string"); }

  [[noreturn]]
  inline void
  __invalid_arg_id_in_format_string()
  { __throw_format_error("format error: invalid arg-id in format string"); }

  [[noreturn]]
  inline void
  __failed_to_parse_format_spec()
  { __throw_format_error("format error: failed to parse format-spec"); }
}



  template<typename _CharT> class basic_format_parse_context;
  using format_parse_context = basic_format_parse_context<char>;

  using wformat_parse_context = basic_format_parse_context<wchar_t>;


  template<typename _CharT>
    class basic_format_parse_context
    {
    public:
      using char_type = _CharT;
      using const_iterator = typename basic_string_view<_CharT>::const_iterator;
      using iterator = const_iterator;

      constexpr explicit
      basic_format_parse_context(basic_string_view<_CharT> __fmt,
     size_t __num_args = 0) noexcept
      : _M_begin(__fmt.begin()), _M_end(__fmt.end()), _M_num_args(__num_args)
      { }

      basic_format_parse_context(const basic_format_parse_context&) = delete;
      void operator=(const basic_format_parse_context&) = delete;

      constexpr const_iterator begin() const noexcept { return _M_begin; }
      constexpr const_iterator end() const noexcept { return _M_end; }

      constexpr void
      advance_to(const_iterator __it) noexcept
      { _M_begin = __it; }

      constexpr size_t
      next_arg_id()
      {
 if (_M_indexing == _Manual)
   __format::__conflicting_indexing_in_format_string();
 _M_indexing = _Auto;



 if (std::is_constant_evaluated())
   if (_M_next_arg_id == _M_num_args)
     __format::__invalid_arg_id_in_format_string();
 return _M_next_arg_id++;
      }

      constexpr void
      check_arg_id(size_t __id)
      {
 if (_M_indexing == _Auto)
   __format::__conflicting_indexing_in_format_string();
 _M_indexing = _Manual;

 if (std::is_constant_evaluated())
   if (__id >= _M_num_args)
     __format::__invalid_arg_id_in_format_string();
      }

    private:
      iterator _M_begin;
      iterator _M_end;
      enum _Indexing { _Unknown, _Manual, _Auto };
      _Indexing _M_indexing = _Unknown;
      size_t _M_next_arg_id = 0;
      size_t _M_num_args;
    };


  template<typename _Tp, template<typename...> class _Class>
    static constexpr bool __is_specialization_of = false;
  template<template<typename...> class _Class, typename... _Args>
    static constexpr bool __is_specialization_of<_Class<_Args...>, _Class>
      = true;

namespace __format
{

  template<typename _CharT>
    constexpr pair<unsigned short, const _CharT*>
    __parse_integer(const _CharT* __first, const _CharT* __last)
    {
      if (__first == __last)
 __builtin_unreachable();

      if constexpr (is_same_v<_CharT, char>)
 {
   const auto __start = __first;
   unsigned short __val = 0;

   if (__detail::__from_chars_alnum<true>(__first, __last, __val, 10)
  && __first != __start) [[likely]]
     return {__val, __first};
 }
      else
 {
   constexpr int __n = 32;
   char __buf[__n]{};
   for (int __i = 0; __i < __n && (__first + __i) != __last; ++__i)
     __buf[__i] = __first[__i];
   auto [__v, __ptr] = __format::__parse_integer(__buf, __buf + __n);
   if (__ptr) [[likely]]
     return {__v, __first + (__ptr - __buf)};
 }
      return {0, nullptr};
    }

  template<typename _CharT>
    constexpr pair<unsigned short, const _CharT*>
    __parse_arg_id(const _CharT* __first, const _CharT* __last)
    {
      if (__first == __last)
 __builtin_unreachable();

      if (*__first == '0')
 return {0, __first + 1};

      if ('1' <= *__first && *__first <= '9')
 {
   const unsigned short __id = *__first - '0';
   const auto __next = __first + 1;

   if (__next == __last || !('0' <= *__next && *__next <= '9'))
     return {__id, __next};
   else
     return __format::__parse_integer(__first, __last);
 }
      return {0, nullptr};
    }

  enum _Pres_type {
    _Pres_none = 0,

    _Pres_d = 1, _Pres_b, _Pres_B, _Pres_o, _Pres_x, _Pres_X, _Pres_c,

    _Pres_a = 1, _Pres_A, _Pres_e, _Pres_E, _Pres_f, _Pres_F, _Pres_g, _Pres_G,
    _Pres_p = 0, _Pres_P,
    _Pres_s = 0,
    _Pres_esc = 0xf,
  };

  enum _Align {
    _Align_default,
    _Align_left,
    _Align_right,
    _Align_centre,
  };

  enum _Sign {
    _Sign_default,
    _Sign_plus,
    _Sign_minus,
    _Sign_space,
  };

  enum _WidthPrec {
    _WP_none,
    _WP_value,
    _WP_from_arg
  };

  template<typename _Context>
    size_t
    __int_from_arg(const basic_format_arg<_Context>& __arg);

  constexpr bool __is_digit(char __c)
  { return std::__detail::__from_chars_alnum_to_val(__c) < 10; }

  constexpr bool __is_xdigit(char __c)
  { return std::__detail::__from_chars_alnum_to_val(__c) < 16; }

  template<typename _CharT>
    struct _Spec
    {
      _Align _M_align : 2;
      _Sign _M_sign : 2;
      unsigned _M_alt : 1;
      unsigned _M_localized : 1;
      unsigned _M_zero_fill : 1;
      _WidthPrec _M_width_kind : 2;
      _WidthPrec _M_prec_kind : 2;
      _Pres_type _M_type : 4;
      unsigned _M_reserved : 1;
      unsigned _M_reserved2 : 16;
      unsigned short _M_width;
      unsigned short _M_prec;
      char32_t _M_fill = ' ';

      using iterator = typename basic_string_view<_CharT>::iterator;

      static constexpr _Align
      _S_align(_CharT __c) noexcept
      {
 switch (__c)
 {
   case '<': return _Align_left;
   case '>': return _Align_right;
   case '^': return _Align_centre;
   default: return _Align_default;
 }
      }


      constexpr iterator
      _M_parse_fill_and_align(iterator __first, iterator __last) noexcept
      {
 if (*__first != '{')
   {
     using namespace __unicode;
     if constexpr (__literal_encoding_is_unicode<_CharT>())
       {

  _Utf32_view<ranges::subrange<iterator>> __uv({__first, __last});
  if (!__uv.empty())
    {
      auto __beg = __uv.begin();
      char32_t __c = *__beg++;
      if (__is_scalar_value(__c))
        if (auto __next = __beg.base(); __next != __last)
   if (_Align __align = _S_align(*__next))
     {
       _M_fill = __c;
       _M_align = __align;
       return ++__next;
     }
    }
       }
     else if (__last - __first >= 2)
       if (_Align __align = _S_align(__first[1]))
  {
    _M_fill = *__first;
    _M_align = __align;
    return __first + 2;
  }

     if (_Align __align = _S_align(__first[0]))
       {
  _M_fill = ' ';
  _M_align = __align;
  return __first + 1;
       }
   }
 return __first;
      }

      static constexpr _Sign
      _S_sign(_CharT __c) noexcept
      {
 switch (__c)
 {
   case '+': return _Sign_plus;
   case '-': return _Sign_minus;
   case ' ': return _Sign_space;
   default: return _Sign_default;
 }
      }


      constexpr iterator
      _M_parse_sign(iterator __first, iterator) noexcept
      {
 if (_Sign __sign = _S_sign(*__first))
   {
     _M_sign = __sign;
     return __first + 1;
   }
 return __first;
      }


      constexpr iterator
      _M_parse_alternate_form(iterator __first, iterator) noexcept
      {
 if (*__first == '#')
   {
     _M_alt = true;
     ++__first;
   }
 return __first;
      }


      constexpr iterator
      _M_parse_zero_fill(iterator __first, iterator ) noexcept
      {
 if (*__first == '0')
   {
     _M_zero_fill = true;
     ++__first;
   }
 return __first;
      }


      static constexpr iterator
      _S_parse_width_or_precision(iterator __first, iterator __last,
      unsigned short& __val, bool& __arg_id,
      basic_format_parse_context<_CharT>& __pc)
      {
 if (__format::__is_digit(*__first))
   {
     auto [__v, __ptr] = __format::__parse_integer(__first, __last);
     if (!__ptr)
       __throw_format_error("format error: invalid width or precision "
       "in format-spec");
     __first = __ptr;
     __val = __v;
   }
 else if (*__first == '{')
   {
     __arg_id = true;
     ++__first;
     if (__first == __last)
       __format::__unmatched_left_brace_in_format_string();
     if (*__first == '}')
       __val = __pc.next_arg_id();
     else
       {
  auto [__v, __ptr] = __format::__parse_arg_id(__first, __last);
  if (__ptr == nullptr || __ptr == __last || *__ptr != '}')
    __format::__invalid_arg_id_in_format_string();
  __first = __ptr;
  __pc.check_arg_id(__v);
  __val = __v;
       }
     ++__first;
   }
 return __first;
      }


      constexpr iterator
      _M_parse_width(iterator __first, iterator __last,
       basic_format_parse_context<_CharT>& __pc)
      {
 bool __arg_id = false;
 if (*__first == '0')
   __throw_format_error("format error: width must be non-zero in "
          "format string");
 auto __next = _S_parse_width_or_precision(__first, __last, _M_width,
        __arg_id, __pc);
 if (__next != __first)
   _M_width_kind = __arg_id ? _WP_from_arg : _WP_value;
 return __next;
      }


      constexpr iterator
      _M_parse_precision(iterator __first, iterator __last,
    basic_format_parse_context<_CharT>& __pc)
      {
 if (__first[0] != '.')
   return __first;

 iterator __next = ++__first;
 bool __arg_id = false;
 if (__next != __last)
   __next = _S_parse_width_or_precision(__first, __last, _M_prec,
            __arg_id, __pc);
 if (__next == __first)
   __throw_format_error("format error: missing precision after '.' in "
          "format string");
 _M_prec_kind = __arg_id ? _WP_from_arg : _WP_value;
 return __next;
      }


      constexpr iterator
      _M_parse_locale(iterator __first, iterator ) noexcept
      {
 if (*__first == 'L')
   {
     _M_localized = true;
     ++__first;
   }
 return __first;
      }

      template<typename _Context>
 size_t
 _M_get_width(_Context& __ctx) const
 {
   size_t __width = 0;
   if (_M_width_kind == _WP_value)
     __width = _M_width;
   else if (_M_width_kind == _WP_from_arg)
     __width = __format::__int_from_arg(__ctx.arg(_M_width));
   return __width;
 }

      template<typename _Context>
 size_t
 _M_get_precision(_Context& __ctx) const
 {
   size_t __prec = -1;
   if (_M_prec_kind == _WP_value)
     __prec = _M_prec;
   else if (_M_prec_kind == _WP_from_arg)
     __prec = __format::__int_from_arg(__ctx.arg(_M_prec));
   return __prec;
 }
    };

  template<typename _Int>
    inline char*
    __put_sign(_Int __i, _Sign __sign, char* __dest) noexcept
    {
      if (__i < 0)
 *__dest = '-';
      else if (__sign == _Sign_plus)
 *__dest = '+';
      else if (__sign == _Sign_space)
 *__dest = ' ';
      else
 ++__dest;
      return __dest;
    }


  template<typename _Out, typename _CharT>
    requires output_iterator<_Out, const _CharT&>
    inline _Out
    __write(_Out __out, basic_string_view<_CharT> __str)
    {
      if constexpr (is_same_v<_Out, _Sink_iter<_CharT>>)
 {
   if (__str.size())
     __out = __str;
 }
      else
 for (_CharT __c : __str)
   *__out++ = __c;
      return __out;
    }



  template<typename _Out, typename _CharT>
    _Out
    __write_padded(_Out __out, basic_string_view<_CharT> __str,
     _Align __align, size_t __nfill, char32_t __fill_char)
    {
      const size_t __buflen = 0x20;
      _CharT __padding_chars[__buflen];
      __padding_chars[0] = _CharT();
      basic_string_view<_CharT> __padding{__padding_chars, __buflen};

      auto __pad = [&__padding] (size_t __n, _Out& __o) {
 if (__n == 0)
   return;
 while (__n > __padding.size())
   {
     __o = __format::__write(std::move(__o), __padding);
     __n -= __padding.size();
   }
 if (__n != 0)
   __o = __format::__write(std::move(__o), __padding.substr(0, __n));
      };

      size_t __l, __r, __max;
      if (__align == _Align_centre)
 {
   __l = __nfill / 2;
   __r = __l + (__nfill & 1);
   __max = __r;
 }
      else if (__align == _Align_right)
 {
   __l = __nfill;
   __r = 0;
   __max = __l;
 }
      else
 {
   __l = 0;
   __r = __nfill;
   __max = __r;
 }

      using namespace __unicode;
      if constexpr (__literal_encoding_is_unicode<_CharT>())
 if (!__is_single_code_unit<_CharT>(__fill_char)) [[unlikely]]
   {

     const char32_t __arr[1]{ __fill_char };
     _Utf_view<_CharT, const char32_t(&)[1]> __v(__arr);
     basic_string<_CharT> __padstr(__v.begin(), __v.end());
     __padding = __padstr;
     while (__l-- > 0)
       __out = __format::__write(std::move(__out), __padding);
     __out = __format::__write(std::move(__out), __str);
     while (__r-- > 0)
       __out = __format::__write(std::move(__out), __padding);
     return __out;
   }

      if (__max < __buflen)
 __padding.remove_suffix(__buflen - __max);
      else
 __max = __buflen;

      char_traits<_CharT>::assign(__padding_chars, __max, __fill_char);
      __pad(__l, __out);
      __out = __format::__write(std::move(__out), __str);
      __pad(__r, __out);

      return __out;
    }



  template<typename _CharT, typename _Out>
    _Out
    __write_padded_as_spec(basic_string_view<type_identity_t<_CharT>> __str,
      size_t __estimated_width,
      basic_format_context<_Out, _CharT>& __fc,
      const _Spec<_CharT>& __spec,
      _Align __align = _Align_left)
    {
      size_t __width = __spec._M_get_width(__fc);

      if (__width <= __estimated_width)
 return __format::__write(__fc.out(), __str);

      const size_t __nfill = __width - __estimated_width;

      if (__spec._M_align)
 __align = __spec._M_align;

      return __format::__write_padded(__fc.out(), __str, __align, __nfill,
          __spec._M_fill);
    }


  struct _Optional_locale
  {
    [[__gnu__::__always_inline__]]
    _Optional_locale() : _M_dummy(), _M_hasval(false) { }

    _Optional_locale(const locale& __loc) noexcept
    : _M_loc(__loc), _M_hasval(true)
    { }

    _Optional_locale(const _Optional_locale& __l) noexcept
    : _M_dummy(), _M_hasval(__l._M_hasval)
    {
      if (_M_hasval)
 std::construct_at(&_M_loc, __l._M_loc);
    }

    _Optional_locale&
    operator=(const _Optional_locale& __l) noexcept
    {
      if (_M_hasval)
 {
   if (__l._M_hasval)
     _M_loc = __l._M_loc;
   else
     {
       _M_loc.~locale();
       _M_hasval = false;
     }
 }
      else if (__l._M_hasval)
 {
   std::construct_at(&_M_loc, __l._M_loc);
   _M_hasval = true;
 }
      return *this;
    }

    ~_Optional_locale() { if (_M_hasval) _M_loc.~locale(); }

    _Optional_locale&
    operator=(locale&& __loc) noexcept
    {
      if (_M_hasval)
 _M_loc = std::move(__loc);
      else
 {
   std::construct_at(&_M_loc, std::move(__loc));
   _M_hasval = true;
 }
      return *this;
    }

    const locale&
    value() noexcept
    {
      if (!_M_hasval)
 {
   std::construct_at(&_M_loc);
   _M_hasval = true;
 }
      return _M_loc;
    }

    bool has_value() const noexcept { return _M_hasval; }

    union {
      char _M_dummy = '\0';
      std::locale _M_loc;
    };
    bool _M_hasval = false;
  };


  template<typename _CharT>
    concept __char = same_as<_CharT, char> || same_as<_CharT, wchar_t>;





  template<__char _CharT>
    struct __formatter_str
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      {
 auto __first = __pc.begin();
 const auto __last = __pc.end();
 _Spec<_CharT> __spec{};

 auto __finalize = [this, &__spec] {
   _M_spec = __spec;
 };

 auto __finished = [&] {
   if (__first == __last || *__first == '}')
     {
       __finalize();
       return true;
     }
   return false;
 };

 if (__finished())
   return __first;

 __first = __spec._M_parse_fill_and_align(__first, __last);
 if (__finished())
   return __first;

 __first = __spec._M_parse_width(__first, __last, __pc);
 if (__finished())
   return __first;

 __first = __spec._M_parse_precision(__first, __last, __pc);
 if (__finished())
   return __first;

 if (*__first == 's')
   ++__first;
# 889 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/format" 3
 if (__finished())
   return __first;

 __format::__failed_to_parse_format_spec();
      }

      template<typename _Out>
 _Out
 format(basic_string_view<_CharT> __s,
        basic_format_context<_Out, _CharT>& __fc) const
 {
   if (_M_spec._M_type == _Pres_esc)
     {

     }

   if (_M_spec._M_width_kind == _WP_none
  && _M_spec._M_prec_kind == _WP_none)
     return __format::__write(__fc.out(), __s);

   size_t __estimated_width;
   if constexpr (__unicode::__literal_encoding_is_unicode<_CharT>())
     {
       if (_M_spec._M_prec_kind != _WP_none)
  {
    size_t __prec = _M_spec._M_get_precision(__fc);
    __estimated_width = __unicode::__truncate(__s, __prec);
  }
       else
  __estimated_width = __unicode::__field_width(__s);
     }
   else
     {
       __s = __s.substr(0, _M_spec._M_get_precision(__fc));
       __estimated_width = __s.size();
     }

   return __format::__write_padded_as_spec(__s, __estimated_width,
        __fc, _M_spec);
 }







    private:
      _Spec<_CharT> _M_spec{};
    };

  template<__char _CharT>
    struct __formatter_int
    {


      static constexpr _Pres_type _AsInteger = _Pres_d;
      static constexpr _Pres_type _AsBool = _Pres_s;
      static constexpr _Pres_type _AsChar = _Pres_c;

      constexpr typename basic_format_parse_context<_CharT>::iterator
      _M_do_parse(basic_format_parse_context<_CharT>& __pc, _Pres_type __type)
      {
 _Spec<_CharT> __spec{};
 __spec._M_type = __type;

 const auto __last = __pc.end();
 auto __first = __pc.begin();

 auto __finalize = [this, &__spec] {
   _M_spec = __spec;
 };

 auto __finished = [&] {
   if (__first == __last || *__first == '}')
     {
       __finalize();
       return true;
     }
   return false;
 };

 if (__finished())
   return __first;

 __first = __spec._M_parse_fill_and_align(__first, __last);
 if (__finished())
   return __first;

 __first = __spec._M_parse_sign(__first, __last);
 if (__finished())
   return __first;

 __first = __spec._M_parse_alternate_form(__first, __last);
 if (__finished())
   return __first;

 __first = __spec._M_parse_zero_fill(__first, __last);
 if (__finished())
   return __first;

 __first = __spec._M_parse_width(__first, __last, __pc);
 if (__finished())
   return __first;

 __first = __spec._M_parse_locale(__first, __last);
 if (__finished())
   return __first;

 switch (*__first)
 {
   case 'b':
     __spec._M_type = _Pres_b;
     ++__first;
     break;
   case 'B':
     __spec._M_type = _Pres_B;
     ++__first;
     break;
   case 'c':


     if (__type != _AsBool)
       {
  __spec._M_type = _Pres_c;
  ++__first;
       }
     break;
   case 'd':
     __spec._M_type = _Pres_d;
     ++__first;
     break;
   case 'o':
     __spec._M_type = _Pres_o;
     ++__first;
     break;
   case 'x':
     __spec._M_type = _Pres_x;
     ++__first;
     break;
   case 'X':
     __spec._M_type = _Pres_X;
     ++__first;
     break;
   case 's':
     if (__type == _AsBool)
       {
  __spec._M_type = _Pres_s;
  ++__first;
       }
     break;
# 1048 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/format" 3
     break;
   }

 if (__finished())
   return __first;

 __format::__failed_to_parse_format_spec();
      }

      template<typename _Tp>
 constexpr typename basic_format_parse_context<_CharT>::iterator
 _M_parse(basic_format_parse_context<_CharT>& __pc)
 {
   if constexpr (is_same_v<_Tp, bool>)
     {
       auto __end = _M_do_parse(__pc, _AsBool);
       if (_M_spec._M_type == _Pres_s)
  if (_M_spec._M_sign || _M_spec._M_alt || _M_spec._M_zero_fill)
    __throw_format_error("format error: format-spec contains "
           "invalid formatting options for "
           "'bool'");
       return __end;
     }
   else if constexpr (__char<_Tp>)
     {
       auto __end = _M_do_parse(__pc, _AsChar);
       if (_M_spec._M_type == _Pres_c || _M_spec._M_type == _Pres_esc)
  if (_M_spec._M_sign || _M_spec._M_alt || _M_spec._M_zero_fill
                                                            )
    __throw_format_error("format error: format-spec contains "
           "invalid formatting options for "
           "'charT'");
       return __end;
     }
   else
     return _M_do_parse(__pc, _AsInteger);
 }

      template<typename _Int, typename _Out>
 typename basic_format_context<_Out, _CharT>::iterator
 format(_Int __i, basic_format_context<_Out, _CharT>& __fc) const
 {
   if (_M_spec._M_type == _Pres_c)
     return _M_format_character(_S_to_character(__i), __fc);

   char __buf[sizeof(_Int) * 8 + 3];
   to_chars_result __res{};

   string_view __base_prefix;
   make_unsigned_t<_Int> __u;
   if (__i < 0)
     __u = -static_cast<make_unsigned_t<_Int>>(__i);
   else
     __u = __i;

   char* __start = __buf + 3;
   char* const __end = __buf + sizeof(__buf);
   char* const __start_digits = __start;

   switch (_M_spec._M_type)
   {
     case _Pres_b:
     case _Pres_B:
       __base_prefix = _M_spec._M_type == _Pres_b ? "0b" : "0B";
       __res = to_chars(__start, __end, __u, 2);
       break;




     case _Pres_none:

       [[fallthrough]];
     case _Pres_d:
       __res = to_chars(__start, __end, __u, 10);
       break;
     case _Pres_o:
       if (__i != 0)
  __base_prefix = "0";
       __res = to_chars(__start, __end, __u, 8);
       break;
     case _Pres_x:
     case _Pres_X:
       __base_prefix = _M_spec._M_type == _Pres_x ? "0x" : "0X";
       __res = to_chars(__start, __end, __u, 16);
       if (_M_spec._M_type == _Pres_X)
  for (auto __p = __start; __p != __res.ptr; ++__p)



    *__p = std::toupper(*__p);

       break;
     default:
       __builtin_unreachable();
   }

   if (_M_spec._M_alt && __base_prefix.size())
     {
       __start -= __base_prefix.size();
       __builtin_memcpy(__start, __base_prefix.data(),
          __base_prefix.size());
     }
   __start = __format::__put_sign(__i, _M_spec._M_sign, __start - 1);

   return _M_format_int(string_view(__start, __res.ptr - __start),
          __start_digits - __start, __fc);
 }

      template<typename _Out>
 typename basic_format_context<_Out, _CharT>::iterator
 format(bool __i, basic_format_context<_Out, _CharT>& __fc) const
 {
   if (_M_spec._M_type == _Pres_c)
     return _M_format_character(static_cast<unsigned char>(__i), __fc);
   if (_M_spec._M_type != _Pres_s)
     return format(static_cast<unsigned char>(__i), __fc);

   basic_string<_CharT> __s;
   size_t __est_width;
   if (_M_spec._M_localized) [[unlikely]]
     {
       auto& __np = std::use_facet<numpunct<_CharT>>(__fc.locale());
       __s = __i ? __np.truename() : __np.falsename();
       __est_width = __s.size();
     }
   else
     {
       if constexpr (is_same_v<char, _CharT>)
  __s = __i ? "true" : "false";
       else
  __s = __i ? L"true" : L"false";
       __est_width = __s.size();
     }

   return __format::__write_padded_as_spec(__s, __est_width, __fc,
        _M_spec);
 }

      template<typename _Out>
 typename basic_format_context<_Out, _CharT>::iterator
 _M_format_character(_CharT __c,
        basic_format_context<_Out, _CharT>& __fc) const
 {
   return __format::__write_padded_as_spec({&__c, 1u}, 1, __fc, _M_spec);
 }

      template<typename _Int>
 static _CharT
 _S_to_character(_Int __i)
 {
   using _Traits = __gnu_cxx::__int_traits<_CharT>;
   if constexpr (is_signed_v<_Int> == is_signed_v<_CharT>)
     {
       if (_Traits::__min <= __i && __i <= _Traits::__max)
  return static_cast<_CharT>(__i);
     }
   else if constexpr (is_signed_v<_Int>)
     {
       if (__i >= 0 && make_unsigned_t<_Int>(__i) <= _Traits::__max)
  return static_cast<_CharT>(__i);
     }
   else if (__i <= make_unsigned_t<_CharT>(_Traits::__max))
     return static_cast<_CharT>(__i);
   __throw_format_error("format error: integer not representable as "
          "character");
 }

      template<typename _Out>
 typename basic_format_context<_Out, _CharT>::iterator
 _M_format_int(string_view __narrow_str, size_t __prefix_len,
        basic_format_context<_Out, _CharT>& __fc) const
 {
   size_t __width = _M_spec._M_get_width(__fc);

   basic_string_view<_CharT> __str;
   if constexpr (is_same_v<char, _CharT>)
     __str = __narrow_str;

   else
     {
       size_t __n = __narrow_str.size();
       auto __p = (_CharT*)__builtin_alloca(__n * sizeof(_CharT));
       std::__to_wstring_numeric(__narrow_str.data(), __n, __p);
       __str = {__p, __n};
     }


   if (_M_spec._M_localized)
     {
       const auto& __l = __fc.locale();
       if (__l.name() != "C")
  {
    auto& __np = use_facet<numpunct<_CharT>>(__l);
    string __grp = __np.grouping();
    if (!__grp.empty())
      {
        size_t __n = __str.size() - __prefix_len;
        auto __p = (_CharT*)__builtin_alloca(2 * __n
            * sizeof(_CharT)
            + __prefix_len);
        auto __s = __str.data();
        char_traits<_CharT>::copy(__p, __s, __prefix_len);
        __s += __prefix_len;
        auto __end = std::__add_grouping(__p + __prefix_len,
             __np.thousands_sep(),
             __grp.data(),
             __grp.size(),
             __s, __s + __n);
        __str = {__p, size_t(__end - __p)};
      }
  }
     }

   if (__width <= __str.size())
     return __format::__write(__fc.out(), __str);

   char32_t __fill_char = _M_spec._M_fill;
   _Align __align = _M_spec._M_align;

   size_t __nfill = __width - __str.size();
   auto __out = __fc.out();
   if (__align == _Align_default)
     {
       __align = _Align_right;
       if (_M_spec._M_zero_fill)
  {
    __fill_char = _CharT('0');

    if (__prefix_len != 0)
      {
        __out = __format::__write(std::move(__out),
      __str.substr(0, __prefix_len));
        __str.remove_prefix(__prefix_len);
      }
  }
       else
  __fill_char = _CharT(' ');
     }
   return __format::__write_padded(std::move(__out), __str,
       __align, __nfill, __fill_char);
 }
# 1305 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/format" 3
      _Spec<_CharT> _M_spec{};
    };
# 1393 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/format" 3
  using std::to_chars;


  template<typename _Tp>
    concept __formattable_float = requires (_Tp __t, char* __p)
    { __format::to_chars(__p, __p, __t, chars_format::scientific, 6); };

  template<__char _CharT>
    struct __formatter_fp
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      {
 _Spec<_CharT> __spec{};
 const auto __last = __pc.end();
 auto __first = __pc.begin();

 auto __finalize = [this, &__spec] {
   _M_spec = __spec;
 };

 auto __finished = [&] {
   if (__first == __last || *__first == '}')
     {
       __finalize();
       return true;
     }
   return false;
 };

 if (__finished())
   return __first;

 __first = __spec._M_parse_fill_and_align(__first, __last);
 if (__finished())
   return __first;

 __first = __spec._M_parse_sign(__first, __last);
 if (__finished())
   return __first;

 __first = __spec._M_parse_alternate_form(__first, __last);
 if (__finished())
   return __first;

 __first = __spec._M_parse_zero_fill(__first, __last);
 if (__finished())
   return __first;

 if (__first[0] != '.')
   {
     __first = __spec._M_parse_width(__first, __last, __pc);
     if (__finished())
       return __first;
   }

 __first = __spec._M_parse_precision(__first, __last, __pc);
 if (__finished())
   return __first;

 __first = __spec._M_parse_locale(__first, __last);
 if (__finished())
   return __first;

 switch (*__first)
 {
   case 'a':
     __spec._M_type = _Pres_a;
     ++__first;
     break;
   case 'A':
     __spec._M_type = _Pres_A;
     ++__first;
     break;
   case 'e':
     __spec._M_type = _Pres_e;
     ++__first;
     break;
   case 'E':
     __spec._M_type = _Pres_E;
     ++__first;
     break;
   case 'f':
     __spec._M_type = _Pres_f;
     ++__first;
     break;
   case 'F':
     __spec._M_type = _Pres_F;
     ++__first;
     break;
   case 'g':
     __spec._M_type = _Pres_g;
     ++__first;
     break;
   case 'G':
     __spec._M_type = _Pres_G;
     ++__first;
     break;
   }

 if (__finished())
   return __first;

 __format::__failed_to_parse_format_spec();
      }

      template<typename _Fp, typename _Out>
 typename basic_format_context<_Out, _CharT>::iterator
 format(_Fp __v, basic_format_context<_Out, _CharT>& __fc) const
 {
   std::string __dynbuf;
   char __buf[128];
   to_chars_result __res{};

   size_t __prec = 6;
   bool __use_prec = _M_spec._M_prec_kind != _WP_none;
   if (__use_prec)
     __prec = _M_spec._M_get_precision(__fc);

   char* __start = __buf + 1;
   char* __end = __buf + sizeof(__buf);

   chars_format __fmt{};
   bool __upper = false;
   bool __trailing_zeros = false;
   char __expc = 'e';

   switch (_M_spec._M_type)
   {
     case _Pres_A:
       __upper = true;
       __expc = 'P';
       [[fallthrough]];
     case _Pres_a:
       if (_M_spec._M_type != _Pres_A)
  __expc = 'p';
       __fmt = chars_format::hex;
       break;
     case _Pres_E:
       __upper = true;
       __expc = 'E';
       [[fallthrough]];
     case _Pres_e:
       __use_prec = true;
       __fmt = chars_format::scientific;
       break;
     case _Pres_F:
       __upper = true;
       [[fallthrough]];
     case _Pres_f:
       __use_prec = true;
       __fmt = chars_format::fixed;
       break;
     case _Pres_G:
       __upper = true;
       __expc = 'E';
       [[fallthrough]];
     case _Pres_g:
       __trailing_zeros = true;
       __use_prec = true;
       __fmt = chars_format::general;
       break;
     case _Pres_none:
       if (__use_prec)
  __fmt = chars_format::general;
       break;
     default:
       __builtin_unreachable();
   }


   auto __to_chars = [&](char* __b, char* __e) {
     if (__use_prec)
       return __format::to_chars(__b, __e, __v, __fmt, __prec);
     else if (__fmt != chars_format{})
       return __format::to_chars(__b, __e, __v, __fmt);
     else
       return __format::to_chars(__b, __e, __v);
   };


   __res = __to_chars(__start, __end);

   if (__builtin_expect(__res.ec == errc::value_too_large, 0))
     {


       size_t __guess = 8 + __prec;
       if (__fmt == chars_format::fixed)
  {
    if constexpr (is_same_v<_Fp, float> || is_same_v<_Fp, double>
      || is_same_v<_Fp, long double>)
      {


        int __exp{};
        if constexpr (is_same_v<_Fp, float>)
   __builtin_frexpf(__v, &__exp);
        else if constexpr (is_same_v<_Fp, double>)
   __builtin_frexp(__v, &__exp);
        else if constexpr (is_same_v<_Fp, long double>)
   __builtin_frexpl(__v, &__exp);
        if (__exp > 0)
   __guess += 1U + __exp * 4004U / 13301U;
      }
    else
      __guess += numeric_limits<_Fp>::max_exponent10;
  }
       if (__guess <= sizeof(__buf)) [[unlikely]]
  __guess = sizeof(__buf) * 2;
       __dynbuf.reserve(__guess);

       do
  {
    auto __overwrite = [&__to_chars, &__res] (char* __p, size_t __n)
    {
      __res = __to_chars(__p + 1, __p + __n - 1);
      return __res.ec == errc{} ? __res.ptr - __p : 0;
    };

    __dynbuf.__resize_and_overwrite(__dynbuf.capacity() * 2,
        __overwrite);
    __start = __dynbuf.data() + 1;
    __end = __dynbuf.data() + __dynbuf.size();
  }
       while (__builtin_expect(__res.ec == errc::value_too_large, 0));
   }


   if (__upper)
     {
       for (char* __p = __start; __p != __res.ptr; ++__p)
  *__p = std::toupper(*__p);
     }

   bool __have_sign = true;

   if (!__builtin_signbit(__v))
     {
       if (_M_spec._M_sign == _Sign_plus)
  *--__start = '+';
       else if (_M_spec._M_sign == _Sign_space)
  *--__start = ' ';
       else
  __have_sign = false;
     }

   string_view __narrow_str(__start, __res.ptr - __start);



   if (_M_spec._M_alt && __builtin_isfinite(__v))
     {
       string_view __s = __narrow_str;
       size_t __sigfigs;
       size_t __z = 0;
       size_t __p;
       size_t __d = __s.find('.');
       if (__d != __s.npos)
  {
    __p = __s.find(__expc, __d + 1);
    if (__p == __s.npos)
      __p = __s.size();


    if (__trailing_zeros)
      {

        if (__s[__have_sign] != '0')

   __sigfigs = __p - __have_sign - 1;
        else



   __sigfigs = __p - __s.find_first_not_of('0', __d + 1);
      }
  }
       else
  {
    __p = __s.find(__expc);
    if (__p == __s.npos)
      __p = __s.size();
    __d = __p;
    __sigfigs = __d - __have_sign;
  }

       if (__trailing_zeros && __prec != 0)
  {



    __z = __prec - __sigfigs;
  }

       if (size_t __extras = int(__d == __p) + __z)
  {
    if (__dynbuf.empty() && __extras <= size_t(__end - __res.ptr))
      {


        __builtin_memmove(__start + __p + __extras,
     __start + __p,
     __s.size() - __p);
        if (__d == __p)
   __start[__p++] = '.';
        __builtin_memset(__start + __p, '0', __z);
        __narrow_str = {__s.data(), __s.size() + __extras};
      }
    else
      {
        __dynbuf.reserve(__s.size() + __extras);
        if (__dynbuf.empty())
   {
     __dynbuf = __s.substr(0, __p);
     if (__d == __p)
       __dynbuf += '.';
     if (__z)
       __dynbuf.append(__z, '0');
     __dynbuf.append(__s.substr(__p));
   }
        else
   {
     __dynbuf.insert(__p, __extras, '0');
     if (__d == __p)
       __dynbuf[__p] = '.';
   }
        __narrow_str = __dynbuf;
      }
  }
     }

   basic_string<_CharT> __wstr;
   basic_string_view<_CharT> __str;
   if constexpr (is_same_v<_CharT, char>)
     __str = __narrow_str;

   else
     {
       __wstr = std::__to_wstring_numeric(__narrow_str);
       __str = __wstr;
     }


   if (_M_spec._M_localized && __builtin_isfinite(__v))
     {
       __wstr = _M_localize(__str, __expc, __fc.locale());
       if (!__wstr.empty())
  __str = __wstr;
     }

   size_t __width = _M_spec._M_get_width(__fc);

   if (__width <= __str.size())
     return __format::__write(__fc.out(), __str);

   char32_t __fill_char = _M_spec._M_fill;
   _Align __align = _M_spec._M_align;

   size_t __nfill = __width - __str.size();
   auto __out = __fc.out();
   if (__align == _Align_default)
     {
       __align = _Align_right;
       if (_M_spec._M_zero_fill && __builtin_isfinite(__v))
  {
    __fill_char = _CharT('0');

    if (!__format::__is_xdigit(__narrow_str[0]))
      {
        *__out++ = __str[0];
        __str.remove_prefix(1);
      }
  }
       else
  __fill_char = _CharT(' ');
     }
   return __format::__write_padded(std::move(__out), __str,
       __align, __nfill, __fill_char);
 }


      basic_string<_CharT>
      _M_localize(basic_string_view<_CharT> __str, char __expc,
    const locale& __loc) const
      {
 basic_string<_CharT> __lstr;

 if (__loc == locale::classic())
   return __lstr;

 const auto& __np = use_facet<numpunct<_CharT>>(__loc);
 const _CharT __point = __np.decimal_point();
 const string __grp = __np.grouping();

 _CharT __dot, __exp;
 if constexpr (is_same_v<_CharT, char>)
   {
     __dot = '.';
     __exp = __expc;
   }
 else
   {
     __dot = L'.';
     switch (__expc)
     {
       case 'e':
  __exp = L'e';
  break;
       case 'E':
  __exp = L'E';
  break;
       case 'p':
  __exp = L'p';
  break;
       case 'P':
  __exp = L'P';
  break;
       default:
  __builtin_unreachable();
     }
   }

 if (__grp.empty() && __point == __dot)
   return __lstr;

 size_t __d = __str.find(__dot);
 size_t __e = min(__d, __str.find(__exp));
 if (__e == __str.npos)
   __e = __str.size();
 const size_t __r = __str.size() - __e;
 auto __overwrite = [&](_CharT* __p, size_t) {
   auto __end = std::__add_grouping(__p, __np.thousands_sep(),
        __grp.data(), __grp.size(),
        __str.data(), __str.data() + __e);
   if (__r)
     {
       if (__d != __str.npos)
  {
    *__end = __point;
    ++__end;
    ++__e;
  }
       if (__r > 1)
  __end += __str.copy(__end, __str.npos, __e);
     }
   return (__end - __p);
 };
 __lstr.__resize_and_overwrite(__e * 2 + __r, __overwrite);
 return __lstr;
      }

      _Spec<_CharT> _M_spec{};
    };

}



  template<__format::__char _CharT>
    struct formatter<_CharT, _CharT>
    {
      formatter() = default;

      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      {
 return _M_f.template _M_parse<_CharT>(__pc);
      }

      template<typename _Out>
 typename basic_format_context<_Out, _CharT>::iterator
 format(_CharT __u, basic_format_context<_Out, _CharT>& __fc) const
 {
   if (_M_f._M_spec._M_type == __format::_Pres_none
       || _M_f._M_spec._M_type == __format::_Pres_c)
     return _M_f._M_format_character(__u, __fc);
   else if (_M_f._M_spec._M_type == __format::_Pres_esc)
     {

       return __fc.out();
     }
   else
     return _M_f.format(static_cast<make_unsigned_t<_CharT>>(__u), __fc);
 }







    private:
      __format::__formatter_int<_CharT> _M_f;
    };



  template<>
    struct formatter<char, wchar_t>
    {
      formatter() = default;

      constexpr typename basic_format_parse_context<wchar_t>::iterator
      parse(basic_format_parse_context<wchar_t>& __pc)
      {
 return _M_f._M_parse<char>(__pc);
      }

      template<typename _Out>
 typename basic_format_context<_Out, wchar_t>::iterator
 format(char __u, basic_format_context<_Out, wchar_t>& __fc) const
 {
   if (_M_f._M_spec._M_type == __format::_Pres_none
       || _M_f._M_spec._M_type == __format::_Pres_c)
     return _M_f._M_format_character(__u, __fc);
   else if (_M_f._M_spec._M_type == __format::_Pres_esc)
     {

       return __fc.out();
     }
   else
     return _M_f.format(static_cast<unsigned char>(__u), __fc);
 }







    private:
      __format::__formatter_int<wchar_t> _M_f;
    };





  template<__format::__char _CharT>
    struct formatter<_CharT*, _CharT>
    {
      formatter() = default;

      [[__gnu__::__always_inline__]]
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      { return _M_f.parse(__pc); }

      template<typename _Out>
 [[__gnu__::__nonnull__]]
 typename basic_format_context<_Out, _CharT>::iterator
 format(_CharT* __u, basic_format_context<_Out, _CharT>& __fc) const
 { return _M_f.format(__u, __fc); }





    private:
      __format::__formatter_str<_CharT> _M_f;
    };

  template<__format::__char _CharT>
    struct formatter<const _CharT*, _CharT>
    {
      formatter() = default;

      [[__gnu__::__always_inline__]]
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      { return _M_f.parse(__pc); }

      template<typename _Out>
 [[__gnu__::__nonnull__]]
 typename basic_format_context<_Out, _CharT>::iterator
 format(const _CharT* __u,
        basic_format_context<_Out, _CharT>& __fc) const
 { return _M_f.format(__u, __fc); }





    private:
      __format::__formatter_str<_CharT> _M_f;
    };

  template<__format::__char _CharT, size_t _Nm>
    struct formatter<_CharT[_Nm], _CharT>
    {
      formatter() = default;

      [[__gnu__::__always_inline__]]
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      { return _M_f.parse(__pc); }

      template<typename _Out>
 typename basic_format_context<_Out, _CharT>::iterator
 format(const _CharT (&__u)[_Nm],
        basic_format_context<_Out, _CharT>& __fc) const
 { return _M_f.format({__u, _Nm}, __fc); }





    private:
      __format::__formatter_str<_CharT> _M_f;
    };

  template<typename _Traits, typename _Alloc>
    struct formatter<basic_string<char, _Traits, _Alloc>, char>
    {
      formatter() = default;

      [[__gnu__::__always_inline__]]
      constexpr typename basic_format_parse_context<char>::iterator
      parse(basic_format_parse_context<char>& __pc)
      { return _M_f.parse(__pc); }

      template<typename _Out>
 typename basic_format_context<_Out, char>::iterator
 format(const basic_string<char, _Traits, _Alloc>& __u,
        basic_format_context<_Out, char>& __fc) const
 { return _M_f.format(__u, __fc); }





    private:
      __format::__formatter_str<char> _M_f;
    };


  template<typename _Traits, typename _Alloc>
    struct formatter<basic_string<wchar_t, _Traits, _Alloc>, wchar_t>
    {
      formatter() = default;

      [[__gnu__::__always_inline__]]
      constexpr typename basic_format_parse_context<wchar_t>::iterator
      parse(basic_format_parse_context<wchar_t>& __pc)
      { return _M_f.parse(__pc); }

      template<typename _Out>
 typename basic_format_context<_Out, wchar_t>::iterator
 format(const basic_string<wchar_t, _Traits, _Alloc>& __u,
        basic_format_context<_Out, wchar_t>& __fc) const
 { return _M_f.format(__u, __fc); }





    private:
      __format::__formatter_str<wchar_t> _M_f;
    };


  template<typename _Traits>
    struct formatter<basic_string_view<char, _Traits>, char>
    {
      formatter() = default;

      [[__gnu__::__always_inline__]]
      constexpr typename basic_format_parse_context<char>::iterator
      parse(basic_format_parse_context<char>& __pc)
      { return _M_f.parse(__pc); }

      template<typename _Out>
 typename basic_format_context<_Out, char>::iterator
 format(basic_string_view<char, _Traits> __u,
        basic_format_context<_Out, char>& __fc) const
 { return _M_f.format(__u, __fc); }





    private:
      __format::__formatter_str<char> _M_f;
    };


  template<typename _Traits>
    struct formatter<basic_string_view<wchar_t, _Traits>, wchar_t>
    {
      formatter() = default;

      [[__gnu__::__always_inline__]]
      constexpr typename basic_format_parse_context<wchar_t>::iterator
      parse(basic_format_parse_context<wchar_t>& __pc)
      { return _M_f.parse(__pc); }

      template<typename _Out>
 typename basic_format_context<_Out, wchar_t>::iterator
 format(basic_string_view<wchar_t, _Traits> __u,
        basic_format_context<_Out, wchar_t>& __fc) const
 { return _M_f.format(__u, __fc); }





    private:
      __format::__formatter_str<wchar_t> _M_f;
    };




  template<integral _Tp, __format::__char _CharT>
    requires (!__is_one_of<_Tp, char, wchar_t, char16_t, char32_t>::value)
    struct formatter<_Tp, _CharT>
    {
      formatter() = default;

      [[__gnu__::__always_inline__]]
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      {
 return _M_f.template _M_parse<_Tp>(__pc);
      }

      template<typename _Out>
 typename basic_format_context<_Out, _CharT>::iterator
 format(_Tp __u, basic_format_context<_Out, _CharT>& __fc) const
 { return _M_f.format(__u, __fc); }

    private:
      __format::__formatter_int<_CharT> _M_f;
    };
# 2155 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/format" 3
  template<__format::__formattable_float _Tp, __format::__char _CharT>
    struct formatter<_Tp, _CharT>
    {
      formatter() = default;

      [[__gnu__::__always_inline__]]
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      { return _M_f.parse(__pc); }

      template<typename _Out>
 typename basic_format_context<_Out, _CharT>::iterator
 format(_Tp __u, basic_format_context<_Out, _CharT>& __fc) const
 { return _M_f.format(__u, __fc); }

    private:
      __format::__formatter_fp<_CharT> _M_f;
    };
# 2311 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/format" 3
  template<__format::__char _CharT>
    struct formatter<const void*, _CharT>
    {
      formatter() = default;

      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      {
 __format::_Spec<_CharT> __spec{};
 const auto __last = __pc.end();
 auto __first = __pc.begin();

 auto __finalize = [this, &__spec] {
   _M_spec = __spec;
 };

 auto __finished = [&] {
   if (__first == __last || *__first == '}')
     {
       __finalize();
       return true;
     }
   return false;
 };

 if (__finished())
   return __first;

 __first = __spec._M_parse_fill_and_align(__first, __last);
 if (__finished())
   return __first;
# 2352 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/format" 3
 __first = __spec._M_parse_zero_fill(__first, __last);
 if (__finished())
   return __first;


 __first = __spec._M_parse_width(__first, __last, __pc);

 if (__first != __last)
   {
     if (*__first == 'p')
       ++__first;

     else if (*__first == 'P')
     {


       __spec._M_type = __format::_Pres_P;
       ++__first;
     }

   }

 if (__finished())
   return __first;

 __format::__failed_to_parse_format_spec();
      }

      template<typename _Out>
 typename basic_format_context<_Out, _CharT>::iterator
 format(const void* __v, basic_format_context<_Out, _CharT>& __fc) const
 {
   auto __u = reinterpret_cast<long unsigned int>(__v);
   char __buf[2 + sizeof(__v) * 2];
   auto [__ptr, __ec] = std::to_chars(__buf + 2, std::end(__buf),
          __u, 16);
   int __n = __ptr - __buf;
   __buf[0] = '0';
   __buf[1] = 'x';

   if (_M_spec._M_type == __format::_Pres_P)
     {
       __buf[1] = 'X';
       for (auto __p = __buf + 2; __p != __ptr; ++__p)



  *__p = std::toupper(*__p);

     }


   basic_string_view<_CharT> __str;
   if constexpr (is_same_v<_CharT, char>)
     __str = string_view(__buf, __n);

   else
     {
       auto __p = (_CharT*)__builtin_alloca(__n * sizeof(_CharT));
       std::__to_wstring_numeric(__buf, __n, __p);
       __str = wstring_view(__p, __n);
     }



   if (_M_spec._M_zero_fill)
     {
       size_t __width = _M_spec._M_get_width(__fc);
       if (__width <= __str.size())
  return __format::__write(__fc.out(), __str);

       auto __out = __fc.out();

       __out = __format::__write(std::move(__out), __str.substr(0, 2));
       __str.remove_prefix(2);
       size_t __nfill = __width - __n;
       return __format::__write_padded(std::move(__out), __str,
           __format::_Align_right,
           __nfill, _CharT('0'));
     }


   return __format::__write_padded_as_spec(__str, __n, __fc, _M_spec,
        __format::_Align_right);
 }

    private:
      __format::_Spec<_CharT> _M_spec{};
    };

  template<__format::__char _CharT>
    struct formatter<void*, _CharT>
    {
      formatter() = default;

      [[__gnu__::__always_inline__]]
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      { return _M_f.parse(__pc); }

      template<typename _Out>
 typename basic_format_context<_Out, _CharT>::iterator
 format(void* __v, basic_format_context<_Out, _CharT>& __fc) const
 { return _M_f.format(__v, __fc); }

    private:
      formatter<const void*, _CharT> _M_f;
    };

  template<__format::__char _CharT>
    struct formatter<nullptr_t, _CharT>
    {
      formatter() = default;

      [[__gnu__::__always_inline__]]
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      { return _M_f.parse(__pc); }

      template<typename _Out>
 typename basic_format_context<_Out, _CharT>::iterator
 format(nullptr_t, basic_format_context<_Out, _CharT>& __fc) const
 { return _M_f.format(nullptr, __fc); }

    private:
      formatter<const void*, _CharT> _M_f;
    };
# 2506 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/format" 3
namespace __format
{
  template<typename _Tp, typename _Context,
    typename _Formatter
      = typename _Context::template formatter_type<remove_const_t<_Tp>>,
    typename _ParseContext
      = basic_format_parse_context<typename _Context::char_type>>
    concept __parsable_with
      = semiregular<_Formatter>
   && requires (_Formatter __f, _ParseContext __pc)
    {
      { __f.parse(__pc) } -> same_as<typename _ParseContext::iterator>;
    };

  template<typename _Tp, typename _Context,
    typename _Formatter
      = typename _Context::template formatter_type<remove_const_t<_Tp>>,
    typename _ParseContext
      = basic_format_parse_context<typename _Context::char_type>>
    concept __formattable_with
      = semiregular<_Formatter>
   && requires (const _Formatter __cf, _Tp&& __t, _Context __fc)
    {
      { __cf.format(__t, __fc) } -> same_as<typename _Context::iterator>;
    };


  template<typename _CharT>
    using _Iter_for = back_insert_iterator<basic_string<_CharT>>;

  template<typename _Tp, typename _CharT,
    typename _Context = basic_format_context<_Iter_for<_CharT>, _CharT>>
    concept __formattable_impl
      = __parsable_with<_Tp, _Context> && __formattable_with<_Tp, _Context>;

}




  template<typename _Tp, typename _CharT>
    concept formattable
      = __format::__formattable_impl<remove_reference_t<_Tp>, _CharT>;
# 2569 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/format" 3
  template<typename _Out>
    struct format_to_n_result
    {
      _Out out;
      iter_difference_t<_Out> size;
    };


template<typename, typename> class vector;



namespace __format
{
  template<typename _CharT>
    class _Sink_iter
    {
      _Sink<_CharT>* _M_sink = nullptr;

    public:
      using iterator_category = output_iterator_tag;
      using value_type = void;
      using difference_type = ptrdiff_t;
      using pointer = void;
      using reference = void;

      _Sink_iter() = default;
      _Sink_iter(const _Sink_iter&) = default;
      _Sink_iter& operator=(const _Sink_iter&) = default;

      [[__gnu__::__always_inline__]]
      explicit constexpr
      _Sink_iter(_Sink<_CharT>& __sink) : _M_sink(std::addressof(__sink)) { }

      [[__gnu__::__always_inline__]]
      constexpr _Sink_iter&
      operator=(_CharT __c)
      {
 _M_sink->_M_write(__c);
 return *this;
      }

      [[__gnu__::__always_inline__]]
      constexpr _Sink_iter&
      operator=(basic_string_view<_CharT> __s)
      {
 _M_sink->_M_write(__s);
 return *this;
      }

      [[__gnu__::__always_inline__]]
      constexpr _Sink_iter&
      operator*() { return *this; }

      [[__gnu__::__always_inline__]]
      constexpr _Sink_iter&
      operator++() { return *this; }

      [[__gnu__::__always_inline__]]
      constexpr _Sink_iter
      operator++(int) { return *this; }

      auto
      _M_reserve(size_t __n) const
      { return _M_sink->_M_reserve(__n); }
    };




  template<typename _CharT>
    class _Sink
    {
      friend class _Sink_iter<_CharT>;

      span<_CharT> _M_span;
      typename span<_CharT>::iterator _M_next;





      virtual void _M_overflow() = 0;

    protected:

      [[__gnu__::__always_inline__]]
      explicit constexpr
      _Sink(span<_CharT> __span) noexcept
      : _M_span(__span), _M_next(__span.begin())
      { }


      [[__gnu__::__always_inline__]]
      span<_CharT>
      _M_used() const noexcept
      { return _M_span.first(_M_next - _M_span.begin()); }


      [[__gnu__::__always_inline__]]
      constexpr span<_CharT>
      _M_unused() const noexcept
      { return _M_span.subspan(_M_next - _M_span.begin()); }


      [[__gnu__::__always_inline__]]
      constexpr void
      _M_rewind() noexcept
      { _M_next = _M_span.begin(); }


      void
      _M_reset(span<_CharT> __s, size_t __pos = 0) noexcept
      {
 _M_span = __s;
 _M_next = __s.begin() + __pos;
      }


      constexpr void
      _M_write(_CharT __c)
      {
 *_M_next++ = __c;
 if (_M_next - _M_span.begin() == std::ssize(_M_span)) [[unlikely]]
   _M_overflow();
      }

      constexpr void
      _M_write(basic_string_view<_CharT> __s)
      {
 span __to = _M_unused();
 while (__to.size() <= __s.size())
   {
     __s.copy(__to.data(), __to.size());
     _M_next += __to.size();
     __s.remove_prefix(__to.size());
     _M_overflow();
     __to = _M_unused();
   }
 if (__s.size())
   {
     __s.copy(__to.data(), __s.size());
     _M_next += __s.size();
   }
      }



      struct _Reservation
      {

 explicit operator bool() const noexcept { return _M_sink; }

 _CharT* get() const noexcept { return _M_sink->_M_next.operator->(); }

 void _M_bump(size_t __n) { _M_sink->_M_bump(__n); }
 _Sink* _M_sink;
      };





      virtual _Reservation
      _M_reserve(size_t __n)
      {
 if (__n <= _M_unused().size())
   return { this };

 if (__n <= _M_span.size())
   {
     _M_overflow();
     if (__n <= _M_unused().size())
       return { this };
   }
 return { nullptr };
      }



      virtual void
      _M_bump(size_t __n)
      { _M_next += __n; }

    public:
      _Sink(const _Sink&) = delete;
      _Sink& operator=(const _Sink&) = delete;

      [[__gnu__::__always_inline__]]
      constexpr _Sink_iter<_CharT>
      out() noexcept
      { return _Sink_iter<_CharT>(*this); }
    };


  template<typename _CharT>
    class _Buf_sink : public _Sink<_CharT>
    {
    protected:
      _CharT _M_buf[32 * sizeof(void*) / sizeof(_CharT)];

      [[__gnu__::__always_inline__]]
      constexpr
      _Buf_sink() noexcept
      : _Sink<_CharT>(_M_buf)
      { }
    };

  using std::vector;



  template<typename _Seq>
    class _Seq_sink final : public _Buf_sink<typename _Seq::value_type>
    {
      using _CharT = typename _Seq::value_type;

      _Seq _M_seq;


      void
      _M_overflow() override
      {
 auto __s = this->_M_used();
 if (__s.empty()) [[unlikely]]
   return;


                                                   ;

 if constexpr (__is_specialization_of<_Seq, basic_string>)
   _M_seq.append(__s.data(), __s.size());
 else
   _M_seq.insert(_M_seq.end(), __s.begin(), __s.end());


 this->_M_rewind();
      }

      typename _Sink<_CharT>::_Reservation
      _M_reserve(size_t __n) override
      {







 if constexpr (__is_specialization_of<_Seq, basic_string>
   || __is_specialization_of<_Seq, vector>)
   {

     if (this->_M_used().size()) [[unlikely]]
       _Seq_sink::_M_overflow();


     const auto __sz = _M_seq.size();
     if constexpr (is_same_v<string, _Seq> || is_same_v<wstring, _Seq>)
       _M_seq.__resize_and_overwrite(__sz + __n,
         [](auto, auto __n2) {
           return __n2;
         });
     else
       _M_seq.resize(__sz + __n);



     this->_M_reset(_M_seq, __sz);
     return { this };
   }
 else
   return _Sink<_CharT>::_M_reserve(__n);
      }

      void
      _M_bump(size_t __n) override
      {
 if constexpr (__is_specialization_of<_Seq, basic_string>
   || __is_specialization_of<_Seq, vector>)
   {
     auto __s = this->_M_used();
                                                       ;

     _M_seq.resize(__s.size() + __n);

     this->_M_reset(this->_M_buf);
   }
      }

    public:



      [[__gnu__::__always_inline__]]
      _Seq_sink() noexcept(is_nothrow_default_constructible_v<_Seq>)
      { }

      _Seq_sink(_Seq&& __s) noexcept(is_nothrow_move_constructible_v<_Seq>)
      : _M_seq(std::move(__s))
      { }

      using _Sink<_CharT>::out;

      _Seq
      get() &&
      {
 if (this->_M_used().size() != 0)
   _Seq_sink::_M_overflow();
 return std::move(_M_seq);
      }



      span<_CharT>
      view()
      {
 auto __s = this->_M_used();
 if (_M_seq.size())
   {
     if (__s.size() != 0)
       _Seq_sink::_M_overflow();
     return _M_seq;
   }
 return __s;
      }
    };

  template<typename _CharT, typename _Alloc = allocator<_CharT>>
    using _Str_sink
      = _Seq_sink<basic_string<_CharT, char_traits<_CharT>, _Alloc>>;







  template<typename _CharT, typename _OutIter>
    class _Iter_sink : public _Buf_sink<_CharT>
    {
      _OutIter _M_out;
      iter_difference_t<_OutIter> _M_max;

    protected:
      size_t _M_count = 0;

      void
      _M_overflow() override
      {
 auto __s = this->_M_used();
 if (_M_max < 0)
   _M_out = ranges::copy(__s, std::move(_M_out)).out;
 else if (_M_count < static_cast<size_t>(_M_max))
   {
     auto __max = _M_max - _M_count;
     span<_CharT> __first;
     if (__max < __s.size())
       __first = __s.first(static_cast<size_t>(__max));
     else
       __first = __s;
     _M_out = ranges::copy(__first, std::move(_M_out)).out;
   }
 this->_M_rewind();
 _M_count += __s.size();
      }

    public:
      [[__gnu__::__always_inline__]]
      explicit
      _Iter_sink(_OutIter __out, iter_difference_t<_OutIter> __max = -1)
      : _M_out(std::move(__out)), _M_max(__max)
      { }

      using _Sink<_CharT>::out;

      format_to_n_result<_OutIter>
      _M_finish() &&
      {
 if (this->_M_used().size() != 0)
   _Iter_sink::_M_overflow();
 iter_difference_t<_OutIter> __count(_M_count);
 return { std::move(_M_out), __count };
      }
    };
# 2962 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/format" 3
  template<typename _CharT, contiguous_iterator _OutIter>
    requires same_as<iter_value_t<_OutIter>, _CharT>
    class _Iter_sink<_CharT, _OutIter> : public _Sink<_CharT>
    {
      _OutIter _M_first;
      iter_difference_t<_OutIter> _M_max = -1;
    protected:
      size_t _M_count = 0;
    private:
      _CharT _M_buf[64];

    protected:
      void
      _M_overflow() override
      {
 if (this->_M_unused().size() != 0)
   return;

 auto __s = this->_M_used();

 if (_M_max >= 0)
   {
     _M_count += __s.size();



     this->_M_reset(this->_M_buf);
   }
 else
   {


     this->_M_reset({__s.data(), __s.size() + 1024}, __s.size());
   }
      }

      typename _Sink<_CharT>::_Reservation
      _M_reserve(size_t __n) final
      {
 auto __avail = this->_M_unused();
 if (__n > __avail.size())
   {
     if (_M_max >= 0)
       return {};

     auto __s = this->_M_used();
     this->_M_reset({__s.data(), __s.size() + __n}, __s.size());
   }
 return { this };
      }

    private:
      static span<_CharT>
      _S_make_span(_CharT* __ptr, iter_difference_t<_OutIter> __n,
     span<_CharT> __buf) noexcept
      {
 if (__n == 0)
   return __buf;

 if (__n > 0)
   {
     if constexpr (!is_integral_v<iter_difference_t<_OutIter>>
       || sizeof(__n) > sizeof(size_t))
       {

  auto __m = iter_difference_t<_OutIter>((size_t)-1);
  if (__n > __m)
    __n = __m;
       }
     return {__ptr, (size_t)__n};
   }


 if (size_t __bytes = __builtin_dynamic_object_size(__ptr, 2))
   return {__ptr, __bytes / sizeof(_CharT)};


 const auto __off = reinterpret_cast<long unsigned int>(__ptr) % 1024;
 __n = (1024 - __off) / sizeof(_CharT);
 if (__n > 0) [[likely]]
   return {__ptr, static_cast<size_t>(__n)};
 else
   return {__ptr, 1};
      }

    public:
      explicit
      _Iter_sink(_OutIter __out, iter_difference_t<_OutIter> __n = -1) noexcept
      : _Sink<_CharT>(_S_make_span(std::to_address(__out), __n, _M_buf)),
 _M_first(__out), _M_max(__n)
      { }

      format_to_n_result<_OutIter>
      _M_finish() &&
      {
 auto __s = this->_M_used();
 if (__s.data() == _M_buf)
   {

     iter_difference_t<_OutIter> __count(_M_count + __s.size());
     return { _M_first + _M_max, __count };
   }
 else
   {
     iter_difference_t<_OutIter> __count(__s.size());
     return { _M_first + __count, __count };
   }
      }
    };

  enum _Arg_t : unsigned char {
    _Arg_none, _Arg_bool, _Arg_c, _Arg_i, _Arg_u, _Arg_ll, _Arg_ull,
    _Arg_flt, _Arg_dbl, _Arg_ldbl, _Arg_str, _Arg_sv, _Arg_ptr, _Arg_handle,
    _Arg_i128, _Arg_u128,
    _Arg_bf16, _Arg_f16, _Arg_f32, _Arg_f64,





    _Arg_f128,

    _Arg_max_
  };

  template<typename _Context>
    struct _Arg_value
    {
      using _CharT = typename _Context::char_type;

      struct _HandleBase
      {
 const void* _M_ptr;
 void (*_M_func)();
      };

      union
      {
 monostate _M_none;
 bool _M_bool;
 _CharT _M_c;
 int _M_i;
 unsigned _M_u;
 long long _M_ll;
 unsigned long long _M_ull;
 float _M_flt;
 double _M_dbl;

 long double _M_ldbl;

 const _CharT* _M_str;
 basic_string_view<_CharT> _M_sv;
 const void* _M_ptr;
 _HandleBase _M_handle;

 __int128 _M_i128;
 unsigned __int128 _M_u128;







      };

      [[__gnu__::__always_inline__]]
      _Arg_value() : _M_none() { }







      template<typename _Tp, typename _Self>
 [[__gnu__::__always_inline__]]
 static auto&
 _S_get(_Self& __u) noexcept
 {
   if constexpr (is_same_v<_Tp, bool>)
     return __u._M_bool;
   else if constexpr (is_same_v<_Tp, _CharT>)
     return __u._M_c;
   else if constexpr (is_same_v<_Tp, int>)
     return __u._M_i;
   else if constexpr (is_same_v<_Tp, unsigned>)
     return __u._M_u;
   else if constexpr (is_same_v<_Tp, long long>)
     return __u._M_ll;
   else if constexpr (is_same_v<_Tp, unsigned long long>)
     return __u._M_ull;
   else if constexpr (is_same_v<_Tp, float>)
     return __u._M_flt;
   else if constexpr (is_same_v<_Tp, double>)
     return __u._M_dbl;

   else if constexpr (is_same_v<_Tp, long double>)
     return __u._M_ldbl;






   else if constexpr (is_same_v<_Tp, const _CharT*>)
     return __u._M_str;
   else if constexpr (is_same_v<_Tp, basic_string_view<_CharT>>)
     return __u._M_sv;
   else if constexpr (is_same_v<_Tp, const void*>)
     return __u._M_ptr;

   else if constexpr (is_same_v<_Tp, __int128>)
     return __u._M_i128;
   else if constexpr (is_same_v<_Tp, unsigned __int128>)
     return __u._M_u128;





   else if constexpr (derived_from<_Tp, _HandleBase>)
     return static_cast<_Tp&>(__u._M_handle);

 }

      template<typename _Tp>
 [[__gnu__::__always_inline__]]
 auto&
 _M_get() noexcept
 { return _S_get<_Tp>(*this); }

      template<typename _Tp>
 [[__gnu__::__always_inline__]]
 const auto&
 _M_get() const noexcept
 { return _S_get<_Tp>(*this); }

      template<typename _Tp>
 [[__gnu__::__always_inline__]]
 void
 _M_set(_Tp __v) noexcept
 {
   if constexpr (derived_from<_Tp, _HandleBase>)
     std::construct_at(&_M_handle, __v);
   else
     _S_get<_Tp>(*this) = __v;
 }
      };


  template<typename _Context, typename... _Args>
    class _Arg_store;

}


  template<typename _Context>
    class basic_format_arg
    {
      using _CharT = typename _Context::char_type;

      template<typename _Tp>
 static constexpr bool __formattable
   = __format::__formattable_with<_Tp, _Context>;

    public:
      class handle : public __format::_Arg_value<_Context>::_HandleBase
      {
 using _Base = typename __format::_Arg_value<_Context>::_HandleBase;


 template<typename _Tp>
   using __maybe_const_t
     = __conditional_t<__formattable<const _Tp>, const _Tp, _Tp>;

 template<typename _Tq>
   static void
   _S_format(basic_format_parse_context<_CharT>& __parse_ctx,
      _Context& __format_ctx, const void* __ptr)
   {
     using _Td = remove_const_t<_Tq>;
     typename _Context::template formatter_type<_Td> __f;
     __parse_ctx.advance_to(__f.parse(__parse_ctx));
     _Tq& __val = *const_cast<_Tq*>(static_cast<const _Td*>(__ptr));
     __format_ctx.advance_to(__f.format(__val, __format_ctx));
   }

 template<typename _Tp>
   explicit
   handle(_Tp& __val) noexcept
   {
     this->_M_ptr = __builtin_addressof(__val);
     auto __func = _S_format<__maybe_const_t<_Tp>>;
     this->_M_func = reinterpret_cast<void(*)()>(__func);
   }

 friend class basic_format_arg<_Context>;

      public:
 handle(const handle&) = default;
 handle& operator=(const handle&) = default;

 [[__gnu__::__always_inline__]]
 void
 format(basic_format_parse_context<_CharT>& __pc, _Context& __fc) const
 {
   using _Func = void(*)(basic_format_parse_context<_CharT>&,
    _Context&, const void*);
   auto __f = reinterpret_cast<_Func>(this->_M_func);
   __f(__pc, __fc, this->_M_ptr);
 }
      };

      [[__gnu__::__always_inline__]]
      basic_format_arg() noexcept : _M_type(__format::_Arg_none) { }

      [[nodiscard,__gnu__::__always_inline__]]
      explicit operator bool() const noexcept
      { return _M_type != __format::_Arg_none; }

    private:
      template<typename _Ctx>
 friend class basic_format_args;

      template<typename _Ctx, typename... _Args>
 friend class __format::_Arg_store;

      static_assert(is_trivially_copyable_v<__format::_Arg_value<_Context>>);

      __format::_Arg_value<_Context> _M_val;
      __format::_Arg_t _M_type;




      template<typename _Tp>
 static consteval auto
 _S_to_arg_type()
 {
   using _Td = remove_const_t<_Tp>;
   if constexpr (is_same_v<_Td, bool>)
     return type_identity<bool>();
   else if constexpr (is_same_v<_Td, _CharT>)
     return type_identity<_CharT>();
   else if constexpr (is_same_v<_Td, char> && is_same_v<_CharT, wchar_t>)
     return type_identity<_CharT>();

   else if constexpr (is_same_v<_Td, __int128>)
     return type_identity<__int128>();
   else if constexpr (is_same_v<_Td, unsigned __int128>)
     return type_identity<unsigned __int128>();

   else if constexpr (__is_signed_integer<_Td>::value)
     {
       if constexpr (sizeof(_Td) <= sizeof(int))
  return type_identity<int>();
       else if constexpr (sizeof(_Td) <= sizeof(long long))
  return type_identity<long long>();
     }
   else if constexpr (__is_unsigned_integer<_Td>::value)
     {
       if constexpr (sizeof(_Td) <= sizeof(unsigned))
  return type_identity<unsigned>();
       else if constexpr (sizeof(_Td) <= sizeof(unsigned long long))
  return type_identity<unsigned long long>();
     }
   else if constexpr (is_same_v<_Td, float>)
     return type_identity<float>();
   else if constexpr (is_same_v<_Td, double>)
     return type_identity<double>();

   else if constexpr (is_same_v<_Td, long double>)
     return type_identity<long double>();
# 3344 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/format" 3
   else if constexpr (is_same_v<_Td, _Float16>)
     return type_identity<float>();
# 3379 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/format" 3
   else if constexpr (__is_specialization_of<_Td, basic_string_view>
       || __is_specialization_of<_Td, basic_string>)
     {
       if constexpr (is_same_v<typename _Td::value_type, _CharT>)
  return type_identity<basic_string_view<_CharT>>();
       else
  return type_identity<handle>();
     }
   else if constexpr (is_same_v<decay_t<_Td>, const _CharT*>)
     return type_identity<const _CharT*>();
   else if constexpr (is_same_v<decay_t<_Td>, _CharT*>)
     return type_identity<const _CharT*>();
   else if constexpr (is_void_v<remove_pointer_t<_Td>>)
     return type_identity<const void*>();
   else if constexpr (is_same_v<_Td, nullptr_t>)
     return type_identity<const void*>();
   else
     return type_identity<handle>();
 }


      template<typename _Tp>
 using _Normalize = typename decltype(_S_to_arg_type<_Tp>())::type;


      template<typename _Tp>
 static consteval __format::_Arg_t
 _S_to_enum()
 {
   using namespace __format;
   if constexpr (is_same_v<_Tp, bool>)
     return _Arg_bool;
   else if constexpr (is_same_v<_Tp, _CharT>)
     return _Arg_c;
   else if constexpr (is_same_v<_Tp, int>)
     return _Arg_i;
   else if constexpr (is_same_v<_Tp, unsigned>)
     return _Arg_u;
   else if constexpr (is_same_v<_Tp, long long>)
     return _Arg_ll;
   else if constexpr (is_same_v<_Tp, unsigned long long>)
     return _Arg_ull;
   else if constexpr (is_same_v<_Tp, float>)
     return _Arg_flt;
   else if constexpr (is_same_v<_Tp, double>)
     return _Arg_dbl;

   else if constexpr (is_same_v<_Tp, long double>)
     return _Arg_ldbl;







   else if constexpr (is_same_v<_Tp, const _CharT*>)
     return _Arg_str;
   else if constexpr (is_same_v<_Tp, basic_string_view<_CharT>>)
     return _Arg_sv;
   else if constexpr (is_same_v<_Tp, const void*>)
     return _Arg_ptr;

   else if constexpr (is_same_v<_Tp, __int128>)
     return _Arg_i128;
   else if constexpr (is_same_v<_Tp, unsigned __int128>)
     return _Arg_u128;
# 3462 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/format" 3
   else if constexpr (is_same_v<_Tp, handle>)
     return _Arg_handle;
 }

      template<typename _Tp>
 void
 _M_set(_Tp __v) noexcept
 {
   _M_type = _S_to_enum<_Tp>();
   _M_val._M_set(__v);
 }

      template<typename _Tp>
 requires __format::__formattable_with<_Tp, _Context>
 explicit
 basic_format_arg(_Tp& __v) noexcept
 {
   using _Td = _Normalize<_Tp>;
   if constexpr (is_same_v<_Td, basic_string_view<_CharT>>)
     _M_set(_Td{__v.data(), __v.size()});
   else if constexpr (is_same_v<remove_const_t<_Tp>, char>
          && is_same_v<_CharT, wchar_t>)
     _M_set(static_cast<_Td>(static_cast<unsigned char>(__v)));
   else
     _M_set(static_cast<_Td>(__v));
 }

      template<typename _Ctx, typename... _Argz>
 friend auto
 make_format_args(_Argz&...) noexcept;

      template<typename _Visitor, typename _Ctx>
 friend decltype(auto)
 visit_format_arg(_Visitor&& __vis, basic_format_arg<_Ctx>);

      template<typename _Visitor>
 decltype(auto)
 _M_visit(_Visitor&& __vis, __format::_Arg_t __type)
 {
   using namespace __format;
   switch (__type)
   {
     case _Arg_none:
       return std::forward<_Visitor>(__vis)(_M_val._M_none);
     case _Arg_bool:
       return std::forward<_Visitor>(__vis)(_M_val._M_bool);
     case _Arg_c:
       return std::forward<_Visitor>(__vis)(_M_val._M_c);
     case _Arg_i:
       return std::forward<_Visitor>(__vis)(_M_val._M_i);
     case _Arg_u:
       return std::forward<_Visitor>(__vis)(_M_val._M_u);
     case _Arg_ll:
       return std::forward<_Visitor>(__vis)(_M_val._M_ll);
     case _Arg_ull:
       return std::forward<_Visitor>(__vis)(_M_val._M_ull);

     case _Arg_flt:
       return std::forward<_Visitor>(__vis)(_M_val._M_flt);
     case _Arg_dbl:
       return std::forward<_Visitor>(__vis)(_M_val._M_dbl);

     case _Arg_ldbl:
       return std::forward<_Visitor>(__vis)(_M_val._M_ldbl);







     case _Arg_str:
       return std::forward<_Visitor>(__vis)(_M_val._M_str);
     case _Arg_sv:
       return std::forward<_Visitor>(__vis)(_M_val._M_sv);
     case _Arg_ptr:
       return std::forward<_Visitor>(__vis)(_M_val._M_ptr);
     case _Arg_handle:
     {
       auto& __h = static_cast<handle&>(_M_val._M_handle);
       return std::forward<_Visitor>(__vis)(__h);
     }

     case _Arg_i128:
       return std::forward<_Visitor>(__vis)(_M_val._M_i128);
     case _Arg_u128:
       return std::forward<_Visitor>(__vis)(_M_val._M_u128);







     default:

       __builtin_unreachable();
   }
 }
    };

  template<typename _Visitor, typename _Context>
    inline decltype(auto)
    visit_format_arg(_Visitor&& __vis, basic_format_arg<_Context> __arg)
    {
      return __arg._M_visit(std::forward<_Visitor>(__vis), __arg._M_type);
    }


namespace __format
{
  struct _WidthPrecVisitor
  {
    template<typename _Tp>
      size_t
      operator()(_Tp& __arg) const
      {
 if constexpr (is_same_v<_Tp, monostate>)
   __format::__invalid_arg_id_in_format_string();



 else if constexpr (sizeof(_Tp) <= sizeof(long long))
   {


     if constexpr (__is_unsigned_integer<_Tp>::value)
       return __arg;
     else if constexpr (__is_signed_integer<_Tp>::value)
       if (__arg >= 0)
  return __arg;
   }
 __throw_format_error("format error: argument used for width or "
        "precision must be a non-negative integer");
      }
  };

  template<typename _Context>
    inline size_t
    __int_from_arg(const basic_format_arg<_Context>& __arg)
    { return std::visit_format_arg(_WidthPrecVisitor(), __arg); }


  template<int _Bits, size_t _Nm>
    constexpr auto
    __pack_arg_types(const array<_Arg_t, _Nm>& __types)
    {
      long unsigned int __packed_types = 0;
      for (auto __i = __types.rbegin(); __i != __types.rend(); ++__i)
 __packed_types = (__packed_types << _Bits) | *__i;
      return __packed_types;
    }
}


  template<typename _Context>
    class basic_format_args
    {
      static constexpr int _S_packed_type_bits = 5;
      static constexpr int _S_packed_type_mask = 0b11111;
      static constexpr int _S_max_packed_args = 12;

      static_assert( __format::_Arg_max_ <= (1 << _S_packed_type_bits) );

      template<typename... _Args>
 using _Store = __format::_Arg_store<_Context, _Args...>;

      template<typename _Ctx, typename... _Args>
 friend class __format::_Arg_store;

      using uint64_t = long unsigned int;
      using _Format_arg = basic_format_arg<_Context>;
      using _Format_arg_val = __format::_Arg_value<_Context>;





      uint64_t _M_packed_size : 4;
      uint64_t _M_unpacked_size : 60;

      union {
 const _Format_arg_val* _M_values;
 const _Format_arg* _M_args;
      };

      size_t
      _M_size() const noexcept
      { return _M_packed_size ? _M_packed_size : _M_unpacked_size; }

      typename __format::_Arg_t
      _M_type(size_t __i) const noexcept
      {
 uint64_t __t = _M_unpacked_size >> (__i * _S_packed_type_bits);
 return static_cast<__format::_Arg_t>(__t & _S_packed_type_mask);
      }

      template<typename _Ctx, typename... _Args>
 friend auto
 make_format_args(_Args&...) noexcept;


      template<typename... _Args>
 static consteval array<__format::_Arg_t, sizeof...(_Args)>
 _S_types_to_pack()
 { return {_Format_arg::template _S_to_enum<_Args>()...}; }

    public:
      basic_format_args() noexcept = default;

      template<typename... _Args>
 basic_format_args(const _Store<_Args...>& __store) noexcept;

      [[nodiscard,__gnu__::__always_inline__]]
      basic_format_arg<_Context>
      get(size_t __i) const noexcept
      {
 basic_format_arg<_Context> __arg;
 if (__i < _M_packed_size)
   {
     __arg._M_type = _M_type(__i);
     __arg._M_val = _M_values[__i];
   }
 else if (_M_packed_size == 0 && __i < _M_unpacked_size)
   __arg = _M_args[__i];
 return __arg;
      }
    };



  template<typename _Context, typename... _Args>
    basic_format_args(__format::_Arg_store<_Context, _Args...>)
      -> basic_format_args<_Context>;

  template<typename _Context, typename... _Args>
    auto
    make_format_args(_Args&... __fmt_args) noexcept;


  template<typename _Context, typename... _Args>
    class __format::_Arg_store
    {
      friend std::basic_format_args<_Context>;

      template<typename _Ctx, typename... _Argz>
 friend auto std::



 make_format_args(_Argz&...) noexcept;



      static constexpr bool _S_values_only
 = sizeof...(_Args) <= basic_format_args<_Context>::_S_max_packed_args;

      using _Element_t
 = __conditional_t<_S_values_only,
     __format::_Arg_value<_Context>,
     basic_format_arg<_Context>>;

      _Element_t _M_args[sizeof...(_Args)];

      template<typename _Tp>
 static _Element_t
 _S_make_elt(_Tp& __v)
 {
   using _Tq = remove_const_t<_Tp>;
   using _CharT = typename _Context::char_type;
   static_assert(is_default_constructible_v<formatter<_Tq, _CharT>>,
   "std::formatter must be specialized for the type "
   "of each format arg");
   using __format::__formattable_with;
   if constexpr (is_const_v<_Tp>)
     if constexpr (!__formattable_with<_Tp, _Context>)
       if constexpr (__formattable_with<_Tq, _Context>)
  static_assert(__formattable_with<_Tp, _Context>,
         "format arg must be non-const because its "
         "std::formatter specialization has a "
         "non-const reference parameter");
   basic_format_arg<_Context> __arg(__v);
   if constexpr (_S_values_only)
     return __arg._M_val;
   else
     return __arg;
 }

      template<typename... _Tp>
 requires (sizeof...(_Tp) == sizeof...(_Args))
 [[__gnu__::__always_inline__]]
 _Arg_store(_Tp&... __a) noexcept
 : _M_args{_S_make_elt(__a)...}
 { }
    };

  template<typename _Context>
    class __format::_Arg_store<_Context>
    { };

  template<typename _Context>
    template<typename... _Args>
      inline
      basic_format_args<_Context>::
      basic_format_args(const _Store<_Args...>& __store) noexcept
      {
 if constexpr (sizeof...(_Args) == 0)
   {
     _M_packed_size = 0;
     _M_unpacked_size = 0;
     _M_args = nullptr;
   }
 else if constexpr (sizeof...(_Args) <= _S_max_packed_args)
   {

     _M_packed_size = sizeof...(_Args);

     _M_unpacked_size
       = __format::__pack_arg_types<_S_packed_type_bits>(_S_types_to_pack<_Args...>());

     _M_values = __store._M_args;
   }
 else
   {

     _M_packed_size = 0;

     _M_unpacked_size = sizeof...(_Args);

     _M_args = __store._M_args;
   }
      }


  template<typename _Context = format_context, typename... _Args>
    [[nodiscard,__gnu__::__always_inline__]]
    inline auto
    make_format_args(_Args&... __fmt_args) noexcept
    {
      using _Fmt_arg = basic_format_arg<_Context>;
      using _Store = __format::_Arg_store<_Context, typename _Fmt_arg::template
       _Normalize<_Args>...>;
      return _Store(__fmt_args...);
    }



  template<typename... _Args>
    [[nodiscard,__gnu__::__always_inline__]]
    inline auto
    make_wformat_args(_Args&... __args) noexcept
    { return std::make_format_args<wformat_context>(__args...); }



namespace __format
{
  template<typename _Out, typename _CharT, typename _Context>
    _Out
    __do_vformat_to(_Out, basic_string_view<_CharT>,
      const basic_format_args<_Context>&,
      const locale* = nullptr);
}
# 3835 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/format" 3
  template<typename _Out, typename _CharT>
    class basic_format_context
    {
      static_assert( output_iterator<_Out, const _CharT&> );

      basic_format_args<basic_format_context> _M_args;
      _Out _M_out;
      __format::_Optional_locale _M_loc;

      basic_format_context(basic_format_args<basic_format_context> __args,
      _Out __out)
      : _M_args(__args), _M_out(std::move(__out))
      { }

      basic_format_context(basic_format_args<basic_format_context> __args,
      _Out __out, const std::locale& __loc)
      : _M_args(__args), _M_out(std::move(__out)), _M_loc(__loc)
      { }

      template<typename _Out2, typename _CharT2, typename _Context2>
 friend _Out2
 __format::__do_vformat_to(_Out2, basic_string_view<_CharT2>,
      const basic_format_args<_Context2>&,
      const locale*);

    public:
      basic_format_context() = default;
      ~basic_format_context() = default;

      using iterator = _Out;
      using char_type = _CharT;
      template<typename _Tp>
 using formatter_type = formatter<_Tp, _CharT>;

      [[nodiscard]]
      basic_format_arg<basic_format_context>
      arg(size_t __id) const noexcept
      { return _M_args.get(__id); }

      [[nodiscard]]
      std::locale locale() { return _M_loc.value(); }

      [[nodiscard]]
      iterator out() { return std::move(_M_out); }

      void advance_to(iterator __it) { _M_out = std::move(__it); }
    };



namespace __format
{





  template<typename _CharT>
    struct _Scanner
    {
      using iterator = typename basic_format_parse_context<_CharT>::iterator;

      basic_format_parse_context<_CharT> _M_pc;

      constexpr explicit
      _Scanner(basic_string_view<_CharT> __str, size_t __nargs = -1)
      : _M_pc(__str, __nargs)
      { }

      constexpr iterator begin() const noexcept { return _M_pc.begin(); }
      constexpr iterator end() const noexcept { return _M_pc.end(); }

      constexpr void
      _M_scan()
      {
 basic_string_view<_CharT> __fmt = _M_fmt_str();

 if (__fmt.size() == 2 && __fmt[0] == '{' && __fmt[1] == '}')
   {
     _M_pc.advance_to(begin() + 1);
     _M_format_arg(_M_pc.next_arg_id());
     return;
   }

 size_t __lbr = __fmt.find('{');
 size_t __rbr = __fmt.find('}');

 while (__fmt.size())
   {
     auto __cmp = __lbr <=> __rbr;
     if (__cmp == 0)
       {
  _M_on_chars(end());
  _M_pc.advance_to(end());
  return;
       }
     else if (__cmp < 0)
       {
  if (__lbr + 1 == __fmt.size()
        || (__rbr == __fmt.npos && __fmt[__lbr + 1] != '{'))
    __format::__unmatched_left_brace_in_format_string();
  const bool __is_escape = __fmt[__lbr + 1] == '{';
  iterator __last = begin() + __lbr + int(__is_escape);
  _M_on_chars(__last);
  _M_pc.advance_to(__last + 1);
  __fmt = _M_fmt_str();
  if (__is_escape)
    {
      if (__rbr != __fmt.npos)
        __rbr -= __lbr + 2;
      __lbr = __fmt.find('{');
    }
  else
    {
      _M_on_replacement_field();
      __fmt = _M_fmt_str();
      __lbr = __fmt.find('{');
      __rbr = __fmt.find('}');
    }
       }
     else
       {
  if (++__rbr == __fmt.size() || __fmt[__rbr] != '}')
    __format::__unmatched_right_brace_in_format_string();
  iterator __last = begin() + __rbr;
  _M_on_chars(__last);
  _M_pc.advance_to(__last + 1);
  __fmt = _M_fmt_str();
  if (__lbr != __fmt.npos)
    __lbr -= __rbr + 1;
  __rbr = __fmt.find('}');
       }
   }
      }

      constexpr basic_string_view<_CharT>
      _M_fmt_str() const noexcept
      { return {begin(), end()}; }

      constexpr virtual void _M_on_chars(iterator) { }

      constexpr void _M_on_replacement_field()
      {
 auto __next = begin();

 size_t __id;
 if (*__next == '}')
   __id = _M_pc.next_arg_id();
 else if (*__next == ':')
   {
     __id = _M_pc.next_arg_id();
     _M_pc.advance_to(++__next);
   }
 else
   {
     auto [__i, __ptr] = __format::__parse_arg_id(begin(), end());
     if (!__ptr || !(*__ptr == '}' || *__ptr == ':'))
       __format::__invalid_arg_id_in_format_string();
     _M_pc.check_arg_id(__id = __i);
     if (*__ptr == ':')
       {
  _M_pc.advance_to(++__ptr);
       }
     else
       _M_pc.advance_to(__ptr);
   }
 _M_format_arg(__id);
 if (begin() == end() || *begin() != '}')
   __format::__unmatched_left_brace_in_format_string();
 _M_pc.advance_to(begin() + 1);
      }

      constexpr virtual void _M_format_arg(size_t __id) = 0;
    };


  template<typename _Out, typename _CharT>
    class _Formatting_scanner : public _Scanner<_CharT>
    {
    public:
      _Formatting_scanner(basic_format_context<_Out, _CharT>& __fc,
     basic_string_view<_CharT> __str)
      : _Scanner<_CharT>(__str), _M_fc(__fc)
      { }

    private:
      basic_format_context<_Out, _CharT>& _M_fc;

      using iterator = typename _Scanner<_CharT>::iterator;

      constexpr void
      _M_on_chars(iterator __last) override
      {
 basic_string_view<_CharT> __str(this->begin(), __last);
 _M_fc.advance_to(__format::__write(_M_fc.out(), __str));
      }

      constexpr void
      _M_format_arg(size_t __id) override
      {
 using _Context = basic_format_context<_Out, _CharT>;
 using handle = typename basic_format_arg<_Context>::handle;

 std::visit_format_arg([this](auto& __arg) {
   using _Type = remove_reference_t<decltype(__arg)>;
   using _Formatter = typename _Context::template formatter_type<_Type>;
   if constexpr (is_same_v<_Type, monostate>)
     __format::__invalid_arg_id_in_format_string();
   else if constexpr (is_same_v<_Type, handle>)
     __arg.format(this->_M_pc, this->_M_fc);
   else if constexpr (is_default_constructible_v<_Formatter>)
     {
       _Formatter __f;
       this->_M_pc.advance_to(__f.parse(this->_M_pc));
       this->_M_fc.advance_to(__f.format(__arg, this->_M_fc));
     }
   else
     static_assert(__format::__formattable_with<_Type, _Context>);
 }, _M_fc.arg(__id));
      }
    };


  template<typename _CharT, typename... _Args>
    class _Checking_scanner : public _Scanner<_CharT>
    {
      static_assert(
 (is_default_constructible_v<formatter<_Args, _CharT>> && ...),
 "std::formatter must be specialized for each type being formatted");

    public:
      constexpr
      _Checking_scanner(basic_string_view<_CharT> __str)
      : _Scanner<_CharT>(__str, sizeof...(_Args))
      { }

    private:
      constexpr void
      _M_format_arg(size_t __id) override
      {
 if constexpr (sizeof...(_Args) != 0)
   {
     if (__id < sizeof...(_Args))
       {
  _M_parse_format_spec<_Args...>(__id);
  return;
       }
   }
 __builtin_unreachable();
      }

      template<typename _Tp, typename... _OtherArgs>
 constexpr void
 _M_parse_format_spec(size_t __id)
 {
   if (__id == 0)
     {
       formatter<_Tp, _CharT> __f;
       this->_M_pc.advance_to(__f.parse(this->_M_pc));
     }
   else if constexpr (sizeof...(_OtherArgs) != 0)
     _M_parse_format_spec<_OtherArgs...>(__id - 1);
   else
     __builtin_unreachable();
 }
    };

  template<typename _Out, typename _CharT, typename _Context>
    inline _Out
    __do_vformat_to(_Out __out, basic_string_view<_CharT> __fmt,
      const basic_format_args<_Context>& __args,
      const locale* __loc)
    {
      _Iter_sink<_CharT, _Out> __sink(std::move(__out));
      _Sink_iter<_CharT> __sink_out;

      if constexpr (is_same_v<_Out, _Sink_iter<_CharT>>)
 __sink_out = __out;
      else
 __sink_out = __sink.out();

      if constexpr (is_same_v<_CharT, char>)

 if (__fmt.size() == 2 && __fmt[0] == '{' && __fmt[1] == '}')
   {
     bool __done = false;
     std::visit_format_arg([&](auto& __arg) {
       using _Tp = remove_cvref_t<decltype(__arg)>;
       if constexpr (is_same_v<_Tp, bool>)
  {
    size_t __len = 4 + !__arg;
    const char* __chars[] = { "false", "true" };
    if (auto __res = __sink_out._M_reserve(__len))
      {
        __builtin_memcpy(__res.get(), __chars[__arg], __len);
        __res._M_bump(__len);
        __done = true;
      }
  }
       else if constexpr (is_same_v<_Tp, char>)
  {
    if (auto __res = __sink_out._M_reserve(1))
      {
        *__res.get() = __arg;
        __res._M_bump(1);
        __done = true;
      }
  }
       else if constexpr (is_integral_v<_Tp>)
  {
    make_unsigned_t<_Tp> __uval;
    const bool __neg = __arg < 0;
    if (__neg)
      __uval = make_unsigned_t<_Tp>(~__arg) + 1u;
    else
      __uval = __arg;
    const auto __n = __detail::__to_chars_len(__uval);
    if (auto __res = __sink_out._M_reserve(__n + __neg))
      {
        auto __ptr = __res.get();
        *__ptr = '-';
        __detail::__to_chars_10_impl(__ptr + (int)__neg, __n,
         __uval);
        __res._M_bump(__n + __neg);
        __done = true;
      }
  }
       else if constexpr (is_convertible_v<_Tp, string_view>)
  {
    string_view __sv = __arg;
    if (auto __res = __sink_out._M_reserve(__sv.size()))
      {
        __builtin_memcpy(__res.get(), __sv.data(), __sv.size());
        __res._M_bump(__sv.size());
        __done = true;
      }
  }
     }, __args.get(0));

     if (__done)
       {
  if constexpr (is_same_v<_Out, _Sink_iter<_CharT>>)
    return __sink_out;
  else
    return std::move(__sink)._M_finish().out;
       }
   }

      auto __ctx = __loc == nullptr
       ? _Context(__args, __sink_out)
       : _Context(__args, __sink_out, *__loc);
      _Formatting_scanner<_Sink_iter<_CharT>, _CharT> __scanner(__ctx, __fmt);
      __scanner._M_scan();

      if constexpr (is_same_v<_Out, _Sink_iter<_CharT>>)
 return __ctx.out();
      else
 return std::move(__sink)._M_finish().out;
    }

}


  template<typename _CharT, typename... _Args>
    template<typename _Tp>
      requires convertible_to<const _Tp&, basic_string_view<_CharT>>
      consteval
      basic_format_string<_CharT, _Args...>::
      basic_format_string(const _Tp& __s)
      : _M_str(__s)
      {
 __format::_Checking_scanner<_CharT, remove_cvref_t<_Args>...>
   __scanner(_M_str);
 __scanner._M_scan();
      }



  template<typename _Out> requires output_iterator<_Out, const char&>
    [[__gnu__::__always_inline__]]
    inline _Out
    vformat_to(_Out __out, string_view __fmt, format_args __args)
    { return __format::__do_vformat_to(std::move(__out), __fmt, __args); }


  template<typename _Out> requires output_iterator<_Out, const wchar_t&>
    [[__gnu__::__always_inline__]]
    inline _Out
    vformat_to(_Out __out, wstring_view __fmt, wformat_args __args)
    { return __format::__do_vformat_to(std::move(__out), __fmt, __args); }


  template<typename _Out> requires output_iterator<_Out, const char&>
    [[__gnu__::__always_inline__]]
    inline _Out
    vformat_to(_Out __out, const locale& __loc, string_view __fmt,
        format_args __args)
    {
      return __format::__do_vformat_to(std::move(__out), __fmt, __args, &__loc);
    }


  template<typename _Out> requires output_iterator<_Out, const wchar_t&>
    [[__gnu__::__always_inline__]]
    inline _Out
    vformat_to(_Out __out, const locale& __loc, wstring_view __fmt,
        wformat_args __args)
    {
      return __format::__do_vformat_to(std::move(__out), __fmt, __args, &__loc);
    }


  [[nodiscard]]
  inline string
  vformat(string_view __fmt, format_args __args)
  {
    __format::_Str_sink<char> __buf;
    std::vformat_to(__buf.out(), __fmt, __args);
    return std::move(__buf).get();
  }


  [[nodiscard]]
  inline wstring
  vformat(wstring_view __fmt, wformat_args __args)
  {
    __format::_Str_sink<wchar_t> __buf;
    std::vformat_to(__buf.out(), __fmt, __args);
    return std::move(__buf).get();
  }


  [[nodiscard]]
  inline string
  vformat(const locale& __loc, string_view __fmt, format_args __args)
  {
    __format::_Str_sink<char> __buf;
    std::vformat_to(__buf.out(), __loc, __fmt, __args);
    return std::move(__buf).get();
  }


  [[nodiscard]]
  inline wstring
  vformat(const locale& __loc, wstring_view __fmt, wformat_args __args)
  {
    __format::_Str_sink<wchar_t> __buf;
    std::vformat_to(__buf.out(), __loc, __fmt, __args);
    return std::move(__buf).get();
  }


  template<typename... _Args>
    [[nodiscard]]
    inline string
    format(format_string<_Args...> __fmt, _Args&&... __args)
    { return std::vformat(__fmt.get(), std::make_format_args(__args...)); }


  template<typename... _Args>
    [[nodiscard]]
    inline wstring
    format(wformat_string<_Args...> __fmt, _Args&&... __args)
    { return std::vformat(__fmt.get(), std::make_wformat_args(__args...)); }


  template<typename... _Args>
    [[nodiscard]]
    inline string
    format(const locale& __loc, format_string<_Args...> __fmt,
    _Args&&... __args)
    {
      return std::vformat(__loc, __fmt.get(),
     std::make_format_args(__args...));
    }


  template<typename... _Args>
    [[nodiscard]]
    inline wstring
    format(const locale& __loc, wformat_string<_Args...> __fmt,
    _Args&&... __args)
    {
      return std::vformat(__loc, __fmt.get(),
     std::make_wformat_args(__args...));
    }


  template<typename _Out, typename... _Args>
    requires output_iterator<_Out, const char&>
    inline _Out
    format_to(_Out __out, format_string<_Args...> __fmt, _Args&&... __args)
    {
      return std::vformat_to(std::move(__out), __fmt.get(),
        std::make_format_args(__args...));
    }


  template<typename _Out, typename... _Args>
    requires output_iterator<_Out, const wchar_t&>
    inline _Out
    format_to(_Out __out, wformat_string<_Args...> __fmt, _Args&&... __args)
    {
      return std::vformat_to(std::move(__out), __fmt.get(),
        std::make_wformat_args(__args...));
    }


  template<typename _Out, typename... _Args>
    requires output_iterator<_Out, const char&>
    inline _Out
    format_to(_Out __out, const locale& __loc, format_string<_Args...> __fmt,
       _Args&&... __args)
    {
      return std::vformat_to(std::move(__out), __loc, __fmt.get(),
        std::make_format_args(__args...));
    }


  template<typename _Out, typename... _Args>
    requires output_iterator<_Out, const wchar_t&>
    inline _Out
    format_to(_Out __out, const locale& __loc, wformat_string<_Args...> __fmt,
       _Args&&... __args)
    {
      return std::vformat_to(std::move(__out), __loc, __fmt.get(),
        std::make_wformat_args(__args...));
    }


  template<typename _Out, typename... _Args>
    requires output_iterator<_Out, const char&>
    inline format_to_n_result<_Out>
    format_to_n(_Out __out, iter_difference_t<_Out> __n,
  format_string<_Args...> __fmt, _Args&&... __args)
    {
      __format::_Iter_sink<char, _Out> __sink(std::move(__out), __n);
      std::vformat_to(__sink.out(), __fmt.get(),
        std::make_format_args(__args...));
      return std::move(__sink)._M_finish();
    }


  template<typename _Out, typename... _Args>
    requires output_iterator<_Out, const wchar_t&>
    inline format_to_n_result<_Out>
    format_to_n(_Out __out, iter_difference_t<_Out> __n,
  wformat_string<_Args...> __fmt, _Args&&... __args)
    {
      __format::_Iter_sink<wchar_t, _Out> __sink(std::move(__out), __n);
      std::vformat_to(__sink.out(), __fmt.get(),
        std::make_wformat_args(__args...));
      return std::move(__sink)._M_finish();
    }


  template<typename _Out, typename... _Args>
    requires output_iterator<_Out, const char&>
    inline format_to_n_result<_Out>
    format_to_n(_Out __out, iter_difference_t<_Out> __n, const locale& __loc,
  format_string<_Args...> __fmt, _Args&&... __args)
    {
      __format::_Iter_sink<char, _Out> __sink(std::move(__out), __n);
      std::vformat_to(__sink.out(), __loc, __fmt.get(),
        std::make_format_args(__args...));
      return std::move(__sink)._M_finish();
    }


  template<typename _Out, typename... _Args>
    requires output_iterator<_Out, const wchar_t&>
    inline format_to_n_result<_Out>
    format_to_n(_Out __out, iter_difference_t<_Out> __n, const locale& __loc,
  wformat_string<_Args...> __fmt, _Args&&... __args)
    {
      __format::_Iter_sink<wchar_t, _Out> __sink(std::move(__out), __n);
      std::vformat_to(__sink.out(), __loc, __fmt.get(),
        std::make_wformat_args(__args...));
      return std::move(__sink)._M_finish();
    }



namespace __format
{

  template<typename _CharT>
    class _Counting_sink final : public _Iter_sink<_CharT, _CharT*>
    {
    public:
      _Counting_sink() : _Iter_sink<_CharT, _CharT*>(nullptr, 0) { }

      [[__gnu__::__always_inline__]]
      size_t
      count() const
      { return this->_M_count + this->_M_used().size(); }
    };
# 4458 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/format" 3
}


  template<typename... _Args>
    [[nodiscard]]
    inline size_t
    formatted_size(format_string<_Args...> __fmt, _Args&&... __args)
    {
      __format::_Counting_sink<char> __buf;
      std::vformat_to(__buf.out(), __fmt.get(),
        std::make_format_args(__args...));
      return __buf.count();
    }


  template<typename... _Args>
    [[nodiscard]]
    inline size_t
    formatted_size(wformat_string<_Args...> __fmt, _Args&&... __args)
    {
      __format::_Counting_sink<wchar_t> __buf;
      std::vformat_to(__buf.out(), __fmt.get(),
        std::make_wformat_args(__args...));
      return __buf.count();
    }


  template<typename... _Args>
    [[nodiscard]]
    inline size_t
    formatted_size(const locale& __loc, format_string<_Args...> __fmt,
     _Args&&... __args)
    {
      __format::_Counting_sink<char> __buf;
      std::vformat_to(__buf.out(), __loc, __fmt.get(),
        std::make_format_args(__args...));
      return __buf.count();
    }


  template<typename... _Args>
    [[nodiscard]]
    inline size_t
    formatted_size(const locale& __loc, wformat_string<_Args...> __fmt,
     _Args&&... __args)
    {
      __format::_Counting_sink<wchar_t> __buf;
      std::vformat_to(__buf.out(), __loc, __fmt.get(),
        std::make_wformat_args(__args...));
      return __buf.count();
    }
# 4581 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/format" 3
}
# 44 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ostream" 2 3



# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ostream" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{
# 65 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ostream" 3
  template<typename _CharT, typename _Traits>
    class basic_ostream : virtual public basic_ios<_CharT, _Traits>
    {
    public:

      typedef _CharT char_type;
      typedef typename _Traits::int_type int_type;
      typedef typename _Traits::pos_type pos_type;
      typedef typename _Traits::off_type off_type;
      typedef _Traits traits_type;


      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
      typedef basic_ios<_CharT, _Traits> __ios_type;
      typedef basic_ostream<_CharT, _Traits> __ostream_type;
      typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> >
             __num_put_type;
      typedef ctype<_CharT> __ctype_type;
# 91 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ostream" 3
      explicit
      basic_ostream(__streambuf_type* __sb)
      { this->init(__sb); }






      virtual
      ~basic_ostream() { }


      class sentry;
      friend class sentry;
# 115 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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;
      }
# 173 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ostream" 3
      __ostream_type&
      operator<<(long __n)
      { return _M_insert(__n); }

      __ostream_type&
      operator<<(unsigned long __n)
      { return _M_insert(__n); }

      __ostream_type&
      operator<<(bool __n)
      { return _M_insert(__n); }

      __ostream_type&
      operator<<(short __n);

      __ostream_type&
      operator<<(unsigned short __n)
      {


 return _M_insert(static_cast<unsigned long>(__n));
      }

      __ostream_type&
      operator<<(int __n);

      __ostream_type&
      operator<<(unsigned int __n)
      {


 return _M_insert(static_cast<unsigned long>(__n));
      }


      __ostream_type&
      operator<<(long long __n)
      { return _M_insert(__n); }

      __ostream_type&
      operator<<(unsigned long long __n)
      { return _M_insert(__n); }
# 227 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ostream" 3
      __ostream_type&
      operator<<(double __f)
      { return _M_insert(__f); }

      __ostream_type&
      operator<<(float __f)
      {


 return _M_insert(static_cast<double>(__f));
      }

      __ostream_type&
      operator<<(long double __f)
      { return _M_insert(__f); }
# 297 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ostream" 3
      __ostream_type&
      operator<<(const void* __p)
      { return _M_insert(__p); }


      __ostream_type&
      operator<<(nullptr_t)
      { return *this << "nullptr"; }



      __attribute__((__always_inline__))
      __ostream_type&
      operator<<(const volatile void* __p)
      { return _M_insert(const_cast<const void*>(__p)); }
# 335 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ostream" 3
      __ostream_type&
      operator<<(__streambuf_type* __sb);
# 368 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ostream" 3
      __ostream_type&
      put(char_type __c);
# 387 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ostream" 3
      __ostream_type&
      write(const char_type* __s, streamsize __n);
# 400 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ostream" 3
      __ostream_type&
      flush();
# 410 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ostream" 3
      pos_type
      tellp();
# 421 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ostream" 3
      __ostream_type&
      seekp(pos_type);
# 433 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ostream" 3
       __ostream_type&
      seekp(off_type, ios_base::seekdir);

    protected:
      basic_ostream()
      { this->init(0); }



      basic_ostream(basic_iostream<_CharT, _Traits>&) { }

      basic_ostream(const basic_ostream&) = delete;

      basic_ostream(basic_ostream&& __rhs)
      : __ios_type()
      { __ios_type::move(__rhs); }



      basic_ostream& operator=(const basic_ostream&) = delete;

      basic_ostream&
      operator=(basic_ostream&& __rhs)
      {
 swap(__rhs);
 return *this;
      }

      void
      swap(basic_ostream& __rhs)
      { __ios_type::swap(__rhs); }


      template<typename _ValueT>
 __ostream_type&
 _M_insert(_ValueT __v);

    private:

      void
      _M_write(const char_type* __s, streamsize __n)
      { std::__ostream_insert(*this, __s, __n); }

    };
# 485 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ostream" 3
  template <typename _CharT, typename _Traits>
    class basic_ostream<_CharT, _Traits>::sentry
    {

      bool _M_ok;
      basic_ostream<_CharT, _Traits>& _M_os;

    public:
# 504 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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
# 536 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ostream" 3
      explicit

      operator bool() const
      { return _M_ok; }
    };
# 558 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ostream" 3
  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c)
    {
      if (__out.width() != 0)
 return __ostream_insert(__out, &__c, 1);
      __out.put(__c);
      return __out;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __out, char __c)
    { return (__out << __out.widen(__c)); }


  template<typename _Traits>
    inline basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>& __out, char __c)
    {
      if (__out.width() != 0)
 return __ostream_insert(__out, &__c, 1);
      __out.put(__c);
      return __out;
    }


  template<typename _Traits>
    inline basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>& __out, signed char __c)
    { return (__out << static_cast<char>(__c)); }

  template<typename _Traits>
    inline basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>& __out, unsigned char __c)
    { return (__out << static_cast<char>(__c)); }





  template<typename _Traits>
    basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>&, wchar_t) = delete;


  template<typename _Traits>
    basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>&, char8_t) = delete;


  template<typename _Traits>
    basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>&, char16_t) = delete;

  template<typename _Traits>
    basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>&, char32_t) = delete;



  template<typename _Traits>
    basic_ostream<wchar_t, _Traits>&
    operator<<(basic_ostream<wchar_t, _Traits>&, char8_t) = delete;


  template<typename _Traits>
    basic_ostream<wchar_t, _Traits>&
    operator<<(basic_ostream<wchar_t, _Traits>&, char16_t) = delete;

  template<typename _Traits>
    basic_ostream<wchar_t, _Traits>&
    operator<<(basic_ostream<wchar_t, _Traits>&, char32_t) = delete;
# 649 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ostream" 3
  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s)
    {
      if (!__s)
 __out.setstate(ios_base::badbit);
      else
 __ostream_insert(__out, __s,
    static_cast<streamsize>(_Traits::length(__s)));
      return __out;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits> &
    operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s);


  template<typename _Traits>
    inline basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>& __out, const char* __s)
    {
      if (!__s)
 __out.setstate(ios_base::badbit);
      else
 __ostream_insert(__out, __s,
    static_cast<streamsize>(_Traits::length(__s)));
      return __out;
    }


  template<typename _Traits>
    inline basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>& __out, const signed char* __s)
    { return (__out << reinterpret_cast<const char*>(__s)); }

  template<typename _Traits>
    inline basic_ostream<char, _Traits> &
    operator<<(basic_ostream<char, _Traits>& __out, const unsigned char* __s)
    { return (__out << reinterpret_cast<const char*>(__s)); }





  template<typename _Traits>
    basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>&, const wchar_t*) = delete;


  template<typename _Traits>
    basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>&, const char8_t*) = delete;


  template<typename _Traits>
    basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>&, const char16_t*) = delete;

  template<typename _Traits>
    basic_ostream<char, _Traits>&
    operator<<(basic_ostream<char, _Traits>&, const char32_t*) = delete;



  template<typename _Traits>
    basic_ostream<wchar_t, _Traits>&
    operator<<(basic_ostream<wchar_t, _Traits>&, const char8_t*) = delete;


  template<typename _Traits>
    basic_ostream<wchar_t, _Traits>&
    operator<<(basic_ostream<wchar_t, _Traits>&, const char16_t*) = delete;

  template<typename _Traits>
    basic_ostream<wchar_t, _Traits>&
    operator<<(basic_ostream<wchar_t, _Traits>&, const char32_t*) = delete;
# 739 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ostream" 3
  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    endl(basic_ostream<_CharT, _Traits>& __os)
    { return flush(__os.put(__os.widen('\n'))); }
# 751 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ostream" 3
  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    ends(basic_ostream<_CharT, _Traits>& __os)
    { return __os.put(_CharT()); }






  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    flush(basic_ostream<_CharT, _Traits>& __os)
    { return __os.flush(); }
# 773 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ostream" 3
  template<typename _Tp>
    concept __derived_from_ios_base = is_class_v<_Tp>
      && (!is_same_v<_Tp, ios_base>)
      && requires (_Tp* __t, ios_base* __b) { __b = __t; };

  template<typename _Os, typename _Tp>
    requires __derived_from_ios_base<_Os>
      && requires (_Os& __os, const _Tp& __t) { __os << __t; }
    using __rvalue_stream_insertion_t = _Os&&;
# 805 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ostream" 3
  template<typename _Ostream, typename _Tp>
    inline __rvalue_stream_insertion_t<_Ostream, _Tp>
    operator<<(_Ostream&& __os, const _Tp& __x)
    {
      __os << __x;
      return std::move(__os);
    }


  template<typename _CharT, typename _Traits>
    class __syncbuf_base : public basic_streambuf<_CharT, _Traits>
    {
    public:
      static bool*
      _S_get(basic_streambuf<_CharT, _Traits>* __buf [[maybe_unused]]) noexcept
      {

 if (auto __p = dynamic_cast<__syncbuf_base*>(__buf))
   return &__p->_M_emit_on_sync;

 return nullptr;
      }

    protected:
      __syncbuf_base(basic_streambuf<_CharT, _Traits>* __w = nullptr)
      : _M_wrapped(__w)
      { }

      basic_streambuf<_CharT, _Traits>* _M_wrapped = nullptr;
      bool _M_emit_on_sync = false;
      bool _M_needs_sync = false;
    };

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    emit_on_flush(basic_ostream<_CharT, _Traits>& __os)
    {
      if (bool* __flag = __syncbuf_base<_CharT, _Traits>::_S_get(__os.rdbuf()))
 *__flag = true;
      return __os;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    noemit_on_flush(basic_ostream<_CharT, _Traits>& __os)
    {
      if (bool* __flag = __syncbuf_base<_CharT, _Traits>::_S_get(__os.rdbuf()))
 *__flag = false;
      return __os;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    flush_emit(basic_ostream<_CharT, _Traits>& __os)
    {
      struct _Restore
      {
 ~_Restore() { *_M_flag = _M_prev; }

 bool _M_prev = false;
 bool* _M_flag = &_M_prev;
      } __restore;

      if (bool* __flag = __syncbuf_base<_CharT, _Traits>::_S_get(__os.rdbuf()))
 {
   __restore._M_prev = *__flag;
   __restore._M_flag = __flag;
   *__flag = true;
 }

      __os.flush();
      return __os;
    }




  inline void
  vprint_nonunicode(ostream& __os, string_view __fmt, format_args __args)
  {
    ostream::sentry __cerb(__os);
    if (__cerb)
      {
 __format::_Str_sink<char> __buf;
 std::vformat_to(__buf.out(), __os.getloc(), __fmt, __args);
 auto __out = __buf.view();

 try
   {
     std::__ostream_write(__os, __out.data(), __out.size());
   }
 catch(const __cxxabiv1::__forced_unwind&)
   {
     __os._M_setstate(ios_base::badbit);
     throw;
   }
 catch(...)
   { __os._M_setstate(ios_base::badbit); }
      }
  }

  inline void
  vprint_unicode(ostream& __os, string_view __fmt, format_args __args)
  {



    std::vprint_nonunicode(__os, __fmt, __args);
# 978 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ostream" 3
  }

  template<typename... _Args>
    inline void
    print(ostream& __os, format_string<_Args...> __fmt, _Args&&... __args)
    {
      auto __fmtargs = std::make_format_args(__args...);
      if constexpr (__unicode::__literal_encoding_is_utf8())
 std::vprint_unicode(__os, __fmt.get(), __fmtargs);
      else
 std::vprint_nonunicode(__os, __fmt.get(), __fmtargs);
    }

  template<typename... _Args>
    inline void
    println(ostream& __os, format_string<_Args...> __fmt, _Args&&... __args)
    {
      std::print(__os, "{}\n",
   std::format(__fmt, std::forward<_Args>(__args)...));
    }


  inline void println(ostream& __os)
  {





      __os.put('\n');
  }






}

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ostream.tcc" 1 3
# 38 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ostream.tcc" 3



namespace std __attribute__ ((__visibility__ ("default")))
{


  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>::sentry::
    sentry(basic_ostream<_CharT, _Traits>& __os)
    : _M_ok(false), _M_os(__os)
    {

      if (__os.tie() && __os.good())
 __os.tie()->flush();

      if (__os.good())
 _M_ok = true;
      else if (__os.bad())
 __os.setstate(ios_base::failbit);
    }

  template<typename _CharT, typename _Traits>
    template<typename _ValueT>
      basic_ostream<_CharT, _Traits>&
      basic_ostream<_CharT, _Traits>::
      _M_insert(_ValueT __v)
      {
 sentry __cerb(*this);
 if (__cerb)
   {
     ios_base::iostate __err = ios_base::goodbit;
     try
       {

  const __num_put_type& __np = __check_facet(this->_M_num_put);




  if (__np.put(*this, *this, this->fill(), __v).failed())
    __err |= ios_base::badbit;
       }
     catch(__cxxabiv1::__forced_unwind&)
       {
  this->_M_setstate(ios_base::badbit);
  throw;
       }
     catch(...)
       { this->_M_setstate(ios_base::badbit); }
     if (__err)
       this->setstate(__err);
   }
 return *this;
      }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    operator<<(short __n)
    {


      const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
      if (__fmt == ios_base::oct || __fmt == ios_base::hex)
 return _M_insert(static_cast<long>(static_cast<unsigned short>(__n)));
      else
 return _M_insert(static_cast<long>(__n));
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    operator<<(int __n)
    {


      const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield;
      if (__fmt == ios_base::oct || __fmt == ios_base::hex)
 return _M_insert(static_cast<long>(static_cast<unsigned int>(__n)));
      else
 return _M_insert(static_cast<long>(__n));
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    operator<<(__streambuf_type* __sbin)
    {
      ios_base::iostate __err = ios_base::goodbit;
      sentry __cerb(*this);
      if (__cerb && __sbin)
 {
   try
     {
       if (!__copy_streambufs(__sbin, this->rdbuf()))
  __err |= ios_base::failbit;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::failbit); }
 }
      else if (!__sbin)
 __err |= ios_base::badbit;
      if (__err)
 this->setstate(__err);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    put(char_type __c)
    {






      sentry __cerb(*this);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {
       const int_type __put = this->rdbuf()->sputc(__c);
       if (traits_type::eq_int_type(__put, traits_type::eof()))
  __err |= ios_base::badbit;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    write(const _CharT* __s, streamsize __n)
    {







      sentry __cerb(*this);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {
       if (this->rdbuf()->sputn(__s, __n) != __n)
  __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(ios_base::badbit);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    flush()
    {





      if (__streambuf_type* __buf = this->rdbuf())
 {
   sentry __cerb(*this);
   if (__cerb)
     {
       ios_base::iostate __err = ios_base::goodbit;
       try
  {
    if (this->rdbuf()->pubsync() == -1)
      __err |= ios_base::badbit;
  }
       catch(__cxxabiv1::__forced_unwind&)
  {
    this->_M_setstate(ios_base::badbit);
    throw;
  }
       catch(...)
  { this->_M_setstate(ios_base::badbit); }
       if (__err)
  this->setstate(__err);
     }
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    typename basic_ostream<_CharT, _Traits>::pos_type
    basic_ostream<_CharT, _Traits>::
    tellp()
    {
      sentry __cerb(*this);
      pos_type __ret = pos_type(-1);
      if (!this->fail())
 __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out);
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    seekp(pos_type __pos)
    {
      sentry __cerb(*this);
      if (!this->fail())
 {


   const pos_type __p = this->rdbuf()->pubseekpos(__pos, ios_base::out);


   if (__p == pos_type(off_type(-1)))
     this->setstate(ios_base::failbit);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    basic_ostream<_CharT, _Traits>::
    seekp(off_type __off, ios_base::seekdir __dir)
    {
      sentry __cerb(*this);
      if (!this->fail())
 {


   const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
        ios_base::out);


   if (__p == pos_type(off_type(-1)))
     this->setstate(ios_base::failbit);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s)
    {
      if (!__s)
 __out.setstate(ios_base::badbit);
      else
 {


   const size_t __clen = char_traits<char>::length(__s);
   try
     {
       struct __ptr_guard
       {
  _CharT *__p;
  __ptr_guard (_CharT *__ip): __p(__ip) { }
  ~__ptr_guard() { delete[] __p; }
  _CharT* __get() { return __p; }
       } __pg (new _CharT[__clen]);

       _CharT *__ws = __pg.__get();
       for (size_t __i = 0; __i < __clen; ++__i)
  __ws[__i] = __out.widen(__s[__i]);
       __ostream_insert(__out, __ws, __clen);
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       __out._M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { __out._M_setstate(ios_base::badbit); }
 }
      return __out;
    }




  extern template class basic_ostream<char>;
  extern template ostream& endl(ostream&);
  extern template ostream& ends(ostream&);
  extern template ostream& flush(ostream&);
  extern template ostream& operator<<(ostream&, char);
  extern template ostream& operator<<(ostream&, unsigned char);
  extern template ostream& operator<<(ostream&, signed char);
  extern template ostream& operator<<(ostream&, const char*);
  extern template ostream& operator<<(ostream&, const unsigned char*);
  extern template ostream& operator<<(ostream&, const signed char*);

  extern template ostream& ostream::_M_insert(long);
  extern template ostream& ostream::_M_insert(unsigned long);
  extern template ostream& ostream::_M_insert(bool);

  extern template ostream& ostream::_M_insert(long long);
  extern template ostream& ostream::_M_insert(unsigned long long);

  extern template ostream& ostream::_M_insert(double);
  extern template ostream& ostream::_M_insert(long double);
  extern template ostream& ostream::_M_insert(const void*);


  extern template class basic_ostream<wchar_t>;
  extern template wostream& endl(wostream&);
  extern template wostream& ends(wostream&);
  extern template wostream& flush(wostream&);
  extern template wostream& operator<<(wostream&, wchar_t);
  extern template wostream& operator<<(wostream&, char);
  extern template wostream& operator<<(wostream&, const wchar_t*);
  extern template wostream& operator<<(wostream&, const char*);

  extern template wostream& wostream::_M_insert(long);
  extern template wostream& wostream::_M_insert(unsigned long);
  extern template wostream& wostream::_M_insert(bool);

  extern template wostream& wostream::_M_insert(long long);
  extern template wostream& wostream::_M_insert(unsigned long long);

  extern template wostream& wostream::_M_insert(double);
  extern template wostream& wostream::_M_insert(long double);
  extern template wostream& wostream::_M_insert(const void*);




}
# 1018 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ostream" 2 3
# 44 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unique_ptr.h" 2 3



namespace std __attribute__ ((__visibility__ ("default")))
{








#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
  template<typename> class auto_ptr;
#pragma GCC diagnostic pop







  template<typename _Tp>
    struct default_delete
    {

      constexpr default_delete() noexcept = default;






      template<typename _Up,
        typename = _Require<is_convertible<_Up*, _Tp*>>>
 constexpr
        default_delete(const default_delete<_Up>&) noexcept { }


      constexpr
      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;
      }
    };
# 105 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unique_ptr.h" 3
  template<typename _Tp>
    struct default_delete<_Tp[]>
    {
    public:

      constexpr default_delete() noexcept = default;
# 121 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unique_ptr.h" 3
      template<typename _Up,
        typename = _Require<is_convertible<_Up(*)[], _Tp(*)[]>>>
 constexpr
        default_delete(const default_delete<_Up[]>&) noexcept { }


      template<typename _Up>
 constexpr
 typename enable_if<is_convertible<_Up(*)[], _Tp(*)[]>::value>::type
 operator()(_Up* __ptr) const
 {
   static_assert(sizeof(_Tp)>0,
   "can't delete pointer to incomplete type");
   delete [] __ptr;
 }
    };




  template <typename _Tp, typename _Dp>
    class __uniq_ptr_impl
    {
      template <typename _Up, typename _Ep, typename = void>
 struct _Ptr
 {
   using type = _Up*;
 };

      template <typename _Up, typename _Ep>
 struct
 _Ptr<_Up, _Ep, __void_t<typename remove_reference<_Ep>::type::pointer>>
 {
   using type = typename remove_reference<_Ep>::type::pointer;
 };

    public:
      using _DeleterConstraint = enable_if<
        __and_<__not_<is_pointer<_Dp>>,
        is_default_constructible<_Dp>>::value>;

      using pointer = typename _Ptr<_Tp, _Dp>::type;

      static_assert( !is_rvalue_reference<_Dp>::value,
       "unique_ptr's deleter type must be a function object type"
       " or an lvalue reference type" );

      __uniq_ptr_impl() = default;
      constexpr
      __uniq_ptr_impl(pointer __p) : _M_t() { _M_ptr() = __p; }

      template<typename _Del>
 constexpr
 __uniq_ptr_impl(pointer __p, _Del&& __d)
 : _M_t(__p, std::forward<_Del>(__d)) { }

      constexpr
      __uniq_ptr_impl(__uniq_ptr_impl&& __u) noexcept
      : _M_t(std::move(__u._M_t))
      { __u._M_ptr() = nullptr; }

      constexpr
      __uniq_ptr_impl& operator=(__uniq_ptr_impl&& __u) noexcept
      {
 reset(__u.release());
 _M_deleter() = std::forward<_Dp>(__u._M_deleter());
 return *this;
      }

      constexpr
      pointer& _M_ptr() noexcept { return std::get<0>(_M_t); }
      constexpr
      pointer _M_ptr() const noexcept { return std::get<0>(_M_t); }
      constexpr
      _Dp& _M_deleter() noexcept { return std::get<1>(_M_t); }
      constexpr
      const _Dp& _M_deleter() const noexcept { return std::get<1>(_M_t); }

      constexpr
      void reset(pointer __p) noexcept
      {
 const pointer __old_p = _M_ptr();
 _M_ptr() = __p;
 if (__old_p)
   _M_deleter()(__old_p);
      }

      constexpr
      pointer release() noexcept
      {
 pointer __p = _M_ptr();
 _M_ptr() = nullptr;
 return __p;
      }

      constexpr
      void
      swap(__uniq_ptr_impl& __rhs) noexcept
      {
 using std::swap;
 swap(this->_M_ptr(), __rhs._M_ptr());
 swap(this->_M_deleter(), __rhs._M_deleter());
      }

    private:
      tuple<pointer, _Dp> _M_t;
    };


  template <typename _Tp, typename _Dp,
     bool = is_move_constructible<_Dp>::value,
     bool = is_move_assignable<_Dp>::value>
    struct __uniq_ptr_data : __uniq_ptr_impl<_Tp, _Dp>
    {
      using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl;
      __uniq_ptr_data(__uniq_ptr_data&&) = default;
      __uniq_ptr_data& operator=(__uniq_ptr_data&&) = default;
    };

  template <typename _Tp, typename _Dp>
    struct __uniq_ptr_data<_Tp, _Dp, true, false> : __uniq_ptr_impl<_Tp, _Dp>
    {
      using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl;
      __uniq_ptr_data(__uniq_ptr_data&&) = default;
      __uniq_ptr_data& operator=(__uniq_ptr_data&&) = delete;
    };

  template <typename _Tp, typename _Dp>
    struct __uniq_ptr_data<_Tp, _Dp, false, true> : __uniq_ptr_impl<_Tp, _Dp>
    {
      using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl;
      __uniq_ptr_data(__uniq_ptr_data&&) = delete;
      __uniq_ptr_data& operator=(__uniq_ptr_data&&) = default;
    };

  template <typename _Tp, typename _Dp>
    struct __uniq_ptr_data<_Tp, _Dp, false, false> : __uniq_ptr_impl<_Tp, _Dp>
    {
      using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl;
      __uniq_ptr_data(__uniq_ptr_data&&) = delete;
      __uniq_ptr_data& operator=(__uniq_ptr_data&&) = delete;
    };







  template <typename _Tp, typename _Dp = default_delete<_Tp>>
    class unique_ptr
    {
      template <typename _Up>
 using _DeleterConstraint =
   typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type;

      __uniq_ptr_data<_Tp, _Dp> _M_t;

    public:
      using pointer = typename __uniq_ptr_impl<_Tp, _Dp>::pointer;
      using element_type = _Tp;
      using deleter_type = _Dp;

    private:


      template<typename _Up, typename _Ep>
 using __safe_conversion_up = __and_<
   is_convertible<typename unique_ptr<_Up, _Ep>::pointer, pointer>,
   __not_<is_array<_Up>>
        >;

    public:



      template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>
 constexpr unique_ptr() noexcept
 : _M_t()
 { }







      template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>
 constexpr
 explicit
 unique_ptr(pointer __p) noexcept
 : _M_t(__p)
        { }
# 322 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unique_ptr.h" 3
      template<typename _Del = deleter_type,
        typename = _Require<is_copy_constructible<_Del>>>
 constexpr
 unique_ptr(pointer __p, const deleter_type& __d) noexcept
 : _M_t(__p, __d) { }
# 335 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unique_ptr.h" 3
      template<typename _Del = deleter_type,
        typename = _Require<is_move_constructible<_Del>>>
 constexpr
 unique_ptr(pointer __p,
     __enable_if_t<!is_lvalue_reference<_Del>::value,
     _Del&&> __d) noexcept
 : _M_t(__p, std::move(__d))
 { }

      template<typename _Del = deleter_type,
        typename _DelUnref = typename remove_reference<_Del>::type>
 constexpr
 unique_ptr(pointer,
     __enable_if_t<is_lvalue_reference<_Del>::value,
     _DelUnref&&>) = delete;


      template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>
 constexpr unique_ptr(nullptr_t) noexcept
 : _M_t()
 { }




      unique_ptr(unique_ptr&&) = default;







      template<typename _Up, typename _Ep, typename = _Require<
               __safe_conversion_up<_Up, _Ep>,
        __conditional_t<is_reference<_Dp>::value,
          is_same<_Ep, _Dp>,
          is_convertible<_Ep, _Dp>>>>
 constexpr
 unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
 : _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
 { }


#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"

      template<typename _Up, typename = _Require<
        is_convertible<_Up*, _Tp*>, is_same<_Dp, default_delete<_Tp>>>>
 unique_ptr(auto_ptr<_Up>&& __u) noexcept;
#pragma GCC diagnostic pop




      constexpr

      ~unique_ptr() noexcept
      {
 static_assert(__is_invocable<deleter_type&, pointer>::value,
        "unique_ptr's deleter must be invocable with a pointer");
 auto& __ptr = _M_t._M_ptr();
 if (__ptr != nullptr)
   get_deleter()(std::move(__ptr));
 __ptr = pointer();
      }







      unique_ptr& operator=(unique_ptr&&) = default;
# 417 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unique_ptr.h" 3
      template<typename _Up, typename _Ep>
 constexpr
        typename enable_if< __and_<
          __safe_conversion_up<_Up, _Ep>,
          is_assignable<deleter_type&, _Ep&&>
          >::value,
          unique_ptr&>::type
 operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
 {
   reset(__u.release());
   get_deleter() = std::forward<_Ep>(__u.get_deleter());
   return *this;
 }


      constexpr
      unique_ptr&
      operator=(nullptr_t) noexcept
      {
 reset();
 return *this;
      }




      constexpr
      typename add_lvalue_reference<element_type>::type
      operator*() const noexcept(noexcept(*std::declval<pointer>()))
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(get() != pointer()), false)) std::__glibcxx_assert_fail(); } while (false);
 return *get();
      }


      constexpr
      pointer
      operator->() const noexcept
      {
                                             ;
 return get();
      }


      constexpr
      pointer
      get() const noexcept
      { return _M_t._M_ptr(); }


      constexpr
      deleter_type&
      get_deleter() noexcept
      { return _M_t._M_deleter(); }


      constexpr
      const deleter_type&
      get_deleter() const noexcept
      { return _M_t._M_deleter(); }


      constexpr
      explicit operator bool() const noexcept
      { return get() == pointer() ? false : true; }




      constexpr
      pointer
      release() noexcept
      { return _M_t.release(); }







      constexpr
      void
      reset(pointer __p = pointer()) noexcept
      {
 static_assert(__is_invocable<deleter_type&, pointer>::value,
        "unique_ptr's deleter must be invocable with a pointer");
 _M_t.reset(std::move(__p));
      }


      constexpr
      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;

    private:

      template<typename, typename, typename...>
 friend class out_ptr_t;
      template<typename, typename, typename...>
 friend class inout_ptr_t;

  };
# 536 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unique_ptr.h" 3
  template<typename _Tp, typename _Dp>
    class unique_ptr<_Tp[], _Dp>
    {
      template <typename _Up>
      using _DeleterConstraint =
 typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type;

      __uniq_ptr_data<_Tp, _Dp> _M_t;


      template<typename _Up>
 using __is_derived_Tp
   = __and_< is_base_of<_Tp, _Up>,
      __not_<is_same<__remove_cv_t<_Tp>, __remove_cv_t<_Up>>> >;

    public:
      using pointer = typename __uniq_ptr_impl<_Tp, _Dp>::pointer;
      using element_type = _Tp;
      using deleter_type = _Dp;



      template<typename _Up, typename _Ep,
               typename _UPtr = unique_ptr<_Up, _Ep>,
        typename _UP_pointer = typename _UPtr::pointer,
        typename _UP_element_type = typename _UPtr::element_type>
 using __safe_conversion_up = __and_<
          is_array<_Up>,
          is_same<pointer, element_type*>,
          is_same<_UP_pointer, _UP_element_type*>,
          is_convertible<_UP_element_type(*)[], element_type(*)[]>
        >;


      template<typename _Up>
        using __safe_conversion_raw = __and_<
          __or_<__or_<is_same<_Up, pointer>,
                      is_same<_Up, nullptr_t>>,
                __and_<is_pointer<_Up>,
                       is_same<pointer, element_type*>,
                       is_convertible<
                         typename remove_pointer<_Up>::type(*)[],
                         element_type(*)[]>
                >
          >
        >;




      template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>
 constexpr unique_ptr() noexcept
 : _M_t()
 { }
# 598 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unique_ptr.h" 3
      template<typename _Up,
        typename _Vp = _Dp,
        typename = _DeleterConstraint<_Vp>,
        typename = typename enable_if<
                 __safe_conversion_raw<_Up>::value, bool>::type>
 constexpr
 explicit
 unique_ptr(_Up __p) noexcept
 : _M_t(__p)
        { }
# 617 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unique_ptr.h" 3
      template<typename _Up, typename _Del = deleter_type,
        typename = _Require<__safe_conversion_raw<_Up>,
       is_copy_constructible<_Del>>>
 constexpr
 unique_ptr(_Up __p, const deleter_type& __d) noexcept
 : _M_t(__p, __d) { }
# 632 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unique_ptr.h" 3
      template<typename _Up, typename _Del = deleter_type,
        typename = _Require<__safe_conversion_raw<_Up>,
       is_move_constructible<_Del>>>
 constexpr
 unique_ptr(_Up __p,
     __enable_if_t<!is_lvalue_reference<_Del>::value,
     _Del&&> __d) noexcept
 : _M_t(std::move(__p), std::move(__d))
 { }

      template<typename _Up, typename _Del = deleter_type,
        typename _DelUnref = typename remove_reference<_Del>::type,
        typename = _Require<__safe_conversion_raw<_Up>>>
 unique_ptr(_Up,
     __enable_if_t<is_lvalue_reference<_Del>::value,
     _DelUnref&&>) = delete;


      unique_ptr(unique_ptr&&) = default;


      template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>
 constexpr unique_ptr(nullptr_t) noexcept
 : _M_t()
        { }

      template<typename _Up, typename _Ep, typename = _Require<
        __safe_conversion_up<_Up, _Ep>,
        __conditional_t<is_reference<_Dp>::value,
          is_same<_Ep, _Dp>,
          is_convertible<_Ep, _Dp>>>>
 constexpr
 unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
 : _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
 { }



      constexpr

      ~unique_ptr()
      {
 auto& __ptr = _M_t._M_ptr();
 if (__ptr != nullptr)
   get_deleter()(__ptr);
 __ptr = pointer();
      }







      unique_ptr&
      operator=(unique_ptr&&) = default;
# 696 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unique_ptr.h" 3
      template<typename _Up, typename _Ep>
 constexpr
 typename
 enable_if<__and_<__safe_conversion_up<_Up, _Ep>,
                         is_assignable<deleter_type&, _Ep&&>
                  >::value,
                  unique_ptr&>::type
 operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
 {
   reset(__u.release());
   get_deleter() = std::forward<_Ep>(__u.get_deleter());
   return *this;
 }


      constexpr
      unique_ptr&
      operator=(nullptr_t) noexcept
      {
 reset();
 return *this;
      }




      constexpr
      typename std::add_lvalue_reference<element_type>::type
      operator[](size_t __i) const
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(get() != pointer()), false)) std::__glibcxx_assert_fail(); } while (false);
 return get()[__i];
      }


      constexpr
      pointer
      get() const noexcept
      { return _M_t._M_ptr(); }


      constexpr
      deleter_type&
      get_deleter() noexcept
      { return _M_t._M_deleter(); }


      constexpr
      const deleter_type&
      get_deleter() const noexcept
      { return _M_t._M_deleter(); }


      constexpr
      explicit operator bool() const noexcept
      { return get() == pointer() ? false : true; }




      constexpr
      pointer
      release() noexcept
      { return _M_t.release(); }







      template <typename _Up,
                typename = _Require<
                  __or_<is_same<_Up, pointer>,
                        __and_<is_same<pointer, element_type*>,
                               is_pointer<_Up>,
                               is_convertible<
                                 typename remove_pointer<_Up>::type(*)[],
                                 element_type(*)[]
                               >
                        >
                  >
               >>
      constexpr
      void
      reset(_Up __p) noexcept
      { _M_t.reset(std::move(__p)); }

      constexpr
      void reset(nullptr_t = nullptr) noexcept
      { reset(pointer()); }


      constexpr
      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;

    private:

      template<typename, typename, typename...> friend class out_ptr_t;
      template<typename, typename, typename...> friend class inout_ptr_t;

    };





  template<typename _Tp, typename _Dp>
    inline


    constexpr
    typename enable_if<__is_swappable<_Dp>::value>::type



    swap(unique_ptr<_Tp, _Dp>& __x,
  unique_ptr<_Tp, _Dp>& __y) noexcept
    { __x.swap(__y); }


  template<typename _Tp, typename _Dp>
    typename enable_if<!__is_swappable<_Dp>::value>::type
    swap(unique_ptr<_Tp, _Dp>&,
  unique_ptr<_Tp, _Dp>&) = delete;



  template<typename _Tp, typename _Dp,
    typename _Up, typename _Ep>
    [[__nodiscard__]] constexpr
    inline bool
    operator==(const unique_ptr<_Tp, _Dp>& __x,
        const unique_ptr<_Up, _Ep>& __y)
    { return __x.get() == __y.get(); }


  template<typename _Tp, typename _Dp>
    [[__nodiscard__]] constexpr
    inline bool
    operator==(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
    { return !__x; }
# 881 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unique_ptr.h" 3
  template<typename _Tp, typename _Dp,
    typename _Up, typename _Ep>
    [[__nodiscard__]] constexpr
    inline bool
    operator<(const unique_ptr<_Tp, _Dp>& __x,
       const unique_ptr<_Up, _Ep>& __y)
    {
      typedef typename
 std::common_type<typename unique_ptr<_Tp, _Dp>::pointer,
                  typename unique_ptr<_Up, _Ep>::pointer>::type _CT;
      return std::less<_CT>()(__x.get(), __y.get());
    }


  template<typename _Tp, typename _Dp>
    [[__nodiscard__]] constexpr
    inline bool
    operator<(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
    {
      return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(),
         nullptr);
    }


  template<typename _Tp, typename _Dp>
    [[__nodiscard__]] constexpr
    inline bool
    operator<(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
    {
      return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr,
         __x.get());
    }


  template<typename _Tp, typename _Dp,
    typename _Up, typename _Ep>
    [[__nodiscard__]] constexpr
    inline bool
    operator<=(const unique_ptr<_Tp, _Dp>& __x,
        const unique_ptr<_Up, _Ep>& __y)
    { return !(__y < __x); }


  template<typename _Tp, typename _Dp>
    [[__nodiscard__]] constexpr
    inline bool
    operator<=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
    { return !(nullptr < __x); }


  template<typename _Tp, typename _Dp>
    [[__nodiscard__]] constexpr
    inline bool
    operator<=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
    { return !(__x < nullptr); }


  template<typename _Tp, typename _Dp,
    typename _Up, typename _Ep>
    [[__nodiscard__]] constexpr
    inline bool
    operator>(const unique_ptr<_Tp, _Dp>& __x,
       const unique_ptr<_Up, _Ep>& __y)
    { return (__y < __x); }


  template<typename _Tp, typename _Dp>
    [[__nodiscard__]] constexpr
    inline bool
    operator>(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
    {
      return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr,
         __x.get());
    }


  template<typename _Tp, typename _Dp>
    [[__nodiscard__]] constexpr
    inline bool
    operator>(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
    {
      return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(),
         nullptr);
    }


  template<typename _Tp, typename _Dp,
    typename _Up, typename _Ep>
    [[__nodiscard__]] constexpr
    inline bool
    operator>=(const unique_ptr<_Tp, _Dp>& __x,
        const unique_ptr<_Up, _Ep>& __y)
    { return !(__x < __y); }


  template<typename _Tp, typename _Dp>
    [[__nodiscard__]] constexpr
    inline bool
    operator>=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
    { return !(__x < nullptr); }


  template<typename _Tp, typename _Dp>
    [[__nodiscard__]] inline bool
    operator>=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
    { return !(nullptr < __x); }


  template<typename _Tp, typename _Dp, typename _Up, typename _Ep>
    requires three_way_comparable_with<typename unique_ptr<_Tp, _Dp>::pointer,
           typename unique_ptr<_Up, _Ep>::pointer>
    constexpr
    inline
    compare_three_way_result_t<typename unique_ptr<_Tp, _Dp>::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<typename _Tp, typename _Dp>
    requires three_way_comparable<typename unique_ptr<_Tp, _Dp>::pointer>
    constexpr
    inline
    compare_three_way_result_t<typename unique_ptr<_Tp, _Dp>::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<pointer>(nullptr));
    }




  template<typename _Up, typename _Ptr = typename _Up::pointer,
    bool = __poison_hash<_Ptr>::__enable_hash_call>
    struct __uniq_ptr_hash

    : private __poison_hash<_Ptr>

    {
      size_t
      operator()(const _Up& __u) const
      noexcept(noexcept(std::declval<hash<_Ptr>>()(std::declval<_Ptr>())))
      { return hash<_Ptr>()(__u.get()); }
    };

  template<typename _Up, typename _Ptr>
    struct __uniq_ptr_hash<_Up, _Ptr, false>
    : private __poison_hash<_Ptr>
    { };



  template<typename _Tp, typename _Dp>
    struct hash<unique_ptr<_Tp, _Dp>>
    : public __hash_base<size_t, unique_ptr<_Tp, _Dp>>,
      public __uniq_ptr_hash<unique_ptr<_Tp, _Dp>>
    { };



namespace __detail
{
  template<typename _Tp>
    struct _MakeUniq
    { typedef unique_ptr<_Tp> __single_object; };

  template<typename _Tp>
    struct _MakeUniq<_Tp[]>
    { typedef unique_ptr<_Tp[]> __array; };

  template<typename _Tp, size_t _Bound>
    struct _MakeUniq<_Tp[_Bound]>
    { struct __invalid_type { }; };

  template<typename _Tp>
    using __unique_ptr_t = typename _MakeUniq<_Tp>::__single_object;
  template<typename _Tp>
    using __unique_ptr_array_t = typename _MakeUniq<_Tp>::__array;
  template<typename _Tp>
    using __invalid_make_unique_t = typename _MakeUniq<_Tp>::__invalid_type;
}
# 1072 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unique_ptr.h" 3
  template<typename _Tp, typename... _Args>
    constexpr
    inline __detail::__unique_ptr_t<_Tp>
    make_unique(_Args&&... __args)
    { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); }
# 1087 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unique_ptr.h" 3
  template<typename _Tp>
    constexpr
    inline __detail::__unique_ptr_array_t<_Tp>
    make_unique(size_t __num)
    { return unique_ptr<_Tp>(new remove_extent_t<_Tp>[__num]()); }






  template<typename _Tp, typename... _Args>
    __detail::__invalid_make_unique_t<_Tp>
    make_unique(_Args&&...) = delete;
# 1109 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unique_ptr.h" 3
  template<typename _Tp>
    constexpr
    inline __detail::__unique_ptr_t<_Tp>
    make_unique_for_overwrite()
    { return unique_ptr<_Tp>(new _Tp); }
# 1122 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unique_ptr.h" 3
  template<typename _Tp>
    constexpr
    inline __detail::__unique_ptr_array_t<_Tp>
    make_unique_for_overwrite(size_t __num)
    { return unique_ptr<_Tp>(new remove_extent_t<_Tp>[__num]); }






  template<typename _Tp, typename... _Args>
    __detail::__invalid_make_unique_t<_Tp>
    make_unique_for_overwrite(_Args&&...) = delete;
# 1146 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unique_ptr.h" 3
  template<typename _CharT, typename _Traits, typename _Tp, typename _Dp>
    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;
    }



  template<typename _Tp>
    static constexpr bool __is_unique_ptr = false;
  template<typename _Tp, typename _Del>
    static constexpr bool __is_unique_ptr<unique_ptr<_Tp, _Del>> = true;





  namespace __detail::__variant
  {
    template<typename> struct _Never_valueless_alt;



    template<typename _Tp, typename _Del>
      struct _Never_valueless_alt<std::unique_ptr<_Tp, _Del>>
      : std::true_type
      { };
  }



}
# 79 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/memory" 2 3

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/shared_ptr.h" 1 3
# 53 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/shared_ptr.h" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/shared_ptr_base.h" 1 3
# 62 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/shared_ptr_base.h" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ext/concurrence.h" 1 3
# 33 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ext/concurrence.h" 3







namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{







  enum _Lock_policy { _S_single, _S_mutex, _S_atomic };



  inline 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/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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();
      }

    }
  };



}
# 63 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/shared_ptr_base.h" 2 3







namespace std __attribute__ ((__visibility__ ("default")))
{



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
  template<typename> class auto_ptr;
#pragma GCC diagnostic pop






  class bad_weak_ptr : public std::exception
  {
  public:
    virtual char const* what() const noexcept;

    virtual ~bad_weak_ptr() noexcept;
  };


  inline void
  __throw_bad_weak_ptr()
  { (throw (bad_weak_ptr())); }

  using __gnu_cxx::_Lock_policy;
  using __gnu_cxx::__default_lock_policy;
  using __gnu_cxx::_S_single;
  using __gnu_cxx::_S_mutex;
  using __gnu_cxx::_S_atomic;


  template<_Lock_policy _Lp>
    class _Mutex_base
    {
    protected:

      enum { _S_need_barriers = 0 };
    };

  template<>
    class _Mutex_base<_S_mutex>
    : public __gnu_cxx::__mutex
    {
    protected:



      enum { _S_need_barriers = 1 };
    };

  template<_Lock_policy _Lp = __default_lock_policy>
    class _Sp_counted_base
    : public _Mutex_base<_Lp>
    {
    public:
      _Sp_counted_base() noexcept
      : _M_use_count(1), _M_weak_count(1) { }

      virtual
      ~_Sp_counted_base() noexcept
      { }



      virtual void
      _M_dispose() noexcept = 0;


      virtual void
      _M_destroy() noexcept
      { delete this; }

      virtual void*
      _M_get_deleter(const std::type_info&) noexcept = 0;


      void
      _M_add_ref_copy()
      { __gnu_cxx::__atomic_add_dispatch(&_M_use_count, 1); }


      void
      _M_add_ref_lock()
      {
 if (!_M_add_ref_lock_nothrow())
   __throw_bad_weak_ptr();
      }


      bool
      _M_add_ref_lock_nothrow() noexcept;


      void
      _M_release() noexcept;


      void
      _M_release_last_use() noexcept
      {
                                                      ;
 _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();
   }
      }


      __attribute__((__noinline__))
      void
      _M_release_last_use_cold() noexcept
      { _M_release_last_use(); }


      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 bool
    _Sp_counted_base<_S_single>::
    _M_add_ref_lock_nothrow() noexcept
    {
      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() noexcept
    {
      __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() noexcept
    {

      _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_mutex>::_M_release() noexcept
    {

                                                            ;
      if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1)
 {
   _M_release_last_use();
 }
    }

  template<>
    inline void
    _Sp_counted_base<_S_atomic>::_M_release() noexcept
    {
                                                            ;

      constexpr bool __lock_free
 = __atomic_always_lock_free(sizeof(long long), 0)
 && __atomic_always_lock_free(sizeof(_Atomic_word), 0);
      constexpr bool __double_word
 = sizeof(long long) == 2 * sizeof(_Atomic_word);


      constexpr bool __aligned = __alignof(long long) <= alignof(void*);
      if constexpr (__lock_free && __double_word && __aligned)
 {
   constexpr int __wordbits = 8 * sizeof(_Atomic_word);
   constexpr int __shiftbits = __double_word ? __wordbits : 0;
   constexpr long long __unique_ref = 1LL + (1LL << __shiftbits);
   auto __both_counts = reinterpret_cast<long long*>(&_M_use_count);

                                                          ;
   if (__atomic_load_n(__both_counts, 2) == __unique_ref)
     {




       _M_weak_count = _M_use_count = 0;
                                                            ;
                                                             ;
       _M_dispose();
       _M_destroy();
       return;
     }
   if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1)
     [[__unlikely__]]
     {
       _M_release_last_use_cold();
       return;
     }
 }
      else

      if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1)
 {
   _M_release_last_use();
 }
    }

  template<>
    inline void
    _Sp_counted_base<_S_single>::_M_weak_add_ref() noexcept
    { ++_M_weak_count; }

  template<>
    inline void
    _Sp_counted_base<_S_single>::_M_weak_release() noexcept
    {
      if (--_M_weak_count == 0)
        _M_destroy();
    }

  template<>
    inline long
    _Sp_counted_base<_S_single>::_M_get_use_count() const noexcept
    { return _M_use_count; }



  template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
    class __shared_ptr;

  template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
    class __weak_ptr;

  template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
    class __enable_shared_from_this;

  template<typename _Tp>
    class shared_ptr;

  template<typename _Tp>
    class weak_ptr;

  template<typename _Tp>
    struct owner_less;

  template<typename _Tp>
    class enable_shared_from_this;

  template<_Lock_policy _Lp = __default_lock_policy>
    class __weak_count;

  template<_Lock_policy _Lp = __default_lock_policy>
    class __shared_count;


  template<typename>
    class _Sp_atomic;



  template<typename _Ptr, _Lock_policy _Lp>
    class _Sp_counted_ptr final : public _Sp_counted_base<_Lp>
    {
    public:
      explicit
      _Sp_counted_ptr(_Ptr __p) noexcept
      : _M_ptr(__p) { }

      virtual void
      _M_dispose() noexcept
      { delete _M_ptr; }

      virtual void
      _M_destroy() noexcept
      { delete this; }

      virtual void*
      _M_get_deleter(const std::type_info&) noexcept
      { return nullptr; }

      _Sp_counted_ptr(const _Sp_counted_ptr&) = delete;
      _Sp_counted_ptr& operator=(const _Sp_counted_ptr&) = delete;

    private:
      _Ptr _M_ptr;
    };

  template<>
    inline void
    _Sp_counted_ptr<nullptr_t, _S_single>::_M_dispose() noexcept { }

  template<>
    inline void
    _Sp_counted_ptr<nullptr_t, _S_mutex>::_M_dispose() noexcept { }

  template<>
    inline void
    _Sp_counted_ptr<nullptr_t, _S_atomic>::_M_dispose() noexcept { }






  template<int _Nm, typename _Tp,
    bool __use_ebo = !__is_final(_Tp) && __is_empty(_Tp)>
    struct _Sp_ebo_helper;


  template<int _Nm, typename _Tp>
    struct _Sp_ebo_helper<_Nm, _Tp, true> : private _Tp
    {
      explicit _Sp_ebo_helper(const _Tp& __tp) : _Tp(__tp) { }
      explicit _Sp_ebo_helper(_Tp&& __tp) : _Tp(std::move(__tp)) { }

      static _Tp&
      _S_get(_Sp_ebo_helper& __eboh) { return static_cast<_Tp&>(__eboh); }
    };


  template<int _Nm, typename _Tp>
    struct _Sp_ebo_helper<_Nm, _Tp, false>
    {
      explicit _Sp_ebo_helper(const _Tp& __tp) : _M_tp(__tp) { }
      explicit _Sp_ebo_helper(_Tp&& __tp) : _M_tp(std::move(__tp)) { }

      static _Tp&
      _S_get(_Sp_ebo_helper& __eboh)
      { return __eboh._M_tp; }

    private:
      _Tp _M_tp;
    };


  template<typename _Ptr, typename _Deleter, typename _Alloc, _Lock_policy _Lp>
    class _Sp_counted_deleter final : public _Sp_counted_base<_Lp>
    {
      class _Impl : _Sp_ebo_helper<0, _Deleter>, _Sp_ebo_helper<1, _Alloc>
      {
 typedef _Sp_ebo_helper<0, _Deleter> _Del_base;
 typedef _Sp_ebo_helper<1, _Alloc> _Alloc_base;

      public:
 _Impl(_Ptr __p, _Deleter __d, const _Alloc& __a) noexcept
 : _Del_base(std::move(__d)), _Alloc_base(__a), _M_ptr(__p)
 { }

 _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 type_info& __ti [[__gnu__::__unused__]]) noexcept
      {



        return __ti == typeid(_Deleter)
   ? std::__addressof(_M_impl._M_del())
   : nullptr;



      }

    private:

      template<typename, typename, typename...> friend class out_ptr_t;

      _Impl _M_impl;
    };



  struct _Sp_make_shared_tag
  {
  private:
    template<typename _Tp, typename _Alloc, _Lock_policy _Lp>
      friend class _Sp_counted_ptr_inplace;

    static const type_info&
    _S_ti() noexcept __attribute__ ((__visibility__ ("default")))
    {
      alignas(type_info) static constexpr char __tag[sizeof(type_info)] = { };
      return reinterpret_cast<const type_info&>(__tag);
    }

    static bool _S_eq(const type_info&) noexcept;
  };

  template<typename _Alloc>
    struct _Sp_alloc_shared_tag
    {
      const _Alloc& _M_a;
    };

  template<typename _Tp, typename _Alloc, _Lock_policy _Lp>
    class _Sp_counted_ptr_inplace final : public _Sp_counted_base<_Lp>
    {
      class _Impl : _Sp_ebo_helper<0, _Alloc>
      {
 typedef _Sp_ebo_helper<0, _Alloc> _A_base;

      public:
 explicit _Impl(_Alloc __a) noexcept : _A_base(__a) { }

 _Alloc& _M_alloc() noexcept { return _A_base::_S_get(*this); }

 __gnu_cxx::__aligned_buffer<_Tp> _M_storage;
      };

    public:
      using __allocator_type = __alloc_rebind<_Alloc, _Sp_counted_ptr_inplace>;


      template<typename... _Args>
 _Sp_counted_ptr_inplace(_Alloc __a, _Args&&... __args)
 : _M_impl(__a)
 {


   allocator_traits<_Alloc>::construct(__a, _M_ptr(),
       std::forward<_Args>(__args)...);
 }

      ~_Sp_counted_ptr_inplace() noexcept { }

      virtual void
      _M_dispose() noexcept
      {
 allocator_traits<_Alloc>::destroy(_M_impl._M_alloc(), _M_ptr());
      }


      virtual void
      _M_destroy() noexcept
      {
 __allocator_type __a(_M_impl._M_alloc());
 __allocated_ptr<__allocator_type> __guard_ptr{ __a, this };
 this->~_Sp_counted_ptr_inplace();
      }

    private:
      friend class __shared_count<_Lp>;



      virtual void*
      _M_get_deleter(const std::type_info& __ti) noexcept override
      {
 auto __ptr = const_cast<typename remove_cv<_Tp>::type*>(_M_ptr());




 if (&__ti == &_Sp_make_shared_tag::_S_ti()
     ||

     __ti == typeid(_Sp_make_shared_tag)



    )
   return __ptr;
 return nullptr;
      }

      _Tp* _M_ptr() noexcept { return _M_impl._M_storage._M_ptr(); }

      _Impl _M_impl;
    };


  struct _Sp_overwrite_tag { };





  template<typename _Tp, typename _Alloc, _Lock_policy _Lp>
    requires is_same_v<typename _Alloc::value_type, _Sp_overwrite_tag>
    class _Sp_counted_ptr_inplace<_Tp, _Alloc, _Lp> final




    : public _Sp_counted_base<_Lp>
    {
      [[no_unique_address]] _Alloc _M_alloc;

      union {
 _Tp _M_obj;
 char _M_unused;
      };

      friend class __shared_count<_Lp>;

      _Tp* _M_ptr() noexcept { return std::__addressof(_M_obj); }

    public:
      using __allocator_type = __alloc_rebind<_Alloc, _Sp_counted_ptr_inplace>;

      _Sp_counted_ptr_inplace(const _Alloc& __a)
      : _M_alloc(__a)
      {
 ::new((void*)_M_ptr()) _Tp;
      }

      ~_Sp_counted_ptr_inplace() noexcept { }

      virtual void
      _M_dispose() noexcept
      {
 _M_obj.~_Tp();
      }


      virtual void
      _M_destroy() noexcept
      {
 using pointer = typename allocator_traits<__allocator_type>::pointer;
 __allocator_type __a(_M_alloc);
 auto __p = pointer_traits<pointer>::pointer_to(*this);
 __allocated_ptr<__allocator_type> __guard_ptr{ __a, __p };
 this->~_Sp_counted_ptr_inplace();
      }

      void*
      _M_get_deleter(const std::type_info&) noexcept override
      { return nullptr; }
    };



  struct _Sp_overwrite_tag;


  template<typename _Alloc>
    struct _Sp_counted_array_base
    {
      [[no_unique_address]] _Alloc _M_alloc{};
      size_t _M_n = 0;
      bool _M_overwrite = false;

      typename allocator_traits<_Alloc>::pointer
      _M_alloc_array(size_t __tail)
      {
 return allocator_traits<_Alloc>::allocate(_M_alloc, _M_n + __tail);
      }

      void
      _M_dealloc_array(typename allocator_traits<_Alloc>::pointer __p,
         size_t __tail)
      {
 allocator_traits<_Alloc>::deallocate(_M_alloc, __p, _M_n + __tail);
      }


      template<typename _Init>
 void
 _M_init(typename allocator_traits<_Alloc>::value_type* __p,
  _Init __init)
 {
   using _Tp = remove_pointer_t<_Init>;
   using _Up = typename allocator_traits<_Alloc>::value_type;

   if constexpr (is_same_v<_Init, _Sp_overwrite_tag>)
     {
       std::uninitialized_default_construct_n(__p, _M_n);
       _M_overwrite = true;
     }
   else if (__init == nullptr)
     std::__uninitialized_default_n_a(__p, _M_n, _M_alloc);
   else if constexpr (!is_array_v<_Tp>)
     std::__uninitialized_fill_n_a(__p, _M_n, *__init, _M_alloc);
   else
     {
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-local-typedefs"
       struct _Iter
       {
  using value_type = _Up;
  using difference_type = ptrdiff_t;
  using pointer = const _Up*;
  using reference = const _Up&;
  using iterator_category = forward_iterator_tag;

  const _Up* _M_p;
  size_t _M_len;
  size_t _M_pos;

  _Iter& operator++() { ++_M_pos; return *this; }
  _Iter operator++(int) { auto __i(*this); ++_M_pos; return __i; }

  reference operator*() const { return _M_p[_M_pos % _M_len]; }
  pointer operator->() const { return _M_p + (_M_pos % _M_len); }

  bool operator==(const _Iter& __i) const
  { return _M_pos == __i._M_pos; }
       };
#pragma GCC diagnostic pop

       _Iter __first{_S_first_elem(__init), sizeof(_Tp) / sizeof(_Up)};
       _Iter __last = __first;
       __last._M_pos = _M_n;
       std::__uninitialized_copy_a(__first, __last, __p, _M_alloc);
     }
 }

    protected:

      void
      _M_dispose_array(typename allocator_traits<_Alloc>::value_type* __p)
      {
 if (_M_overwrite)
   std::destroy_n(__p, _M_n);
 else
   {
     size_t __n = _M_n;
     while (__n--)
       allocator_traits<_Alloc>::destroy(_M_alloc, __p + __n);
   }
      }

    private:
      template<typename _Tp>
 static _Tp*
 _S_first_elem(_Tp* __p) { return __p; }

      template<typename _Tp, size_t _Nm>
 static auto
 _S_first_elem(_Tp (*__p)[_Nm]) { return _S_first_elem(*__p); }
    };



  template<typename _Alloc, _Lock_policy _Lp>
    class _Sp_counted_array final
    : public _Sp_counted_base<_Lp>, _Sp_counted_array_base<_Alloc>
    {
      using pointer = typename allocator_traits<_Alloc>::pointer;

      pointer _M_alloc_ptr;

      auto _M_ptr() const noexcept { return std::to_address(_M_alloc_ptr); }

      friend class __shared_count<_Lp>;

    public:
      _Sp_counted_array(const _Sp_counted_array_base<_Alloc>& __a,
   pointer __p) noexcept
      : _Sp_counted_array_base<_Alloc>(__a), _M_alloc_ptr(__p)
      { }

      ~_Sp_counted_array() = default;

      virtual void
      _M_dispose() noexcept
      {
 if (this->_M_n)
   this->_M_dispose_array(_M_ptr());
      }


      virtual void
      _M_destroy() noexcept
      {
 _Sp_counted_array_base<_Alloc> __a = *this;
 pointer __p = _M_alloc_ptr;
 this->~_Sp_counted_array();
 __a._M_dealloc_array(__p, _S_tail());
      }



      static constexpr size_t
      _S_tail()
      {

 using _Tp = typename allocator_traits<_Alloc>::value_type;


 size_t __bytes = sizeof(_Sp_counted_array);


 if constexpr (alignof(_Tp) < alignof(_Sp_counted_array))
   __bytes += alignof(_Sp_counted_array) - alignof(_Tp);

 return (__bytes + sizeof(_Tp) - 1) / sizeof(_Tp);
      }

      void*
      _M_get_deleter(const std::type_info&) noexcept override
      { return nullptr; }
    };



  struct __sp_array_delete
  {
    template<typename _Yp>
      void operator()(_Yp* __p) const { delete[] __p; }
  };

  template<_Lock_policy _Lp>
    class __shared_count
    {

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

      template<typename _Tp>
 struct __not_alloc_shared_tag<_Sp_alloc_shared_tag<_Tp>> { };


      template<typename _Alloc>
 struct __not_alloc_shared_tag<_Sp_counted_array_base<_Alloc>> { };


    public:
      constexpr __shared_count() noexcept : _M_pi(0)
      { }

      template<typename _Ptr>
        explicit
 __shared_count(_Ptr __p) : _M_pi(0)
 {
   try
     {
       _M_pi = new _Sp_counted_ptr<_Ptr, _Lp>(__p);
     }
   catch(...)
     {
       delete __p;
       throw;
     }
 }

      template<typename _Ptr>
 __shared_count(_Ptr __p, false_type)
 : __shared_count(__p)
 { }

      template<typename _Ptr>
 __shared_count(_Ptr __p, true_type)
 : __shared_count(__p, __sp_array_delete{}, allocator<void>())
 { }

      template<typename _Ptr, typename _Deleter,
        typename = typename __not_alloc_shared_tag<_Deleter>::type>
 __shared_count(_Ptr __p, _Deleter __d)
 : __shared_count(__p, std::move(__d), allocator<void>())
 { }

      template<typename _Ptr, typename _Deleter, typename _Alloc,
        typename = typename __not_alloc_shared_tag<_Deleter>::type>
 __shared_count(_Ptr __p, _Deleter __d, _Alloc __a) : _M_pi(0)
 {
   typedef _Sp_counted_deleter<_Ptr, _Deleter, _Alloc, _Lp> _Sp_cd_type;
   try
     {
       typename _Sp_cd_type::__allocator_type __a2(__a);
       auto __guard = std::__allocate_guarded(__a2);
       _Sp_cd_type* __mem = __guard.get();
       ::new (__mem) _Sp_cd_type(__p, std::move(__d), std::move(__a));
       _M_pi = __mem;
       __guard = nullptr;
     }
   catch(...)
     {
       __d(__p);
       throw;
     }
 }

      template<typename _Tp, typename _Alloc, typename... _Args>
 __shared_count(_Tp*& __p, _Sp_alloc_shared_tag<_Alloc> __a,
         _Args&&... __args)
 {
   typedef _Sp_counted_ptr_inplace<_Tp, _Alloc, _Lp> _Sp_cp_type;
   typename _Sp_cp_type::__allocator_type __a2(__a._M_a);
   auto __guard = std::__allocate_guarded(__a2);
   _Sp_cp_type* __mem = __guard.get();
   auto __pi = ::new (__mem)
     _Sp_cp_type(__a._M_a, std::forward<_Args>(__args)...);
   __guard = nullptr;
   _M_pi = __pi;
   __p = __pi->_M_ptr();
 }


      template<typename _Tp, typename _Alloc, typename _Init>
 __shared_count(_Tp*& __p, const _Sp_counted_array_base<_Alloc>& __a,
         _Init __init)
 {
   using _Up = remove_all_extents_t<_Tp>;
   static_assert(is_same_v<_Up, typename _Alloc::value_type>);

   using _Sp_ca_type = _Sp_counted_array<_Alloc, _Lp>;
   const size_t __tail = _Sp_ca_type::_S_tail();

   struct _Guarded_ptr : _Sp_counted_array_base<_Alloc>
   {
     typename allocator_traits<_Alloc>::pointer _M_ptr;

     _Guarded_ptr(_Sp_counted_array_base<_Alloc> __a)
     : _Sp_counted_array_base<_Alloc>(__a),
       _M_ptr(this->_M_alloc_array(_Sp_ca_type::_S_tail()))
     { }

     ~_Guarded_ptr()
     {
       if (_M_ptr)
  this->_M_dealloc_array(_M_ptr, _Sp_ca_type::_S_tail());
     }
   };

   _Guarded_ptr __guard{__a};
   _Up* const __raw = std::to_address(__guard._M_ptr);
   __guard._M_init(__raw, __init);

   void* __c = __raw + __a._M_n;
   if constexpr (alignof(_Up) < alignof(_Sp_ca_type))
     {
       size_t __space = sizeof(_Up) * __tail;
       __c = std::align(alignof(_Sp_ca_type), sizeof(_Sp_ca_type),
          __c, __space);
     }
   auto __pi = ::new(__c) _Sp_ca_type(__guard, __guard._M_ptr);
   __guard._M_ptr = nullptr;
   _M_pi = __pi;
   __p = reinterpret_cast<_Tp*>(__raw);
 }



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"

      template<typename _Tp>
        explicit
 __shared_count(std::auto_ptr<_Tp>&& __r);
#pragma GCC diagnostic pop



      template<typename _Tp, typename _Del>
        explicit
 __shared_count(std::unique_ptr<_Tp, _Del>&& __r) : _M_pi(0)
 {


   if (__r.get() == nullptr)
     return;

   using _Ptr = typename unique_ptr<_Tp, _Del>::pointer;
   using _Del2 = __conditional_t<is_reference<_Del>::value,
       reference_wrapper<typename remove_reference<_Del>::type>,
       _Del>;
   using _Sp_cd_type
     = _Sp_counted_deleter<_Ptr, _Del2, allocator<void>, _Lp>;
   using _Alloc = allocator<_Sp_cd_type>;
   using _Alloc_traits = allocator_traits<_Alloc>;
   _Alloc __a;
   _Sp_cd_type* __mem = _Alloc_traits::allocate(__a, 1);



   _Alloc_traits::construct(__a, __mem, __r.release(),
       std::forward<_Del>(__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) noexcept;

      ~__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 != nullptr)
   _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 != nullptr)
       __tmp->_M_add_ref_copy();
     if (_M_pi != nullptr)
       _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 ? _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>;

      template<typename> friend class _Sp_atomic;


      template<typename, typename, typename...> friend class out_ptr_t;


      _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>;

      template<typename> friend class _Sp_atomic;


      _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_nothrow())
 __throw_bad_weak_ptr();
    }


  template<_Lock_policy _Lp>
    inline
    __shared_count<_Lp>::
    __shared_count(const __weak_count<_Lp>& __r, std::nothrow_t) noexcept
    : _M_pi(__r._M_pi)
    {
      if (_M_pi && !_M_pi->_M_add_ref_lock_nothrow())
 _M_pi = nullptr;
    }





  template<typename _Yp_ptr, typename _Tp_ptr>
    struct __sp_compatible_with
    : false_type
    { };

  template<typename _Yp, typename _Tp>
    struct __sp_compatible_with<_Yp*, _Tp*>
    : is_convertible<_Yp*, _Tp*>::type
    { };

  template<typename _Up, size_t _Nm>
    struct __sp_compatible_with<_Up(*)[_Nm], _Up(*)[]>
    : true_type
    { };

  template<typename _Up, size_t _Nm>
    struct __sp_compatible_with<_Up(*)[_Nm], const _Up(*)[]>
    : true_type
    { };

  template<typename _Up, size_t _Nm>
    struct __sp_compatible_with<_Up(*)[_Nm], volatile _Up(*)[]>
    : true_type
    { };

  template<typename _Up, size_t _Nm>
    struct __sp_compatible_with<_Up(*)[_Nm], const volatile _Up(*)[]>
    : true_type
    { };


  template<typename _Up, size_t _Nm, typename _Yp, typename = void>
    struct __sp_is_constructible_arrN
    : false_type
    { };

  template<typename _Up, size_t _Nm, typename _Yp>
    struct __sp_is_constructible_arrN<_Up, _Nm, _Yp, __void_t<_Yp[_Nm]>>
    : is_convertible<_Yp(*)[_Nm], _Up(*)[_Nm]>::type
    { };


  template<typename _Up, typename _Yp, typename = void>
    struct __sp_is_constructible_arr
    : false_type
    { };

  template<typename _Up, typename _Yp>
    struct __sp_is_constructible_arr<_Up, _Yp, __void_t<_Yp[]>>
    : is_convertible<_Yp(*)[], _Up(*)[]>::type
    { };


  template<typename _Tp, typename _Yp>
    struct __sp_is_constructible;


  template<typename _Up, size_t _Nm, typename _Yp>
    struct __sp_is_constructible<_Up[_Nm], _Yp>
    : __sp_is_constructible_arrN<_Up, _Nm, _Yp>::type
    { };


  template<typename _Up, typename _Yp>
    struct __sp_is_constructible<_Up[], _Yp>
    : __sp_is_constructible_arr<_Up, _Yp>::type
    { };


  template<typename _Tp, typename _Yp>
    struct __sp_is_constructible
    : is_convertible<_Yp*, _Tp*>::type
    { };



  template<typename _Tp, _Lock_policy _Lp,
    bool = is_array<_Tp>::value, bool = is_void<_Tp>::value>
    class __shared_ptr_access
    {
    public:
      using element_type = _Tp;

      element_type&
      operator*() const noexcept
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(_M_get() != nullptr), false)) std::__glibcxx_assert_fail(); } while (false);
 return *_M_get();
      }

      element_type*
      operator->() const noexcept
      {
                                              ;
 return _M_get();
      }

    private:
      element_type*
      _M_get() const noexcept
      { return static_cast<const __shared_ptr<_Tp, _Lp>*>(this)->get(); }
    };


  template<typename _Tp, _Lock_policy _Lp>
    class __shared_ptr_access<_Tp, _Lp, false, true>
    {
    public:
      using element_type = _Tp;

      element_type*
      operator->() const noexcept
      {
 auto __ptr = static_cast<const __shared_ptr<_Tp, _Lp>*>(this)->get();
                                           ;
 return __ptr;
      }
    };


  template<typename _Tp, _Lock_policy _Lp>
    class __shared_ptr_access<_Tp, _Lp, true, false>
    {
    public:
      using element_type = typename remove_extent<_Tp>::type;
# 1408 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/shared_ptr_base.h" 3
      element_type&
      operator[](ptrdiff_t __i) const noexcept
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(_M_get() != nullptr), false)) std::__glibcxx_assert_fail(); } while (false);
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(!extent<_Tp>::value || __i < extent<_Tp>::value), false)) std::__glibcxx_assert_fail(); } while (false);
 return _M_get()[__i];
      }

    private:
      element_type*
      _M_get() const noexcept
      { return static_cast<const __shared_ptr<_Tp, _Lp>*>(this)->get(); }
    };

  template<typename _Tp, _Lock_policy _Lp>
    class __shared_ptr
    : public __shared_ptr_access<_Tp, _Lp>
    {
    public:
      using element_type = typename remove_extent<_Tp>::type;

    private:

      template<typename _Yp>
 using _SafeConv
   = typename enable_if<__sp_is_constructible<_Tp, _Yp>::value>::type;


      template<typename _Yp, typename _Res = void>
 using _Compatible = typename
   enable_if<__sp_compatible_with<_Yp*, _Tp*>::value, _Res>::type;


      template<typename _Yp>
 using _Assignable = _Compatible<_Yp, __shared_ptr&>;


      template<typename _Yp, typename _Del, typename _Res = void,
        typename _Ptr = typename unique_ptr<_Yp, _Del>::pointer>
 using _UniqCompatible = __enable_if_t<__and_<
   __sp_compatible_with<_Yp*, _Tp*>,
   is_convertible<_Ptr, element_type*>,
   is_move_constructible<_Del>
   >::value, _Res>;


      template<typename _Yp, typename _Del>
 using _UniqAssignable = _UniqCompatible<_Yp, _Del, __shared_ptr&>;

    public:


      using weak_type = __weak_ptr<_Tp, _Lp>;


      constexpr __shared_ptr() noexcept
      : _M_ptr(0), _M_refcount()
      { }

      template<typename _Yp, typename = _SafeConv<_Yp>>
 explicit
 __shared_ptr(_Yp* __p)
 : _M_ptr(__p), _M_refcount(__p, typename is_array<_Tp>::type())
 {
   static_assert( !is_void<_Yp>::value, "incomplete type" );
   static_assert( sizeof(_Yp) > 0, "incomplete type" );
   _M_enable_shared_from_this_with(__p);
 }

      template<typename _Yp, typename _Deleter, typename = _SafeConv<_Yp>>
 __shared_ptr(_Yp* __p, _Deleter __d)
 : _M_ptr(__p), _M_refcount(__p, std::move(__d))
 {
   static_assert(__is_invocable<_Deleter&, _Yp*&>::value,
       "deleter expression d(p) is well-formed");
   _M_enable_shared_from_this_with(__p);
 }

      template<typename _Yp, typename _Deleter, typename _Alloc,
        typename = _SafeConv<_Yp>>
 __shared_ptr(_Yp* __p, _Deleter __d, _Alloc __a)
 : _M_ptr(__p), _M_refcount(__p, std::move(__d), std::move(__a))
 {
   static_assert(__is_invocable<_Deleter&, _Yp*&>::value,
       "deleter expression d(p) is well-formed");
   _M_enable_shared_from_this_with(__p);
 }

      template<typename _Deleter>
 __shared_ptr(nullptr_t __p, _Deleter __d)
 : _M_ptr(0), _M_refcount(__p, std::move(__d))
 { }

      template<typename _Deleter, typename _Alloc>
        __shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a)
 : _M_ptr(0), _M_refcount(__p, std::move(__d), std::move(__a))
 { }


      template<typename _Yp>
 __shared_ptr(const __shared_ptr<_Yp, _Lp>& __r,
       element_type* __p) noexcept
 : _M_ptr(__p), _M_refcount(__r._M_refcount)
 { }


      template<typename _Yp>
 __shared_ptr(__shared_ptr<_Yp, _Lp>&& __r,
       element_type* __p) noexcept
 : _M_ptr(__p), _M_refcount()
 {
   _M_refcount._M_swap(__r._M_refcount);
   __r._M_ptr = nullptr;
 }

      __shared_ptr(const __shared_ptr&) noexcept = default;
      __shared_ptr& operator=(const __shared_ptr&) noexcept = default;
      ~__shared_ptr() = default;

      template<typename _Yp, typename = _Compatible<_Yp>>
 __shared_ptr(const __shared_ptr<_Yp, _Lp>& __r) noexcept
 : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount)
 { }

      __shared_ptr(__shared_ptr&& __r) noexcept
      : _M_ptr(__r._M_ptr), _M_refcount()
      {
 _M_refcount._M_swap(__r._M_refcount);
 __r._M_ptr = nullptr;
      }

      template<typename _Yp, typename = _Compatible<_Yp>>
 __shared_ptr(__shared_ptr<_Yp, _Lp>&& __r) noexcept
 : _M_ptr(__r._M_ptr), _M_refcount()
 {
   _M_refcount._M_swap(__r._M_refcount);
   __r._M_ptr = nullptr;
 }

      template<typename _Yp, typename = _Compatible<_Yp>>
 explicit __shared_ptr(const __weak_ptr<_Yp, _Lp>& __r)
 : _M_refcount(__r._M_refcount)
 {


   _M_ptr = __r._M_ptr;
 }


      template<typename _Yp, typename _Del,
        typename = _UniqCompatible<_Yp, _Del>>
 __shared_ptr(unique_ptr<_Yp, _Del>&& __r)
 : _M_ptr(__r.get()), _M_refcount()
 {
   auto __raw = __to_address(__r.get());
   _M_refcount = __shared_count<_Lp>(std::move(__r));
   _M_enable_shared_from_this_with(__raw);
 }
# 1586 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/shared_ptr_base.h" 3
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"

      template<typename _Yp, typename = _Compatible<_Yp>>
 __shared_ptr(auto_ptr<_Yp>&& __r);
#pragma GCC diagnostic pop


      constexpr __shared_ptr(nullptr_t) noexcept : __shared_ptr() { }

      template<typename _Yp>
 _Assignable<_Yp>
 operator=(const __shared_ptr<_Yp, _Lp>& __r) noexcept
 {
   _M_ptr = __r._M_ptr;
   _M_refcount = __r._M_refcount;
   return *this;
 }


#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
      template<typename _Yp>
 _Assignable<_Yp>
 operator=(auto_ptr<_Yp>&& __r)
 {
   __shared_ptr(std::move(__r)).swap(*this);
   return *this;
 }
#pragma GCC diagnostic pop


      __shared_ptr&
      operator=(__shared_ptr&& __r) noexcept
      {
 __shared_ptr(std::move(__r)).swap(*this);
 return *this;
      }

      template<class _Yp>
 _Assignable<_Yp>
 operator=(__shared_ptr<_Yp, _Lp>&& __r) noexcept
 {
   __shared_ptr(std::move(__r)).swap(*this);
   return *this;
 }

      template<typename _Yp, typename _Del>
 _UniqAssignable<_Yp, _Del>
 operator=(unique_ptr<_Yp, _Del>&& __r)
 {
   __shared_ptr(std::move(__r)).swap(*this);
   return *this;
 }

      void
      reset() noexcept
      { __shared_ptr().swap(*this); }

      template<typename _Yp>
 _SafeConv<_Yp>
 reset(_Yp* __p)
 {

   do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__p == nullptr || __p != _M_ptr), false)) std::__glibcxx_assert_fail(); } while (false);
   __shared_ptr(__p).swap(*this);
 }

      template<typename _Yp, typename _Deleter>
 _SafeConv<_Yp>
 reset(_Yp* __p, _Deleter __d)
 { __shared_ptr(__p, std::move(__d)).swap(*this); }

      template<typename _Yp, typename _Deleter, typename _Alloc>
 _SafeConv<_Yp>
 reset(_Yp* __p, _Deleter __d, _Alloc __a)
        { __shared_ptr(__p, std::move(__d), std::move(__a)).swap(*this); }


      element_type*
      get() const noexcept
      { return _M_ptr; }


      explicit operator bool() const noexcept
      { return _M_ptr != nullptr; }


      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);
      }
# 1698 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/shared_ptr_base.h" 3
      template<typename _Tp1>
 bool
 owner_before(__shared_ptr<_Tp1, _Lp> const& __rhs) const noexcept
 { return _M_refcount._M_less(__rhs._M_refcount); }

      template<typename _Tp1>
 bool
 owner_before(__weak_ptr<_Tp1, _Lp> const& __rhs) const noexcept
 { return _M_refcount._M_less(__rhs._M_refcount); }


    protected:

      template<typename _Alloc, typename... _Args>
 __shared_ptr(_Sp_alloc_shared_tag<_Alloc> __tag, _Args&&... __args)
 : _M_ptr(), _M_refcount(_M_ptr, __tag, std::forward<_Args>(__args)...)
 { _M_enable_shared_from_this_with(_M_ptr); }

      template<typename _Tp1, _Lock_policy _Lp1, typename _Alloc,
        typename... _Args>
 friend __shared_ptr<_Tp1, _Lp1>
 __allocate_shared(const _Alloc& __a, _Args&&... __args);



      template<typename _Alloc, typename _Init = const remove_extent_t<_Tp>*>
 __shared_ptr(const _Sp_counted_array_base<_Alloc>& __a,
       _Init __init = nullptr)
 : _M_ptr(), _M_refcount(_M_ptr, __a, __init)
 { }




      __shared_ptr(const __weak_ptr<_Tp, _Lp>& __r, std::nothrow_t) noexcept
      : _M_refcount(__r._M_refcount, std::nothrow)
      {
 _M_ptr = _M_refcount._M_get_use_count() ? __r._M_ptr : nullptr;
      }

      friend class __weak_ptr<_Tp, _Lp>;

    private:

      template<typename _Yp>
 using __esft_base_t = decltype(__enable_shared_from_this_base(
       std::declval<const __shared_count<_Lp>&>(),
       std::declval<_Yp*>()));


      template<typename _Yp, typename = void>
 struct __has_esft_base
 : false_type { };

      template<typename _Yp>
 struct __has_esft_base<_Yp, __void_t<__esft_base_t<_Yp>>>
 : __not_<is_array<_Tp>> { };

      template<typename _Yp, typename _Yp2 = typename remove_cv<_Yp>::type>
 typename enable_if<__has_esft_base<_Yp2>::value>::type
 _M_enable_shared_from_this_with(_Yp* __p) noexcept
 {
   if (auto __base = __enable_shared_from_this_base(_M_refcount, __p))
     __base->_M_weak_assign(const_cast<_Yp2*>(__p), _M_refcount);
 }

      template<typename _Yp, typename _Yp2 = typename remove_cv<_Yp>::type>
 typename enable_if<!__has_esft_base<_Yp2>::value>::type
 _M_enable_shared_from_this_with(_Yp*) noexcept
 { }

      void*
      _M_get_deleter(const std::type_info& __ti) const noexcept
      { return _M_refcount._M_get_deleter(__ti); }

      template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr;
      template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr;

      template<typename _Del, typename _Tp1, _Lock_policy _Lp1>
 friend _Del* get_deleter(const __shared_ptr<_Tp1, _Lp1>&) noexcept;

      template<typename _Del, typename _Tp1>
 friend _Del* get_deleter(const shared_ptr<_Tp1>&) noexcept;


      friend _Sp_atomic<shared_ptr<_Tp>>;


      template<typename, typename, typename...> friend class out_ptr_t;


      element_type* _M_ptr;
      __shared_count<_Lp> _M_refcount;
    };



  template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
    inline bool
    operator==(const __shared_ptr<_Tp1, _Lp>& __a,
        const __shared_ptr<_Tp2, _Lp>& __b) noexcept
    { return __a.get() == __b.get(); }

  template<typename _Tp, _Lock_policy _Lp>
    inline bool
    operator==(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
    { return !__a; }


  template<typename _Tp, typename _Up, _Lock_policy _Lp>
    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<typename _Tp, _Lock_policy _Lp>
    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<pointer>(nullptr));
    }
# 1919 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/shared_ptr_base.h" 3
  template<typename _Tp, _Lock_policy _Lp>
    inline void
    swap(__shared_ptr<_Tp, _Lp>& __a, __shared_ptr<_Tp, _Lp>& __b) noexcept
    { __a.swap(__b); }
# 1931 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/shared_ptr_base.h" 3
  template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
    inline __shared_ptr<_Tp, _Lp>
    static_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
    {
      using _Sp = __shared_ptr<_Tp, _Lp>;
      return _Sp(__r, static_cast<typename _Sp::element_type*>(__r.get()));
    }






  template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
    inline __shared_ptr<_Tp, _Lp>
    const_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
    {
      using _Sp = __shared_ptr<_Tp, _Lp>;
      return _Sp(__r, const_cast<typename _Sp::element_type*>(__r.get()));
    }






  template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
    inline __shared_ptr<_Tp, _Lp>
    dynamic_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
    {
      using _Sp = __shared_ptr<_Tp, _Lp>;
      if (auto* __p = dynamic_cast<typename _Sp::element_type*>(__r.get()))
 return _Sp(__r, __p);
      return _Sp();
    }


  template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
    inline __shared_ptr<_Tp, _Lp>
    reinterpret_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
    {
      using _Sp = __shared_ptr<_Tp, _Lp>;
      return _Sp(__r, reinterpret_cast<typename _Sp::element_type*>(__r.get()));
    }


  template<typename _Tp, _Lock_policy _Lp>
    class __weak_ptr
    {
      template<typename _Yp, typename _Res = void>
 using _Compatible = typename
   enable_if<__sp_compatible_with<_Yp*, _Tp*>::value, _Res>::type;


      template<typename _Yp>
 using _Assignable = _Compatible<_Yp, __weak_ptr&>;

    public:
      using element_type = typename remove_extent<_Tp>::type;

      constexpr __weak_ptr() noexcept
      : _M_ptr(nullptr), _M_refcount()
      { }

      __weak_ptr(const __weak_ptr&) noexcept = default;

      ~__weak_ptr() = default;
# 2013 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/shared_ptr_base.h" 3
      template<typename _Yp, typename = _Compatible<_Yp>>
 __weak_ptr(const __weak_ptr<_Yp, _Lp>& __r) noexcept
 : _M_refcount(__r._M_refcount)
        { _M_ptr = __r.lock().get(); }

      template<typename _Yp, typename = _Compatible<_Yp>>
 __weak_ptr(const __shared_ptr<_Yp, _Lp>& __r) noexcept
 : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount)
 { }

      __weak_ptr(__weak_ptr&& __r) noexcept
      : _M_ptr(__r._M_ptr), _M_refcount(std::move(__r._M_refcount))
      { __r._M_ptr = nullptr; }

      template<typename _Yp, typename = _Compatible<_Yp>>
 __weak_ptr(__weak_ptr<_Yp, _Lp>&& __r) noexcept
 : _M_ptr(__r.lock().get()), _M_refcount(std::move(__r._M_refcount))
        { __r._M_ptr = nullptr; }

      __weak_ptr&
      operator=(const __weak_ptr& __r) noexcept = default;

      template<typename _Yp>
 _Assignable<_Yp>
 operator=(const __weak_ptr<_Yp, _Lp>& __r) noexcept
 {
   _M_ptr = __r.lock().get();
   _M_refcount = __r._M_refcount;
   return *this;
 }

      template<typename _Yp>
 _Assignable<_Yp>
 operator=(const __shared_ptr<_Yp, _Lp>& __r) noexcept
 {
   _M_ptr = __r._M_ptr;
   _M_refcount = __r._M_refcount;
   return *this;
 }

      __weak_ptr&
      operator=(__weak_ptr&& __r) noexcept
      {
 __weak_ptr(std::move(__r)).swap(*this);
 return *this;
      }

      template<typename _Yp>
 _Assignable<_Yp>
 operator=(__weak_ptr<_Yp, _Lp>&& __r) noexcept
 {
   _M_ptr = __r.lock().get();
   _M_refcount = std::move(__r._M_refcount);
   __r._M_ptr = nullptr;
   return *this;
 }

      __shared_ptr<_Tp, _Lp>
      lock() const noexcept
      { return __shared_ptr<element_type, _Lp>(*this, std::nothrow); }

      long
      use_count() const noexcept
      { return _M_refcount._M_get_use_count(); }

      bool
      expired() const noexcept
      { return _M_refcount._M_get_use_count() == 0; }

      template<typename _Tp1>
 bool
 owner_before(const __shared_ptr<_Tp1, _Lp>& __rhs) const noexcept
 { return _M_refcount._M_less(__rhs._M_refcount); }

      template<typename _Tp1>
 bool
 owner_before(const __weak_ptr<_Tp1, _Lp>& __rhs) const noexcept
 { return _M_refcount._M_less(__rhs._M_refcount); }

      void
      reset() noexcept
      { __weak_ptr().swap(*this); }

      void
      swap(__weak_ptr& __s) noexcept
      {
 std::swap(_M_ptr, __s._M_ptr);
 _M_refcount._M_swap(__s._M_refcount);
      }

    private:

      void
      _M_assign(_Tp* __ptr, const __shared_count<_Lp>& __refcount) noexcept
      {
 if (use_count() == 0)
   {
     _M_ptr = __ptr;
     _M_refcount = __refcount;
   }
      }

      template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr;
      template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr;
      friend class __enable_shared_from_this<_Tp, _Lp>;
      friend class enable_shared_from_this<_Tp>;

      friend _Sp_atomic<weak_ptr<_Tp>>;


      element_type* _M_ptr;
      __weak_count<_Lp> _M_refcount;
    };


  template<typename _Tp, _Lock_policy _Lp>
    inline void
    swap(__weak_ptr<_Tp, _Lp>& __a, __weak_ptr<_Tp, _Lp>& __b) noexcept
    { __a.swap(__b); }

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
  template<typename _Tp, typename _Tp1>
    struct _Sp_owner_less : public binary_function<_Tp, _Tp, bool>
    {
      bool
      operator()(const _Tp& __lhs, const _Tp& __rhs) const noexcept
      { return __lhs.owner_before(__rhs); }

      bool
      operator()(const _Tp& __lhs, const _Tp1& __rhs) const noexcept
      { return __lhs.owner_before(__rhs); }

      bool
      operator()(const _Tp1& __lhs, const _Tp& __rhs) const noexcept
      { return __lhs.owner_before(__rhs); }
    };
#pragma GCC diagnostic pop

  template<>
    struct _Sp_owner_less<void, void>
    {
      template<typename _Tp, typename _Up>
 auto
 operator()(const _Tp& __lhs, const _Up& __rhs) const noexcept
 -> decltype(__lhs.owner_before(__rhs))
 { return __lhs.owner_before(__rhs); }

      using is_transparent = void;
    };

  template<typename _Tp, _Lock_policy _Lp>
    struct owner_less<__shared_ptr<_Tp, _Lp>>
    : public _Sp_owner_less<__shared_ptr<_Tp, _Lp>, __weak_ptr<_Tp, _Lp>>
    { };

  template<typename _Tp, _Lock_policy _Lp>
    struct owner_less<__weak_ptr<_Tp, _Lp>>
    : public _Sp_owner_less<__weak_ptr<_Tp, _Lp>, __shared_ptr<_Tp, _Lp>>
    { };


  template<typename _Tp, _Lock_policy _Lp>
    class __enable_shared_from_this
    {
    protected:
      constexpr __enable_shared_from_this() noexcept { }

      __enable_shared_from_this(const __enable_shared_from_this&) noexcept { }

      __enable_shared_from_this&
      operator=(const __enable_shared_from_this&) noexcept
      { return *this; }

      ~__enable_shared_from_this() { }

    public:
      __shared_ptr<_Tp, _Lp>
      shared_from_this()
      { return __shared_ptr<_Tp, _Lp>(this->_M_weak_this); }

      __shared_ptr<const _Tp, _Lp>
      shared_from_this() const
      { return __shared_ptr<const _Tp, _Lp>(this->_M_weak_this); }


      __weak_ptr<_Tp, _Lp>
      weak_from_this() noexcept
      { return this->_M_weak_this; }

      __weak_ptr<const _Tp, _Lp>
      weak_from_this() const noexcept
      { return this->_M_weak_this; }


    private:
      template<typename _Tp1>
 void
 _M_weak_assign(_Tp1* __p, const __shared_count<_Lp>& __n) const noexcept
 { _M_weak_this._M_assign(__p, __n); }

      friend const __enable_shared_from_this*
      __enable_shared_from_this_base(const __shared_count<_Lp>&,
         const __enable_shared_from_this* __p)
      { return __p; }

      template<typename, _Lock_policy>
 friend class __shared_ptr;

      mutable __weak_ptr<_Tp, _Lp> _M_weak_this;
    };

  template<typename _Tp, _Lock_policy _Lp = __default_lock_policy,
    typename _Alloc, typename... _Args>
    inline __shared_ptr<_Tp, _Lp>
    __allocate_shared(const _Alloc& __a, _Args&&... __args)
    {
      static_assert(!is_array<_Tp>::value, "make_shared<T[]> not supported");

      return __shared_ptr<_Tp, _Lp>(_Sp_alloc_shared_tag<_Alloc>{__a},
        std::forward<_Args>(__args)...);
    }

  template<typename _Tp, _Lock_policy _Lp = __default_lock_policy,
    typename... _Args>
    inline __shared_ptr<_Tp, _Lp>
    __make_shared(_Args&&... __args)
    {
      typedef typename std::remove_const<_Tp>::type _Tp_nc;
      return std::__allocate_shared<_Tp, _Lp>(std::allocator<_Tp_nc>(),
           std::forward<_Args>(__args)...);
    }


  template<typename _Tp, _Lock_policy _Lp>
    struct hash<__shared_ptr<_Tp, _Lp>>
    : public __hash_base<size_t, __shared_ptr<_Tp, _Lp>>
    {
      size_t
      operator()(const __shared_ptr<_Tp, _Lp>& __s) const noexcept
      {
 return hash<typename __shared_ptr<_Tp, _Lp>::element_type*>()(
     __s.get());
      }
    };


}
# 54 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/shared_ptr.h" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{
# 68 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/shared_ptr.h" 3
  template<typename _Ch, typename _Tr, typename _Tp, _Lock_policy _Lp>
    inline std::basic_ostream<_Ch, _Tr>&
    operator<<(std::basic_ostream<_Ch, _Tr>& __os,
        const __shared_ptr<_Tp, _Lp>& __p)
    {
      __os << __p.get();
      return __os;
    }

  template<typename _Del, typename _Tp, _Lock_policy _Lp>
    inline _Del*
    get_deleter(const __shared_ptr<_Tp, _Lp>& __p) noexcept
    {

      return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del)));



    }





  template<typename _Del, typename _Tp>
    inline _Del*
    get_deleter(const shared_ptr<_Tp>& __p) noexcept
    {

      return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del)));



    }





  template<typename _Tp>
    requires (!is_array_v<_Tp>)
    using _NonArray = _Tp;
# 118 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/shared_ptr.h" 3
  template<typename _Tp>
    requires is_array_v<_Tp> && (extent_v<_Tp> == 0)
    using _UnboundedArray = _Tp;
# 129 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/shared_ptr.h" 3
  template<typename _Tp>
    requires (extent_v<_Tp> != 0)
    using _BoundedArray = _Tp;
# 141 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/shared_ptr.h" 3
  template<typename _Tp>
    requires (!is_array_v<_Tp>) || (extent_v<_Tp> != 0)
    using _NotUnboundedArray = _Tp;
# 174 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/shared_ptr.h" 3
  template<typename _Tp>
    class shared_ptr : public __shared_ptr<_Tp>
    {
      template<typename... _Args>
 using _Constructible = typename enable_if<
   is_constructible<__shared_ptr<_Tp>, _Args...>::value
 >::type;

      template<typename _Arg>
 using _Assignable = typename enable_if<
   is_assignable<__shared_ptr<_Tp>&, _Arg>::value, shared_ptr&
 >::type;

    public:


      using element_type = typename __shared_ptr<_Tp>::element_type;




      using weak_type = weak_ptr<_Tp>;





      constexpr shared_ptr() noexcept : __shared_ptr<_Tp>() { }

      shared_ptr(const shared_ptr&) noexcept = default;







      template<typename _Yp, typename = _Constructible<_Yp*>>
 explicit
 shared_ptr(_Yp* __p) : __shared_ptr<_Tp>(__p) { }
# 228 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/shared_ptr.h" 3
      template<typename _Yp, typename _Deleter,
        typename = _Constructible<_Yp*, _Deleter>>
 shared_ptr(_Yp* __p, _Deleter __d)
        : __shared_ptr<_Tp>(__p, std::move(__d)) { }
# 246 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/shared_ptr.h" 3
      template<typename _Deleter>
 shared_ptr(nullptr_t __p, _Deleter __d)
        : __shared_ptr<_Tp>(__p, std::move(__d)) { }
# 265 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/shared_ptr.h" 3
      template<typename _Yp, typename _Deleter, typename _Alloc,
        typename = _Constructible<_Yp*, _Deleter, _Alloc>>
 shared_ptr(_Yp* __p, _Deleter __d, _Alloc __a)
 : __shared_ptr<_Tp>(__p, std::move(__d), std::move(__a)) { }
# 285 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/shared_ptr.h" 3
      template<typename _Deleter, typename _Alloc>
 shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a)
 : __shared_ptr<_Tp>(__p, std::move(__d), std::move(__a)) { }
# 309 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/shared_ptr.h" 3
      template<typename _Yp>
 shared_ptr(const shared_ptr<_Yp>& __r, element_type* __p) noexcept
 : __shared_ptr<_Tp>(__r, __p) { }
# 337 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/shared_ptr.h" 3
      template<typename _Yp>
 shared_ptr(shared_ptr<_Yp>&& __r, element_type* __p) noexcept
 : __shared_ptr<_Tp>(std::move(__r), __p) { }
# 348 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/shared_ptr.h" 3
      template<typename _Yp,
        typename = _Constructible<const shared_ptr<_Yp>&>>
 shared_ptr(const shared_ptr<_Yp>& __r) noexcept
        : __shared_ptr<_Tp>(__r) { }






      shared_ptr(shared_ptr&& __r) noexcept
      : __shared_ptr<_Tp>(std::move(__r)) { }






      template<typename _Yp, typename = _Constructible<shared_ptr<_Yp>>>
 shared_ptr(shared_ptr<_Yp>&& __r) noexcept
 : __shared_ptr<_Tp>(std::move(__r)) { }
# 378 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/shared_ptr.h" 3
      template<typename _Yp, typename = _Constructible<const weak_ptr<_Yp>&>>
 explicit shared_ptr(const weak_ptr<_Yp>& __r)
 : __shared_ptr<_Tp>(__r) { }


#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
      template<typename _Yp, typename = _Constructible<auto_ptr<_Yp>>>
 shared_ptr(auto_ptr<_Yp>&& __r);
#pragma GCC diagnostic pop




      template<typename _Yp, typename _Del,
        typename = _Constructible<unique_ptr<_Yp, _Del>>>
 shared_ptr(unique_ptr<_Yp, _Del>&& __r)
 : __shared_ptr<_Tp>(std::move(__r)) { }
# 411 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/shared_ptr.h" 3
      constexpr shared_ptr(nullptr_t) noexcept : shared_ptr() { }

      shared_ptr& operator=(const shared_ptr&) noexcept = default;

      template<typename _Yp>
 _Assignable<const shared_ptr<_Yp>&>
 operator=(const shared_ptr<_Yp>& __r) noexcept
 {
   this->__shared_ptr<_Tp>::operator=(__r);
   return *this;
 }


#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
      template<typename _Yp>
 _Assignable<auto_ptr<_Yp>>
 operator=(auto_ptr<_Yp>&& __r)
 {
   this->__shared_ptr<_Tp>::operator=(std::move(__r));
   return *this;
 }
#pragma GCC diagnostic pop


      shared_ptr&
      operator=(shared_ptr&& __r) noexcept
      {
 this->__shared_ptr<_Tp>::operator=(std::move(__r));
 return *this;
      }

      template<class _Yp>
 _Assignable<shared_ptr<_Yp>>
 operator=(shared_ptr<_Yp>&& __r) noexcept
 {
   this->__shared_ptr<_Tp>::operator=(std::move(__r));
   return *this;
 }

      template<typename _Yp, typename _Del>
 _Assignable<unique_ptr<_Yp, _Del>>
 operator=(unique_ptr<_Yp, _Del>&& __r)
 {
   this->__shared_ptr<_Tp>::operator=(std::move(__r));
   return *this;
 }

    private:

      template<typename _Alloc, typename... _Args>
 shared_ptr(_Sp_alloc_shared_tag<_Alloc> __tag, _Args&&... __args)
 : __shared_ptr<_Tp>(__tag, std::forward<_Args>(__args)...)
 { }

      template<typename _Yp, typename _Alloc, typename... _Args>
 friend shared_ptr<_NonArray<_Yp>>
 allocate_shared(const _Alloc&, _Args&&...);

      template<typename _Yp, typename... _Args>
 friend shared_ptr<_NonArray<_Yp>>
 make_shared(_Args&&...);



      template<typename _Alloc, typename _Init = const remove_extent_t<_Tp>*>
 shared_ptr(const _Sp_counted_array_base<_Alloc>& __a,
     _Init __init = nullptr)
 : __shared_ptr<_Tp>(__a, __init)
 { }

      template<typename _Yp, typename _Alloc>
 friend shared_ptr<_UnboundedArray<_Yp>>
 allocate_shared(const _Alloc&, size_t);

      template<typename _Yp>
 friend shared_ptr<_UnboundedArray<_Yp>>
 make_shared(size_t);

      template<typename _Yp, typename _Alloc>
 friend shared_ptr<_UnboundedArray<_Yp>>
 allocate_shared(const _Alloc&, size_t, const remove_extent_t<_Yp>&);

      template<typename _Yp>
 friend shared_ptr<_UnboundedArray<_Yp>>
 make_shared(size_t, const remove_extent_t<_Yp>&);

      template<typename _Yp, typename _Alloc>
 friend shared_ptr<_BoundedArray<_Yp>>
 allocate_shared(const _Alloc&);

      template<typename _Yp>
 friend shared_ptr<_BoundedArray<_Yp>>
 make_shared();

      template<typename _Yp, typename _Alloc>
 friend shared_ptr<_BoundedArray<_Yp>>
 allocate_shared(const _Alloc&, const remove_extent_t<_Yp>&);

      template<typename _Yp>
 friend shared_ptr<_BoundedArray<_Yp>>
 make_shared(const remove_extent_t<_Yp>&);


      template<typename _Yp, typename _Alloc>
 friend shared_ptr<_NotUnboundedArray<_Yp>>
 allocate_shared_for_overwrite(const _Alloc&);

      template<typename _Yp>
 friend shared_ptr<_NotUnboundedArray<_Yp>>
 make_shared_for_overwrite();

      template<typename _Yp, typename _Alloc>
 friend shared_ptr<_UnboundedArray<_Yp>>
 allocate_shared_for_overwrite(const _Alloc&, size_t);

      template<typename _Yp>
 friend shared_ptr<_UnboundedArray<_Yp>>
 make_shared_for_overwrite(size_t);




      shared_ptr(const weak_ptr<_Tp>& __r, std::nothrow_t) noexcept
      : __shared_ptr<_Tp>(__r, std::nothrow) { }

      friend class weak_ptr<_Tp>;
    };


  template<typename _Tp>
    shared_ptr(weak_ptr<_Tp>) -> shared_ptr<_Tp>;
  template<typename _Tp, typename _Del>
    shared_ptr(unique_ptr<_Tp, _Del>) -> shared_ptr<_Tp>;







  template<typename _Tp, typename _Up>
    [[__nodiscard__]] inline bool
    operator==(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept
    { return __a.get() == __b.get(); }


  template<typename _Tp>
    [[__nodiscard__]] inline bool
    operator==(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
    { return !__a; }


  template<typename _Tp, typename _Up>
    inline strong_ordering
    operator<=>(const shared_ptr<_Tp>& __a,
  const shared_ptr<_Up>& __b) noexcept
    { return compare_three_way()(__a.get(), __b.get()); }

  template<typename _Tp>
    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<pointer>(nullptr));
    }
# 689 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/shared_ptr.h" 3
  template<typename _Tp>
    inline void
    swap(shared_ptr<_Tp>& __a, shared_ptr<_Tp>& __b) noexcept
    { __a.swap(__b); }




  template<typename _Tp, typename _Up>
    inline shared_ptr<_Tp>
    static_pointer_cast(const shared_ptr<_Up>& __r) noexcept
    {
      using _Sp = shared_ptr<_Tp>;
      return _Sp(__r, static_cast<typename _Sp::element_type*>(__r.get()));
    }


  template<typename _Tp, typename _Up>
    inline shared_ptr<_Tp>
    const_pointer_cast(const shared_ptr<_Up>& __r) noexcept
    {
      using _Sp = shared_ptr<_Tp>;
      return _Sp(__r, const_cast<typename _Sp::element_type*>(__r.get()));
    }


  template<typename _Tp, typename _Up>
    inline shared_ptr<_Tp>
    dynamic_pointer_cast(const shared_ptr<_Up>& __r) noexcept
    {
      using _Sp = shared_ptr<_Tp>;
      if (auto* __p = dynamic_cast<typename _Sp::element_type*>(__r.get()))
 return _Sp(__r, __p);
      return _Sp();
    }




  template<typename _Tp, typename _Up>
    inline shared_ptr<_Tp>
    reinterpret_pointer_cast(const shared_ptr<_Up>& __r) noexcept
    {
      using _Sp = shared_ptr<_Tp>;
      return _Sp(__r, reinterpret_cast<typename _Sp::element_type*>(__r.get()));
    }







  template<typename _Tp, typename _Up>
    inline shared_ptr<_Tp>
    static_pointer_cast(shared_ptr<_Up>&& __r) noexcept
    {
      using _Sp = shared_ptr<_Tp>;
      return _Sp(std::move(__r),
   static_cast<typename _Sp::element_type*>(__r.get()));
    }



  template<typename _Tp, typename _Up>
    inline shared_ptr<_Tp>
    const_pointer_cast(shared_ptr<_Up>&& __r) noexcept
    {
      using _Sp = shared_ptr<_Tp>;
      return _Sp(std::move(__r),
   const_cast<typename _Sp::element_type*>(__r.get()));
    }



  template<typename _Tp, typename _Up>
    inline shared_ptr<_Tp>
    dynamic_pointer_cast(shared_ptr<_Up>&& __r) noexcept
    {
      using _Sp = shared_ptr<_Tp>;
      if (auto* __p = dynamic_cast<typename _Sp::element_type*>(__r.get()))
 return _Sp(std::move(__r), __p);
      return _Sp();
    }



  template<typename _Tp, typename _Up>
    inline shared_ptr<_Tp>
    reinterpret_pointer_cast(shared_ptr<_Up>&& __r) noexcept
    {
      using _Sp = shared_ptr<_Tp>;
      return _Sp(std::move(__r),
   reinterpret_cast<typename _Sp::element_type*>(__r.get()));
    }
# 809 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/shared_ptr.h" 3
  template<typename _Tp>
    class weak_ptr : public __weak_ptr<_Tp>
    {
      template<typename _Arg>
 using _Constructible = typename enable_if<
   is_constructible<__weak_ptr<_Tp>, _Arg>::value
 >::type;

      template<typename _Arg>
 using _Assignable = typename enable_if<
   is_assignable<__weak_ptr<_Tp>&, _Arg>::value, weak_ptr&
 >::type;

    public:
      constexpr weak_ptr() noexcept = default;

      template<typename _Yp,
        typename = _Constructible<const shared_ptr<_Yp>&>>
 weak_ptr(const shared_ptr<_Yp>& __r) noexcept
 : __weak_ptr<_Tp>(__r) { }

      weak_ptr(const weak_ptr&) noexcept = default;

      template<typename _Yp, typename = _Constructible<const weak_ptr<_Yp>&>>
 weak_ptr(const weak_ptr<_Yp>& __r) noexcept
 : __weak_ptr<_Tp>(__r) { }

      weak_ptr(weak_ptr&&) noexcept = default;

      template<typename _Yp, typename = _Constructible<weak_ptr<_Yp>>>
 weak_ptr(weak_ptr<_Yp>&& __r) noexcept
 : __weak_ptr<_Tp>(std::move(__r)) { }

      weak_ptr&
      operator=(const weak_ptr& __r) noexcept = default;

      template<typename _Yp>
 _Assignable<const weak_ptr<_Yp>&>
 operator=(const weak_ptr<_Yp>& __r) noexcept
 {
   this->__weak_ptr<_Tp>::operator=(__r);
   return *this;
 }

      template<typename _Yp>
 _Assignable<const shared_ptr<_Yp>&>
 operator=(const shared_ptr<_Yp>& __r) noexcept
 {
   this->__weak_ptr<_Tp>::operator=(__r);
   return *this;
 }

      weak_ptr&
      operator=(weak_ptr&& __r) noexcept = default;

      template<typename _Yp>
 _Assignable<weak_ptr<_Yp>>
 operator=(weak_ptr<_Yp>&& __r) noexcept
 {
   this->__weak_ptr<_Tp>::operator=(std::move(__r));
   return *this;
 }

      shared_ptr<_Tp>
      lock() const noexcept
      { return shared_ptr<_Tp>(*this, std::nothrow); }
    };


  template<typename _Tp>
    weak_ptr(shared_ptr<_Tp>) -> weak_ptr<_Tp>;





  template<typename _Tp>
    inline void
    swap(weak_ptr<_Tp>& __a, weak_ptr<_Tp>& __b) noexcept
    { __a.swap(__b); }



  template<typename _Tp = void>
    struct owner_less;


  template<>
    struct owner_less<void> : _Sp_owner_less<void, void>
    { };


  template<typename _Tp>
    struct owner_less<shared_ptr<_Tp>>
    : public _Sp_owner_less<shared_ptr<_Tp>, weak_ptr<_Tp>>
    { };


  template<typename _Tp>
    struct owner_less<weak_ptr<_Tp>>
    : public _Sp_owner_less<weak_ptr<_Tp>, shared_ptr<_Tp>>
    { };






  template<typename _Tp>
    class enable_shared_from_this
    {
    protected:
      constexpr enable_shared_from_this() noexcept { }

      enable_shared_from_this(const enable_shared_from_this&) noexcept { }

      enable_shared_from_this&
      operator=(const enable_shared_from_this&) noexcept
      { return *this; }

      ~enable_shared_from_this() { }

    public:
      shared_ptr<_Tp>
      shared_from_this()
      { return shared_ptr<_Tp>(this->_M_weak_this); }

      shared_ptr<const _Tp>
      shared_from_this() const
      { return shared_ptr<const _Tp>(this->_M_weak_this); }






      weak_ptr<_Tp>
      weak_from_this() noexcept
      { return this->_M_weak_this; }

      weak_ptr<const _Tp>
      weak_from_this() const noexcept
      { return this->_M_weak_this; }



    private:
      template<typename _Tp1>
 void
 _M_weak_assign(_Tp1* __p, const __shared_count<>& __n) const noexcept
 { _M_weak_this._M_assign(__p, __n); }


      friend const enable_shared_from_this*
      __enable_shared_from_this_base(const __shared_count<>&,
         const enable_shared_from_this* __p)
      { return __p; }

      template<typename, _Lock_policy>
 friend class __shared_ptr;

      mutable weak_ptr<_Tp> _M_weak_this;
    };
# 986 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/shared_ptr.h" 3
  template<typename _Tp, typename _Alloc, typename... _Args>
    inline shared_ptr<_NonArray<_Tp>>
    allocate_shared(const _Alloc& __a, _Args&&... __args)
    {
      return shared_ptr<_Tp>(_Sp_alloc_shared_tag<_Alloc>{__a},
        std::forward<_Args>(__args)...);
    }
# 1001 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/shared_ptr.h" 3
  template<typename _Tp, typename... _Args>
    inline shared_ptr<_NonArray<_Tp>>
    make_shared(_Args&&... __args)
    {
      using _Alloc = allocator<void>;
      _Alloc __a;
      return shared_ptr<_Tp>(_Sp_alloc_shared_tag<_Alloc>{__a},
        std::forward<_Args>(__args)...);
    }



  template<typename _Tp, typename _Alloc = allocator<void>>
    auto
    __make_shared_arr_tag(size_t __n, const _Alloc& __a = _Alloc()) noexcept
    {
      using _Up = remove_all_extents_t<_Tp>;
      using _UpAlloc = __alloc_rebind<_Alloc, _Up>;
      size_t __s = sizeof(remove_extent_t<_Tp>) / sizeof(_Up);
      if (__builtin_mul_overflow(__s, __n, &__n))
 std::__throw_bad_array_new_length();
      return _Sp_counted_array_base<_UpAlloc>{_UpAlloc(__a), __n};
    }


  template<typename _Tp, typename _Alloc>
    inline shared_ptr<_UnboundedArray<_Tp>>
    allocate_shared(const _Alloc& __a, size_t __n)
    {
      return shared_ptr<_Tp>(std::__make_shared_arr_tag<_Tp>(__n, __a));
    }

  template<typename _Tp>
    inline shared_ptr<_UnboundedArray<_Tp>>
    make_shared(size_t __n)
    {
      return shared_ptr<_Tp>(std::__make_shared_arr_tag<_Tp>(__n));
    }

  template<typename _Tp, typename _Alloc>
    inline shared_ptr<_UnboundedArray<_Tp>>
    allocate_shared(const _Alloc& __a, size_t __n,
      const remove_extent_t<_Tp>& __u)
    {
      return shared_ptr<_Tp>(std::__make_shared_arr_tag<_Tp>(__n, __a),
        std::__addressof(__u));
    }

  template<typename _Tp>
    inline shared_ptr<_UnboundedArray<_Tp>>
    make_shared(size_t __n, const remove_extent_t<_Tp>& __u)
    {
      return shared_ptr<_Tp>(std::__make_shared_arr_tag<_Tp>(__n),
        std::__addressof(__u));
    }


  template<typename _Tp, typename _Alloc = allocator<void>>
    auto
    __make_shared_arrN_tag(const _Alloc& __a = _Alloc()) noexcept
    {
      using _Up = remove_all_extents_t<_Tp>;
      using _UpAlloc = __alloc_rebind<_Alloc, _Up>;
      size_t __n = sizeof(_Tp) / sizeof(_Up);
      return _Sp_counted_array_base<_UpAlloc>{_UpAlloc(__a), __n};
    }


  template<typename _Tp, typename _Alloc>
    inline shared_ptr<_BoundedArray<_Tp>>
    allocate_shared(const _Alloc& __a)
    {
      return shared_ptr<_Tp>(std::__make_shared_arrN_tag<_Tp>(__a));
    }

  template<typename _Tp>
    inline shared_ptr<_BoundedArray<_Tp>>
    make_shared()
    {
      return shared_ptr<_Tp>(std::__make_shared_arrN_tag<_Tp>());
    }

  template<typename _Tp, typename _Alloc>
    inline shared_ptr<_BoundedArray<_Tp>>
    allocate_shared(const _Alloc& __a, const remove_extent_t<_Tp>& __u)
    {
      return shared_ptr<_Tp>(std::__make_shared_arrN_tag<_Tp>(__a),
        std::__addressof(__u));
    }

  template<typename _Tp>
    inline shared_ptr<_BoundedArray<_Tp>>
    make_shared(const remove_extent_t<_Tp>& __u)
    {
      return shared_ptr<_Tp>(std::__make_shared_arrN_tag<_Tp>(),
        std::__addressof(__u));
    }


  template<typename _Tp, typename _Alloc>
    inline shared_ptr<_NotUnboundedArray<_Tp>>
    allocate_shared_for_overwrite(const _Alloc& __a)
    {
      if constexpr (is_array_v<_Tp>)
 return shared_ptr<_Tp>(std::__make_shared_arrN_tag<_Tp>(__a),
          _Sp_overwrite_tag{});
      else
 {


   using _Alloc2 = __alloc_rebind<_Alloc, _Sp_overwrite_tag>;
   _Alloc2 __a2 = __a;
   return shared_ptr<_Tp>(_Sp_alloc_shared_tag<_Alloc2>{__a2});
 }
    }

  template<typename _Tp>
    inline shared_ptr<_NotUnboundedArray<_Tp>>
    make_shared_for_overwrite()
    {
      if constexpr (is_array_v<_Tp>)
 return shared_ptr<_Tp>(std::__make_shared_arrN_tag<_Tp>(),
          _Sp_overwrite_tag{});
      else
 {
   using _Alloc = allocator<_Sp_overwrite_tag>;
   return shared_ptr<_Tp>(_Sp_alloc_shared_tag<_Alloc>{{}});
 }
    }

  template<typename _Tp, typename _Alloc>
    inline shared_ptr<_UnboundedArray<_Tp>>
    allocate_shared_for_overwrite(const _Alloc& __a, size_t __n)
    {
      return shared_ptr<_Tp>(std::__make_shared_arr_tag<_Tp>(__n, __a),
        _Sp_overwrite_tag{});
    }

  template<typename _Tp>
    inline shared_ptr<_UnboundedArray<_Tp>>
    make_shared_for_overwrite(size_t __n)
    {
      return shared_ptr<_Tp>(std::__make_shared_arr_tag<_Tp>(__n),
        _Sp_overwrite_tag{});
    }




  template<typename _Tp>
    struct hash<shared_ptr<_Tp>>
    : public __hash_base<size_t, shared_ptr<_Tp>>
    {
      size_t
      operator()(const shared_ptr<_Tp>& __s) const noexcept
      {
 return std::hash<typename shared_ptr<_Tp>::element_type*>()(__s.get());
      }
    };


  template<typename _Tp>
    static constexpr bool __is_shared_ptr = false;
  template<typename _Tp>
    static constexpr bool __is_shared_ptr<shared_ptr<_Tp>> = true;






  namespace __detail::__variant
  {
    template<typename> struct _Never_valueless_alt;



    template<typename _Tp>
      struct _Never_valueless_alt<std::shared_ptr<_Tp>>
      : std::true_type
      { };



    template<typename _Tp>
      struct _Never_valueless_alt<std::weak_ptr<_Tp>>
      : std::true_type
      { };
  }



}
# 81 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/memory" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/shared_ptr_atomic.h" 1 3
# 33 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/shared_ptr_atomic.h" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/atomic_base.h" 1 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/atomic_base.h" 3




# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/atomic_lockfree_defines.h" 1 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/atomic_lockfree_defines.h" 3
# 39 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/atomic_base.h" 2 3



# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/atomic_wait.h" 1 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/atomic_wait.h" 3

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 36 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/atomic_wait.h" 2 3








# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cerrno" 1 3
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cerrno" 3
# 45 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/atomic_wait.h" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/climits" 1 3
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/climits" 3


# 1 "/usr/bin/../lib/clang/18/include/limits.h" 1 3
# 21 "/usr/bin/../lib/clang/18/include/limits.h" 3
# 1 "/usr/include/limits.h" 1 3 4
# 26 "/usr/include/limits.h" 3 4
# 1 "/usr/include/bits/libc-header-start.h" 1 3 4
# 27 "/usr/include/limits.h" 2 3 4
# 195 "/usr/include/limits.h" 3 4
# 1 "/usr/include/bits/posix1_lim.h" 1 3 4
# 27 "/usr/include/bits/posix1_lim.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 28 "/usr/include/bits/posix1_lim.h" 2 3 4
# 161 "/usr/include/bits/posix1_lim.h" 3 4
# 1 "/usr/include/bits/local_lim.h" 1 3 4
# 38 "/usr/include/bits/local_lim.h" 3 4
# 1 "/usr/include/linux/limits.h" 1 3 4
# 39 "/usr/include/bits/local_lim.h" 2 3 4
# 162 "/usr/include/bits/posix1_lim.h" 2 3 4
# 196 "/usr/include/limits.h" 2 3 4



# 1 "/usr/include/bits/posix2_lim.h" 1 3 4
# 200 "/usr/include/limits.h" 2 3 4



# 1 "/usr/include/bits/xopen_lim.h" 1 3 4
# 64 "/usr/include/bits/xopen_lim.h" 3 4
# 1 "/usr/include/bits/uio_lim.h" 1 3 4
# 65 "/usr/include/bits/xopen_lim.h" 2 3 4
# 204 "/usr/include/limits.h" 2 3 4
# 22 "/usr/bin/../lib/clang/18/include/limits.h" 2 3
# 43 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/climits" 2 3
# 46 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/atomic_wait.h" 2 3

# 1 "/usr/include/syscall.h" 1 3 4
# 1 "/usr/include/sys/syscall.h" 1 3 4
# 24 "/usr/include/sys/syscall.h" 3 4
# 1 "/usr/include/asm/unistd.h" 1 3 4
# 20 "/usr/include/asm/unistd.h" 3 4
# 1 "/usr/include/asm/unistd_64.h" 1 3 4
# 21 "/usr/include/asm/unistd.h" 2 3 4
# 25 "/usr/include/sys/syscall.h" 2 3 4




# 1 "/usr/include/bits/syscall.h" 1 3 4
# 30 "/usr/include/sys/syscall.h" 2 3 4
# 2 "/usr/include/syscall.h" 2 3 4
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/atomic_wait.h" 2 3



# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/std_mutex.h" 1 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/std_mutex.h" 3
# 43 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/std_mutex.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 59 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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;
# 80 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/std_mutex.h" 3
    __mutex_base(const __mutex_base&) = delete;
    __mutex_base& operator=(const __mutex_base&) = delete;
  };
# 96 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/std_mutex.h" 3
  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);
    }

    [[__nodiscard__]]
    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; }
  };




  class __condvar
  {
    using timespec = __gthread_time_t;

  public:
    __condvar() noexcept
    {



    }

    ~__condvar()
    {
      int __e __attribute__((__unused__)) = __gthread_cond_destroy(&_M_cond);
      do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__e != 16), false)) std::__glibcxx_assert_fail(); } while (false);
    }

    __condvar(const __condvar&) = delete;
    __condvar& operator=(const __condvar&) = delete;

    __gthread_cond_t* native_handle() noexcept { return &_M_cond; }


    void
    wait(mutex& __m)
    {
      int __e __attribute__((__unused__))
 = __gthread_cond_wait(&_M_cond, __m.native_handle());
      do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__e == 0), false)) std::__glibcxx_assert_fail(); } while (false);
    }

    void
    wait_until(mutex& __m, timespec& __abs_time)
    {
      __gthread_cond_timedwait(&_M_cond, __m.native_handle(), &__abs_time);
    }


    void
    wait_until(mutex& __m, clockid_t __clock, timespec& __abs_time)
    {
      pthread_cond_clockwait(&_M_cond, __m.native_handle(), __clock,
        &__abs_time);
    }


    void
    notify_one() noexcept
    {
      int __e __attribute__((__unused__)) = __gthread_cond_signal(&_M_cond);
      do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__e == 0), false)) std::__glibcxx_assert_fail(); } while (false);
    }

    void
    notify_all() noexcept
    {
      int __e __attribute__((__unused__)) = __gthread_cond_broadcast(&_M_cond);
      do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__e == 0), false)) std::__glibcxx_assert_fail(); } while (false);
    }

  protected:

    __gthread_cond_t _M_cond = { { {0}, {0}, {0, 0}, {0, 0}, 0, 0, {0, 0} } };



  };





  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 { };
# 242 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/std_mutex.h" 3
  template<typename _Mutex>
    class lock_guard
    {
    public:
      typedef _Mutex mutex_type;

      [[__nodiscard__]]
      explicit lock_guard(mutex_type& __m) : _M_device(__m)
      { _M_device.lock(); }

      [[__nodiscard__]]
      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;
    };



}
# 52 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/atomic_wait.h" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{

  namespace __detail
  {


    using __platform_wait_t = int;
    inline constexpr size_t __platform_wait_alignment = 4;
# 75 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/atomic_wait.h" 3
  }

  template<typename _Tp>
    inline constexpr bool __platform_wait_uses_type

      = is_scalar_v<_Tp>
 && ((sizeof(_Tp) == sizeof(__detail::__platform_wait_t))
 && (alignof(_Tp*) >= __detail::__platform_wait_alignment));




  namespace __detail
  {

    enum class __futex_wait_flags : int
    {



      __private_flag = 0,

      __wait = 0,
      __wake = 1,
      __wait_bitset = 9,
      __wake_bitset = 10,
      __wait_private = __wait | __private_flag,
      __wake_private = __wake | __private_flag,
      __wait_bitset_private = __wait_bitset | __private_flag,
      __wake_bitset_private = __wake_bitset | __private_flag,
      __bitset_match_any = -1
    };

    template<typename _Tp>
      void
      __platform_wait(const _Tp* __addr, __platform_wait_t __val) noexcept
      {
 auto __e = syscall (202, static_cast<const void*>(__addr),
       static_cast<int>(__futex_wait_flags::__wait_private),
       __val, nullptr);
 if (!__e || (*__errno_location ()) == 11)
   return;
 if ((*__errno_location ()) != 4)
   __throw_system_error((*__errno_location ()));
      }

    template<typename _Tp>
      void
      __platform_notify(const _Tp* __addr, bool __all) noexcept
      {
 syscall (202, static_cast<const void*>(__addr),
   static_cast<int>(__futex_wait_flags::__wake_private),
   __all ? 2147483647 : 1);
      }


    inline void
    __thread_yield() noexcept
    {

     __gthread_yield();

    }

    inline void
    __thread_relax() noexcept
    {

      __builtin_ia32_pause();



    }

    inline constexpr auto __atomic_spin_count_relax = 12;
    inline constexpr auto __atomic_spin_count = 16;

    struct __default_spin_policy
    {
      bool
      operator()() const noexcept
      { return false; }
    };

    template<typename _Pred,
      typename _Spin = __default_spin_policy>
      bool
      __atomic_spin(_Pred& __pred, _Spin __spin = _Spin{ }) noexcept
      {
 for (auto __i = 0; __i < __atomic_spin_count; ++__i)
   {
     if (__pred())
       return true;

     if (__i < __atomic_spin_count_relax)
       __detail::__thread_relax();
     else
       __detail::__thread_yield();
   }

 while (__spin())
   {
     if (__pred())
       return true;
   }

 return false;
      }


    template<typename _Tp>
      bool __atomic_compare(const _Tp& __a, const _Tp& __b)
      {

 return __builtin_memcmp(&__a, &__b, sizeof(_Tp)) == 0;
      }

    struct __waiter_pool_base
    {


      static constexpr auto _S_align = 64;

      alignas(_S_align) __platform_wait_t _M_wait = 0;





      alignas(_S_align) __platform_wait_t _M_ver = 0;




      __waiter_pool_base() = default;

      void
      _M_enter_wait() noexcept
      { __atomic_fetch_add(&_M_wait, 1, 5); }

      void
      _M_leave_wait() noexcept
      { __atomic_fetch_sub(&_M_wait, 1, 3); }

      bool
      _M_waiting() const noexcept
      {
 __platform_wait_t __res;
 __atomic_load(&_M_wait, &__res, 5);
 return __res != 0;
      }

      void
      _M_notify(__platform_wait_t* __addr, [[maybe_unused]] bool __all,
  bool __bare) noexcept
      {

 if (__addr == &_M_ver)
   {
     __atomic_fetch_add(__addr, 1, 5);
     __all = true;
   }

 if (__bare || _M_waiting())
   __platform_notify(__addr, __all);
# 248 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/atomic_wait.h" 3
      }

      static __waiter_pool_base&
      _S_for(const void* __addr) noexcept
      {
 constexpr uintptr_t __ct = 16;
 static __waiter_pool_base __w[__ct];
 auto __key = (uintptr_t(__addr) >> 2) % __ct;
 return __w[__key];
      }
    };

    struct __waiter_pool : __waiter_pool_base
    {
      void
      _M_do_wait(const __platform_wait_t* __addr, __platform_wait_t __old) noexcept
      {

 __platform_wait(__addr, __old);
# 278 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/atomic_wait.h" 3
      }
    };

    template<typename _Tp>
      struct __waiter_base
      {
 using __waiter_type = _Tp;

 __waiter_type& _M_w;
 __platform_wait_t* _M_addr;

 template<typename _Up>
   static __platform_wait_t*
   _S_wait_addr(const _Up* __a, __platform_wait_t* __b)
   {
     if constexpr (__platform_wait_uses_type<_Up>)
       return reinterpret_cast<__platform_wait_t*>(const_cast<_Up*>(__a));
     else
       return __b;
   }

 static __waiter_type&
 _S_for(const void* __addr) noexcept
 {
   static_assert(sizeof(__waiter_type) == sizeof(__waiter_pool_base));
   auto& res = __waiter_pool_base::_S_for(__addr);
   return reinterpret_cast<__waiter_type&>(res);
 }

 template<typename _Up>
   explicit __waiter_base(const _Up* __addr) noexcept
     : _M_w(_S_for(__addr))
     , _M_addr(_S_wait_addr(__addr, &_M_w._M_ver))
   { }

 void
 _M_notify(bool __all, bool __bare = false) noexcept
 { _M_w._M_notify(_M_addr, __all, __bare); }

 template<typename _Up, typename _ValFn,
   typename _Spin = __default_spin_policy>
   static bool
   _S_do_spin_v(__platform_wait_t* __addr,
         const _Up& __old, _ValFn __vfn,
         __platform_wait_t& __val,
         _Spin __spin = _Spin{ })
   {
     auto const __pred = [=]
       { return !__detail::__atomic_compare(__old, __vfn()); };

     if constexpr (__platform_wait_uses_type<_Up>)
       {
  __builtin_memcpy(&__val, &__old, sizeof(__val));
       }
     else
       {
  __atomic_load(__addr, &__val, 2);
       }
     return __atomic_spin(__pred, __spin);
   }

 template<typename _Up, typename _ValFn,
   typename _Spin = __default_spin_policy>
   bool
   _M_do_spin_v(const _Up& __old, _ValFn __vfn,
         __platform_wait_t& __val,
         _Spin __spin = _Spin{ })
   { return _S_do_spin_v(_M_addr, __old, __vfn, __val, __spin); }

 template<typename _Pred,
   typename _Spin = __default_spin_policy>
   static bool
   _S_do_spin(const __platform_wait_t* __addr,
       _Pred __pred,
       __platform_wait_t& __val,
       _Spin __spin = _Spin{ })
   {
     __atomic_load(__addr, &__val, 2);
     return __atomic_spin(__pred, __spin);
   }

 template<typename _Pred,
   typename _Spin = __default_spin_policy>
   bool
   _M_do_spin(_Pred __pred, __platform_wait_t& __val,
       _Spin __spin = _Spin{ })
   { return _S_do_spin(_M_addr, __pred, __val, __spin); }
      };

    template<typename _EntersWait>
      struct __waiter : __waiter_base<__waiter_pool>
      {
 using __base_type = __waiter_base<__waiter_pool>;

 template<typename _Tp>
   explicit __waiter(const _Tp* __addr) noexcept
     : __base_type(__addr)
   {
     if constexpr (_EntersWait::value)
       _M_w._M_enter_wait();
   }

 ~__waiter()
 {
   if constexpr (_EntersWait::value)
     _M_w._M_leave_wait();
 }

 template<typename _Tp, typename _ValFn>
   void
   _M_do_wait_v(_Tp __old, _ValFn __vfn)
   {
     do
       {
  __platform_wait_t __val;
  if (__base_type::_M_do_spin_v(__old, __vfn, __val))
    return;
  __base_type::_M_w._M_do_wait(__base_type::_M_addr, __val);
       }
     while (__detail::__atomic_compare(__old, __vfn()));
   }

 template<typename _Pred>
   void
   _M_do_wait(_Pred __pred) noexcept
   {
     do
       {
  __platform_wait_t __val;
  if (__base_type::_M_do_spin(__pred, __val))
    return;
  __base_type::_M_w._M_do_wait(__base_type::_M_addr, __val);
       }
     while (!__pred());
   }
      };

    using __enters_wait = __waiter<std::true_type>;
    using __bare_wait = __waiter<std::false_type>;
  }

  template<typename _Tp, typename _ValFn>
    void
    __atomic_wait_address_v(const _Tp* __addr, _Tp __old,
       _ValFn __vfn) noexcept
    {
      __detail::__enters_wait __w(__addr);
      __w._M_do_wait_v(__old, __vfn);
    }

  template<typename _Tp, typename _Pred>
    void
    __atomic_wait_address(const _Tp* __addr, _Pred __pred) noexcept
    {
      __detail::__enters_wait __w(__addr);
      __w._M_do_wait(__pred);
    }


  template<typename _Pred>
    void
    __atomic_wait_address_bare(const __detail::__platform_wait_t* __addr,
          _Pred __pred) noexcept
    {

      do
 {
   __detail::__platform_wait_t __val;
   if (__detail::__bare_wait::_S_do_spin(__addr, __pred, __val))
     return;
   __detail::__platform_wait(__addr, __val);
 }
      while (!__pred());




    }

  template<typename _Tp>
    void
    __atomic_notify_address(const _Tp* __addr, bool __all) noexcept
    {
      __detail::__bare_wait __w(__addr);
      __w._M_notify(__all);
    }


  inline void
  __atomic_notify_address_bare(const __detail::__platform_wait_t* __addr,
          bool __all) noexcept
  {

    __detail::__platform_notify(__addr, __all);




  }

}
# 43 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/atomic_base.h" 2 3






# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 50 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/atomic_base.h" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{
# 64 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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;
# 93 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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) noexcept
  {
    return memory_order(int(__m) | int(__mod));
  }

  constexpr memory_order
  operator&(memory_order __m, __memory_order_modifier __mod) noexcept
  {
    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));
  }

  constexpr bool
  __is_valid_cmpexch_failure_order(memory_order __m) noexcept
  {
    return (__m & __memory_order_mask) != memory_order_release
 && (__m & __memory_order_mask) != memory_order_acq_rel;
  }


  template<typename _IntTp>
    struct __atomic_base;



  inline __attribute__((__always_inline__)) void
  atomic_thread_fence(memory_order __m) noexcept
  { __atomic_thread_fence(int(__m)); }

  inline __attribute__((__always_inline__)) void
  atomic_signal_fence(memory_order __m) noexcept
  { __atomic_signal_fence(int(__m)); }


  template<typename _Tp>
    inline _Tp
    kill_dependency(_Tp __y) noexcept
    {
      _Tp __ret(__y);
      return __ret;
    }
# 171 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/atomic_base.h" 3
  template<typename _Tp>
    struct atomic;

  template<typename _Tp>
    struct atomic<_Tp*>;



    typedef bool __atomic_flag_data_type;
# 196 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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__)) bool
    test(memory_order __m = memory_order_seq_cst) const noexcept
    {
      __atomic_flag_data_type __v;
      __atomic_load(&_M_i, &__v, int(__m));
      return __v == 1;
    }

    inline __attribute__((__always_inline__)) bool
    test(memory_order __m = memory_order_seq_cst) const volatile noexcept
    {
      __atomic_flag_data_type __v;
      __atomic_load(&_M_i, &__v, int(__m));
      return __v == 1;
    }



    inline __attribute__((__always_inline__)) void
    wait(bool __old,
 memory_order __m = memory_order_seq_cst) const noexcept
    {
      const __atomic_flag_data_type __v
 = __old ? 1 : 0;

      std::__atomic_wait_address_v(&_M_i, __v,
   [__m, this] { return __atomic_load_n(&_M_i, int(__m)); });
    }



    inline __attribute__((__always_inline__)) void
    notify_one() noexcept
    { std::__atomic_notify_address(&_M_i, false); }



    inline __attribute__((__always_inline__)) void
    notify_all() noexcept
    { std::__atomic_notify_address(&_M_i, true); }




    inline __attribute__((__always_inline__)) void
    clear(memory_order __m = memory_order_seq_cst) noexcept
    {
      memory_order __b __attribute__ ((__unused__))
 = __m & __memory_order_mask;
      do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__b != memory_order_consume), false)) std::__glibcxx_assert_fail(); } while (false);
      do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__b != memory_order_acquire), false)) std::__glibcxx_assert_fail(); } while (false);
      do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__b != memory_order_acq_rel), false)) std::__glibcxx_assert_fail(); } while (false);

      __atomic_clear (&_M_i, int(__m));
    }

    inline __attribute__((__always_inline__)) void
    clear(memory_order __m = memory_order_seq_cst) volatile noexcept
    {
      memory_order __b __attribute__ ((__unused__))
 = __m & __memory_order_mask;
      do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__b != memory_order_consume), false)) std::__glibcxx_assert_fail(); } while (false);
      do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__b != memory_order_acquire), false)) std::__glibcxx_assert_fail(); } while (false);
      do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__b != memory_order_acq_rel), false)) std::__glibcxx_assert_fail(); } while (false);

      __atomic_clear (&_M_i, int(__m));
    }

  private:
    static constexpr __atomic_flag_data_type
    _S_init(bool __i)
    { return __i ? 1 : 0; }
  };
# 336 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/atomic_base.h" 3
  template<typename _ITp>
    struct __atomic_base
    {
      using value_type = _ITp;
      using difference_type = value_type;

    private:
      typedef _ITp __int_type;

      static constexpr int _S_alignment =
 sizeof(_ITp) > alignof(_ITp) ? sizeof(_ITp) : alignof(_ITp);

      alignas(_S_alignment) __int_type _M_i = 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<void *>(-_S_alignment));
      }

      bool
      is_lock_free() const volatile noexcept
      {

 return __atomic_is_lock_free(sizeof(_M_i),
     reinterpret_cast<void *>(-_S_alignment));
      }

      inline __attribute__((__always_inline__)) void
      store(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept
      {
 memory_order __b __attribute__ ((__unused__))
   = __m & __memory_order_mask;
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__b != memory_order_acquire), false)) std::__glibcxx_assert_fail(); } while (false);
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__b != memory_order_acq_rel), false)) std::__glibcxx_assert_fail(); } while (false);
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__b != memory_order_consume), false)) std::__glibcxx_assert_fail(); } while (false);

 __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 __attribute__ ((__unused__))
   = __m & __memory_order_mask;
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__b != memory_order_acquire), false)) std::__glibcxx_assert_fail(); } while (false);
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__b != memory_order_acq_rel), false)) std::__glibcxx_assert_fail(); } while (false);
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__b != memory_order_consume), false)) std::__glibcxx_assert_fail(); } while (false);

 __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 __attribute__ ((__unused__))
   = __m & __memory_order_mask;
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__b != memory_order_release), false)) std::__glibcxx_assert_fail(); } while (false);
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__b != memory_order_acq_rel), false)) std::__glibcxx_assert_fail(); } while (false);

 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 __attribute__ ((__unused__))
   = __m & __memory_order_mask;
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__b != memory_order_release), false)) std::__glibcxx_assert_fail(); } while (false);
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__b != memory_order_acq_rel), false)) std::__glibcxx_assert_fail(); } while (false);

 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
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__is_valid_cmpexch_failure_order(__m2)), false)) std::__glibcxx_assert_fail(); } while (false);

 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
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__is_valid_cmpexch_failure_order(__m2)), false)) std::__glibcxx_assert_fail(); } while (false);

 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
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__is_valid_cmpexch_failure_order(__m2)), false)) std::__glibcxx_assert_fail(); } while (false);

 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
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__is_valid_cmpexch_failure_order(__m2)), false)) std::__glibcxx_assert_fail(); } while (false);

 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__)) void
      wait(__int_type __old,
   memory_order __m = memory_order_seq_cst) const noexcept
      {
 std::__atomic_wait_address_v(&_M_i, __old,
      [__m, this] { return this->load(__m); });
      }



      inline __attribute__((__always_inline__)) void
      notify_one() noexcept
      { std::__atomic_notify_address(&_M_i, false); }



      inline __attribute__((__always_inline__)) void
      notify_all() noexcept
      { std::__atomic_notify_address(&_M_i, true); }




      inline __attribute__((__always_inline__)) __int_type
      fetch_add(__int_type __i,
  memory_order __m = memory_order_seq_cst) noexcept
      { return __atomic_fetch_add(&_M_i, __i, int(__m)); }

      inline __attribute__((__always_inline__)) __int_type
      fetch_add(__int_type __i,
  memory_order __m = memory_order_seq_cst) volatile noexcept
      { return __atomic_fetch_add(&_M_i, __i, int(__m)); }

      inline __attribute__((__always_inline__)) __int_type
      fetch_sub(__int_type __i,
  memory_order __m = memory_order_seq_cst) noexcept
      { return __atomic_fetch_sub(&_M_i, __i, int(__m)); }

      inline __attribute__((__always_inline__)) __int_type
      fetch_sub(__int_type __i,
  memory_order __m = memory_order_seq_cst) volatile noexcept
      { return __atomic_fetch_sub(&_M_i, __i, int(__m)); }

      inline __attribute__((__always_inline__)) __int_type
      fetch_and(__int_type __i,
  memory_order __m = memory_order_seq_cst) noexcept
      { return __atomic_fetch_and(&_M_i, __i, int(__m)); }

      inline __attribute__((__always_inline__)) __int_type
      fetch_and(__int_type __i,
  memory_order __m = memory_order_seq_cst) volatile noexcept
      { return __atomic_fetch_and(&_M_i, __i, int(__m)); }

      inline __attribute__((__always_inline__)) __int_type
      fetch_or(__int_type __i,
        memory_order __m = memory_order_seq_cst) noexcept
      { return __atomic_fetch_or(&_M_i, __i, int(__m)); }

      inline __attribute__((__always_inline__)) __int_type
      fetch_or(__int_type __i,
        memory_order __m = memory_order_seq_cst) volatile noexcept
      { return __atomic_fetch_or(&_M_i, __i, int(__m)); }

      inline __attribute__((__always_inline__)) __int_type
      fetch_xor(__int_type __i,
  memory_order __m = memory_order_seq_cst) noexcept
      { return __atomic_fetch_xor(&_M_i, __i, int(__m)); }

      inline __attribute__((__always_inline__)) __int_type
      fetch_xor(__int_type __i,
  memory_order __m = memory_order_seq_cst) volatile noexcept
      { return __atomic_fetch_xor(&_M_i, __i, int(__m)); }
    };



  template<typename _PTp>
    struct __atomic_base<_PTp*>
    {
    private:
      typedef _PTp* __pointer_type;

      __pointer_type _M_p = 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<void *>(-__alignof(_M_p)));
      }

      bool
      is_lock_free() const volatile noexcept
      {

 return __atomic_is_lock_free(sizeof(_M_p),
     reinterpret_cast<void *>(-__alignof(_M_p)));
      }

      inline __attribute__((__always_inline__)) void
      store(__pointer_type __p,
     memory_order __m = memory_order_seq_cst) noexcept
      {
 memory_order __b __attribute__ ((__unused__))
   = __m & __memory_order_mask;

 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__b != memory_order_acquire), false)) std::__glibcxx_assert_fail(); } while (false);
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__b != memory_order_acq_rel), false)) std::__glibcxx_assert_fail(); } while (false);
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__b != memory_order_consume), false)) std::__glibcxx_assert_fail(); } while (false);

 __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 __attribute__ ((__unused__))
   = __m & __memory_order_mask;
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__b != memory_order_acquire), false)) std::__glibcxx_assert_fail(); } while (false);
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__b != memory_order_acq_rel), false)) std::__glibcxx_assert_fail(); } while (false);
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__b != memory_order_consume), false)) std::__glibcxx_assert_fail(); } while (false);

 __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 __attribute__ ((__unused__))
   = __m & __memory_order_mask;
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__b != memory_order_release), false)) std::__glibcxx_assert_fail(); } while (false);
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__b != memory_order_acq_rel), false)) std::__glibcxx_assert_fail(); } while (false);

 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 __attribute__ ((__unused__))
   = __m & __memory_order_mask;
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__b != memory_order_release), false)) std::__glibcxx_assert_fail(); } while (false);
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__b != memory_order_acq_rel), false)) std::__glibcxx_assert_fail(); } while (false);

 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_weak(__pointer_type& __p1, __pointer_type __p2,
       memory_order __m1,
       memory_order __m2) noexcept
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__is_valid_cmpexch_failure_order(__m2)), false)) std::__glibcxx_assert_fail(); } while (false);

 return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 1,
        int(__m1), int(__m2));
      }

      inline __attribute__((__always_inline__)) bool
      compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
       memory_order __m1,
       memory_order __m2) volatile noexcept
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__is_valid_cmpexch_failure_order(__m2)), false)) std::__glibcxx_assert_fail(); } while (false);

 return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 1,
        int(__m1), int(__m2));
      }

      inline __attribute__((__always_inline__)) bool
      compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2,
         memory_order __m1,
         memory_order __m2) noexcept
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__is_valid_cmpexch_failure_order(__m2)), false)) std::__glibcxx_assert_fail(); } while (false);

 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
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__is_valid_cmpexch_failure_order(__m2)), false)) std::__glibcxx_assert_fail(); } while (false);

 return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0,
        int(__m1), int(__m2));
      }


      inline __attribute__((__always_inline__)) void
      wait(__pointer_type __old,
    memory_order __m = memory_order_seq_cst) const noexcept
      {
 std::__atomic_wait_address_v(&_M_p, __old,
         [__m, this]
         { return this->load(__m); });
      }



      inline __attribute__((__always_inline__)) void
      notify_one() const noexcept
      { std::__atomic_notify_address(&_M_p, false); }



      inline __attribute__((__always_inline__)) void
      notify_all() const noexcept
      { std::__atomic_notify_address(&_M_p, true); }




      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<typename _Tp>
      constexpr bool
      __maybe_has_padding()
      {

 return false;






      }

    template<typename _Tp>
      inline __attribute__((__always_inline__)) _Tp*
      __clear_padding(_Tp& __val) noexcept
      {
 auto* __ptr = std::__addressof(__val);




 return __ptr;
      }


    template<typename _Tp>
      using _Val = typename remove_volatile<_Tp>::type;

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++17-extensions"

    template<bool _AtomicRef = false, typename _Tp>
      inline __attribute__((__always_inline__)) bool
      __compare_exchange(_Tp& __val, _Val<_Tp>& __e, _Val<_Tp>& __i,
    bool __is_weak,
    memory_order __s, memory_order __f) noexcept
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__is_valid_cmpexch_failure_order(__f)), false)) std::__glibcxx_assert_fail(); } while (false);

 using _Vp = _Val<_Tp>;
 _Tp* const __pval = std::__addressof(__val);

 if constexpr (!__atomic_impl::__maybe_has_padding<_Vp>())
   {
     return __atomic_compare_exchange(__pval, std::__addressof(__e),
          std::__addressof(__i), __is_weak,
          int(__s), int(__f));
   }
 else if constexpr (!_AtomicRef)
   {

     _Vp* const __pi = __atomic_impl::__clear_padding(__i);

     _Vp __exp = __e;

     _Vp* const __pexp = __atomic_impl::__clear_padding(__exp);



     if (__atomic_compare_exchange(__pval, __pexp, __pi,
       __is_weak, int(__s), int(__f)))
       return true;

     __builtin_memcpy(std::__addressof(__e), __pexp, sizeof(_Vp));
     return false;
   }
 else
   {

     _Vp* const __pi = __atomic_impl::__clear_padding(__i);


     _Vp __exp = __e;


     _Vp* const __pexp = __atomic_impl::__clear_padding(__exp);
# 1045 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/atomic_base.h" 3
     while (true)
       {

  _Vp __orig = __exp;

  if (__atomic_compare_exchange(__pval, __pexp, __pi,
           __is_weak, int(__s), int(__f)))
    return true;


  _Vp __curr = __exp;


  if (__builtin_memcmp(__atomic_impl::__clear_padding(__orig),
         __atomic_impl::__clear_padding(__curr),
         sizeof(_Vp)))
    {

      __builtin_memcpy(std::__addressof(__e), __pexp,
         sizeof(_Vp));
      return false;
    }
       }
   }
      }
#pragma GCC diagnostic pop
  }



  namespace __atomic_impl
  {

    template<typename _Tp>
      using _Diff = __conditional_t<is_pointer_v<_Tp>, ptrdiff_t, _Val<_Tp>>;

    template<size_t _Size, size_t _Align>
      inline __attribute__((__always_inline__)) bool
      is_lock_free() noexcept
      {

 return __atomic_is_lock_free(_Size, reinterpret_cast<void *>(-_Align));
      }

    template<typename _Tp>
      inline __attribute__((__always_inline__)) void
      store(_Tp* __ptr, _Val<_Tp> __t, memory_order __m) noexcept
      {
 __atomic_store(__ptr, __atomic_impl::__clear_padding(__t), int(__m));
      }

    template<typename _Tp>
      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<typename _Tp>
      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, __atomic_impl::__clear_padding(__desired),
     __dest, int(__m));
 return *__dest;
      }

    template<bool _AtomicRef = false, typename _Tp>
      inline __attribute__((__always_inline__)) bool
      compare_exchange_weak(_Tp* __ptr, _Val<_Tp>& __expected,
       _Val<_Tp> __desired, memory_order __success,
       memory_order __failure,
       bool __check_padding = false) noexcept
      {
 return __atomic_impl::__compare_exchange<_AtomicRef>(
     *__ptr, __expected, __desired, true, __success, __failure);
      }

    template<bool _AtomicRef = false, typename _Tp>
      inline __attribute__((__always_inline__)) bool
      compare_exchange_strong(_Tp* __ptr, _Val<_Tp>& __expected,
         _Val<_Tp> __desired, memory_order __success,
         memory_order __failure,
         bool __ignore_padding = false) noexcept
      {
 return __atomic_impl::__compare_exchange<_AtomicRef>(
     *__ptr, __expected, __desired, false, __success, __failure);
      }


    template<typename _Tp>
      inline __attribute__((__always_inline__)) void
      wait(const _Tp* __ptr, _Val<_Tp> __old,
    memory_order __m = memory_order_seq_cst) noexcept
      {
 std::__atomic_wait_address_v(__ptr, __old,
     [__ptr, __m]() { return __atomic_impl::load(__ptr, __m); });
      }



    template<typename _Tp>
      inline __attribute__((__always_inline__)) void
      notify_one(const _Tp* __ptr) noexcept
      { std::__atomic_notify_address(__ptr, false); }



    template<typename _Tp>
      inline __attribute__((__always_inline__)) void
      notify_all(const _Tp* __ptr) noexcept
      { std::__atomic_notify_address(__ptr, true); }




    template<typename _Tp>
      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<typename _Tp>
      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<typename _Tp>
      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<typename _Tp>
      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<typename _Tp>
      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<typename _Tp>
      inline __attribute__((__always_inline__)) _Tp
      __add_fetch(_Tp* __ptr, _Diff<_Tp> __i) noexcept
      { return __atomic_add_fetch(__ptr, __i, 5); }

    template<typename _Tp>
      inline __attribute__((__always_inline__)) _Tp
      __sub_fetch(_Tp* __ptr, _Diff<_Tp> __i) noexcept
      { return __atomic_sub_fetch(__ptr, __i, 5); }

    template<typename _Tp>
      inline __attribute__((__always_inline__)) _Tp
      __and_fetch(_Tp* __ptr, _Val<_Tp> __i) noexcept
      { return __atomic_and_fetch(__ptr, __i, 5); }

    template<typename _Tp>
      inline __attribute__((__always_inline__)) _Tp
      __or_fetch(_Tp* __ptr, _Val<_Tp> __i) noexcept
      { return __atomic_or_fetch(__ptr, __i, 5); }

    template<typename _Tp>
      inline __attribute__((__always_inline__)) _Tp
      __xor_fetch(_Tp* __ptr, _Val<_Tp> __i) noexcept
      { return __atomic_xor_fetch(__ptr, __i, 5); }

    template<typename _Tp>
      _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<typename _Tp>
      _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<typename _Tp>
      _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<typename _Tp>
      _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<typename _Fp>
    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_impl::__clear_padding(_M_fp); }

      __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<sizeof(_Fp), _S_alignment>(); }

      bool
      is_lock_free() const noexcept
      { return __atomic_impl::is_lock_free<sizeof(_Fp), _S_alignment>(); }

      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));
      }


      inline __attribute__((__always_inline__)) void
      wait(_Fp __old, memory_order __m = memory_order_seq_cst) const noexcept
      { __atomic_impl::wait(&_M_fp, __old, __m); }



      inline __attribute__((__always_inline__)) void
      notify_one() const noexcept
      { __atomic_impl::notify_one(&_M_fp); }



      inline __attribute__((__always_inline__)) void
      notify_all() const noexcept
      { __atomic_impl::notify_all(&_M_fp); }




      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<typename _Tp,
    bool = is_integral_v<_Tp>, bool = is_floating_point_v<_Tp>>
    struct __atomic_ref;


  template<typename _Tp>
    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))
      { do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(((uintptr_t)_M_ptr % required_alignment) == 0), false)) std::__glibcxx_assert_fail(); } while (false); }

      __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<sizeof(_Tp), required_alignment>(); }

      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<true>(
   _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<true>(
   _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__)) void
      wait(_Tp __old, memory_order __m = memory_order_seq_cst) const noexcept
      { __atomic_impl::wait(_M_ptr, __old, __m); }



      inline __attribute__((__always_inline__)) void
      notify_one() const noexcept
      { __atomic_impl::notify_one(_M_ptr); }



      inline __attribute__((__always_inline__)) void
      notify_all() const noexcept
      { __atomic_impl::notify_all(_M_ptr); }




    private:
      _Tp* _M_ptr;
    };


  template<typename _Tp>
    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)
      { do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(((uintptr_t)_M_ptr % required_alignment) == 0), false)) std::__glibcxx_assert_fail(); } while (false); }

      __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<sizeof(_Tp), required_alignment>();
      }

      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<true>(
   _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<true>(
   _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__)) void
      wait(_Tp __old, memory_order __m = memory_order_seq_cst) const noexcept
      { __atomic_impl::wait(_M_ptr, __old, __m); }



      inline __attribute__((__always_inline__)) void
      notify_one() const noexcept
      { __atomic_impl::notify_one(_M_ptr); }



      inline __attribute__((__always_inline__)) void
      notify_all() const noexcept
      { __atomic_impl::notify_all(_M_ptr); }




      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<typename _Fp>
    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)
      { do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(((uintptr_t)_M_ptr % required_alignment) == 0), false)) std::__glibcxx_assert_fail(); } while (false); }

      __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<sizeof(_Fp), required_alignment>();
      }

      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<true>(
   _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<true>(
   _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));
      }


      inline __attribute__((__always_inline__)) void
      wait(_Fp __old, memory_order __m = memory_order_seq_cst) const noexcept
      { __atomic_impl::wait(_M_ptr, __old, __m); }



      inline __attribute__((__always_inline__)) void
      notify_one() const noexcept
      { __atomic_impl::notify_one(_M_ptr); }



      inline __attribute__((__always_inline__)) void
      notify_all() const noexcept
      { __atomic_impl::notify_all(_M_ptr); }




      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<typename _Tp>
    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))
      { do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(((uintptr_t)_M_ptr % required_alignment) == 0), false)) std::__glibcxx_assert_fail(); } while (false); }

      __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<sizeof(_Tp*), required_alignment>();
      }

      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<true>(
   _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<true>(
   _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__)) void
      wait(_Tp* __old, memory_order __m = memory_order_seq_cst) const noexcept
      { __atomic_impl::wait(_M_ptr, __old, __m); }



      inline __attribute__((__always_inline__)) void
      notify_one() const noexcept
      { __atomic_impl::notify_one(_M_ptr); }



      inline __attribute__((__always_inline__)) void
      notify_all() const noexcept
      { __atomic_impl::notify_all(_M_ptr); }




      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/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/shared_ptr_atomic.h" 2 3
# 62 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/shared_ptr_atomic.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 74 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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;



  };
# 101 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/shared_ptr_atomic.h" 3
  template<typename _Tp, _Lock_policy _Lp>
    __attribute__ ((__deprecated__ ("use '" "std::atomic<std::shared_ptr<T>>" "' instead")))
    inline bool
    atomic_is_lock_free(const __shared_ptr<_Tp, _Lp>*)
    {

      return __gthread_active_p() == 0;



    }

  template<typename _Tp>
    __attribute__ ((__deprecated__ ("use '" "std::atomic<std::shared_ptr<T>>" "' instead")))
    inline bool
    atomic_is_lock_free(const shared_ptr<_Tp>* __p)
    { return std::atomic_is_lock_free<_Tp, __default_lock_policy>(__p); }
# 130 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/shared_ptr_atomic.h" 3
  template<typename _Tp>
    __attribute__ ((__deprecated__ ("use '" "std::atomic<std::shared_ptr<T>>" "' instead")))
    inline shared_ptr<_Tp>
    atomic_load_explicit(const shared_ptr<_Tp>* __p, memory_order)
    {
      _Sp_locker __lock{__p};
      return *__p;
    }

  template<typename _Tp>
    __attribute__ ((__deprecated__ ("use '" "std::atomic<std::shared_ptr<T>>" "' instead")))
    inline shared_ptr<_Tp>
    atomic_load(const shared_ptr<_Tp>* __p)
    { return std::atomic_load_explicit(__p, memory_order_seq_cst); }

  template<typename _Tp, _Lock_policy _Lp>
    __attribute__ ((__deprecated__ ("use '" "std::atomic<std::shared_ptr<T>>" "' instead")))
    inline __shared_ptr<_Tp, _Lp>
    atomic_load_explicit(const __shared_ptr<_Tp, _Lp>* __p, memory_order)
    {
      _Sp_locker __lock{__p};
      return *__p;
    }

  template<typename _Tp, _Lock_policy _Lp>
    __attribute__ ((__deprecated__ ("use '" "std::atomic<std::shared_ptr<T>>" "' instead")))
    inline __shared_ptr<_Tp, _Lp>
    atomic_load(const __shared_ptr<_Tp, _Lp>* __p)
    { return std::atomic_load_explicit(__p, memory_order_seq_cst); }
# 170 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/shared_ptr_atomic.h" 3
  template<typename _Tp>
    __attribute__ ((__deprecated__ ("use '" "std::atomic<std::shared_ptr<T>>" "' instead")))
    inline void
    atomic_store_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r,
     memory_order)
    {
      _Sp_locker __lock{__p};
      __p->swap(__r);
    }

  template<typename _Tp>
    __attribute__ ((__deprecated__ ("use '" "std::atomic<std::shared_ptr<T>>" "' instead")))
    inline void
    atomic_store(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r)
    { std::atomic_store_explicit(__p, std::move(__r), memory_order_seq_cst); }

  template<typename _Tp, _Lock_policy _Lp>
    __attribute__ ((__deprecated__ ("use '" "std::atomic<std::shared_ptr<T>>" "' instead")))
    inline void
    atomic_store_explicit(__shared_ptr<_Tp, _Lp>* __p,
     __shared_ptr<_Tp, _Lp> __r,
     memory_order)
    {
      _Sp_locker __lock{__p};
      __p->swap(__r);
    }

  template<typename _Tp, _Lock_policy _Lp>
    __attribute__ ((__deprecated__ ("use '" "std::atomic<std::shared_ptr<T>>" "' instead")))
    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); }
# 211 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/shared_ptr_atomic.h" 3
  template<typename _Tp>
    __attribute__ ((__deprecated__ ("use '" "std::atomic<std::shared_ptr<T>>" "' instead")))
    inline shared_ptr<_Tp>
    atomic_exchange_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r,
        memory_order)
    {
      _Sp_locker __lock{__p};
      __p->swap(__r);
      return __r;
    }

  template<typename _Tp>
    __attribute__ ((__deprecated__ ("use '" "std::atomic<std::shared_ptr<T>>" "' instead")))
    inline shared_ptr<_Tp>
    atomic_exchange(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r)
    {
      return std::atomic_exchange_explicit(__p, std::move(__r),
        memory_order_seq_cst);
    }

  template<typename _Tp, _Lock_policy _Lp>
    __attribute__ ((__deprecated__ ("use '" "std::atomic<std::shared_ptr<T>>" "' instead")))
    inline __shared_ptr<_Tp, _Lp>
    atomic_exchange_explicit(__shared_ptr<_Tp, _Lp>* __p,
        __shared_ptr<_Tp, _Lp> __r,
        memory_order)
    {
      _Sp_locker __lock{__p};
      __p->swap(__r);
      return __r;
    }

  template<typename _Tp, _Lock_policy _Lp>
    __attribute__ ((__deprecated__ ("use '" "std::atomic<std::shared_ptr<T>>" "' instead")))
    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);
    }
# 264 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/shared_ptr_atomic.h" 3
  template<typename _Tp>
    __attribute__ ((__deprecated__ ("use '" "std::atomic<std::shared_ptr<T>>" "' instead")))
    bool
    atomic_compare_exchange_strong_explicit(shared_ptr<_Tp>* __p,
         shared_ptr<_Tp>* __v,
         shared_ptr<_Tp> __w,
         memory_order,
         memory_order)
    {
      shared_ptr<_Tp> __x;
      _Sp_locker __lock{__p, __v};
      owner_less<shared_ptr<_Tp>> __less;
      if (*__p == *__v && !__less(*__p, *__v) && !__less(*__v, *__p))
 {
   __x = std::move(*__p);
   *__p = std::move(__w);
   return true;
 }
      __x = std::move(*__v);
      *__v = *__p;
      return false;
    }

  template<typename _Tp>
    __attribute__ ((__deprecated__ ("use '" "std::atomic<std::shared_ptr<T>>" "' instead")))
    inline bool
    atomic_compare_exchange_strong(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v,
     shared_ptr<_Tp> __w)
    {
      return std::atomic_compare_exchange_strong_explicit(__p, __v,
   std::move(__w), memory_order_seq_cst, memory_order_seq_cst);
    }

  template<typename _Tp>
    __attribute__ ((__deprecated__ ("use '" "std::atomic<std::shared_ptr<T>>" "' instead")))
    inline bool
    atomic_compare_exchange_weak_explicit(shared_ptr<_Tp>* __p,
       shared_ptr<_Tp>* __v,
       shared_ptr<_Tp> __w,
       memory_order __success,
       memory_order __failure)
    {
      return std::atomic_compare_exchange_strong_explicit(__p, __v,
   std::move(__w), __success, __failure);
    }

  template<typename _Tp>
    __attribute__ ((__deprecated__ ("use '" "std::atomic<std::shared_ptr<T>>" "' instead")))
    inline bool
    atomic_compare_exchange_weak(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v,
     shared_ptr<_Tp> __w)
    {
      return std::atomic_compare_exchange_weak_explicit(__p, __v,
   std::move(__w), memory_order_seq_cst, memory_order_seq_cst);
    }

  template<typename _Tp, _Lock_policy _Lp>
    __attribute__ ((__deprecated__ ("use '" "std::atomic<std::shared_ptr<T>>" "' instead")))
    bool
    atomic_compare_exchange_strong_explicit(__shared_ptr<_Tp, _Lp>* __p,
         __shared_ptr<_Tp, _Lp>* __v,
         __shared_ptr<_Tp, _Lp> __w,
         memory_order,
         memory_order)
    {
      __shared_ptr<_Tp, _Lp> __x;
      _Sp_locker __lock{__p, __v};
      owner_less<__shared_ptr<_Tp, _Lp>> __less;
      if (*__p == *__v && !__less(*__p, *__v) && !__less(*__v, *__p))
 {
   __x = std::move(*__p);
   *__p = std::move(__w);
   return true;
 }
      __x = std::move(*__v);
      *__v = *__p;
      return false;
    }

  template<typename _Tp, _Lock_policy _Lp>
    __attribute__ ((__deprecated__ ("use '" "std::atomic<std::shared_ptr<T>>" "' instead")))
    inline bool
    atomic_compare_exchange_strong(__shared_ptr<_Tp, _Lp>* __p,
       __shared_ptr<_Tp, _Lp>* __v,
       __shared_ptr<_Tp, _Lp> __w)
    {
      return std::atomic_compare_exchange_strong_explicit(__p, __v,
   std::move(__w), memory_order_seq_cst, memory_order_seq_cst);
    }

  template<typename _Tp, _Lock_policy _Lp>
    __attribute__ ((__deprecated__ ("use '" "std::atomic<std::shared_ptr<T>>" "' instead")))
    inline bool
    atomic_compare_exchange_weak_explicit(__shared_ptr<_Tp, _Lp>* __p,
       __shared_ptr<_Tp, _Lp>* __v,
       __shared_ptr<_Tp, _Lp> __w,
       memory_order __success,
       memory_order __failure)
    {
      return std::atomic_compare_exchange_strong_explicit(__p, __v,
   std::move(__w), __success, __failure);
    }

  template<typename _Tp, _Lock_policy _Lp>
    __attribute__ ((__deprecated__ ("use '" "std::atomic<std::shared_ptr<T>>" "' instead")))
    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);
    }





  template<typename _Tp>
    struct atomic;







  template<typename _Tp>
    class _Sp_atomic
    {
      using value_type = _Tp;

      friend struct atomic<_Tp>;



      struct _Atomic_count
      {

 using __count_type = decltype(_Tp::_M_refcount);


 using pointer = decltype(__count_type::_M_pi);


 static_assert(alignof(remove_pointer_t<pointer>) > 1);

 constexpr _Atomic_count() noexcept = default;

 explicit
 _Atomic_count(__count_type&& __c) noexcept
 : _M_val(reinterpret_cast<uintptr_t>(__c._M_pi))
 {
   __c._M_pi = nullptr;
 }

 ~_Atomic_count()
 {
   auto __val = _M_val.load(memory_order_relaxed);
                                       ;
   do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(!(__val & _S_lock_bit)), false)) std::__glibcxx_assert_fail(); } while (false);
   if (auto __pi = reinterpret_cast<pointer>(__val))
     {
       if constexpr (__is_shared_ptr<_Tp>)
  __pi->_M_release();
       else
  __pi->_M_weak_release();
     }
 }

 _Atomic_count(const _Atomic_count&) = delete;
 _Atomic_count& operator=(const _Atomic_count&) = delete;



 pointer
 lock(memory_order __o) const noexcept
 {


   auto __current = _M_val.load(memory_order_relaxed);
   while (__current & _S_lock_bit)
     {

       __detail::__thread_relax();

       __current = _M_val.load(memory_order_relaxed);
     }

                                        ;

   while (!_M_val.compare_exchange_strong(__current,
       __current | _S_lock_bit,
       __o,
       memory_order_relaxed))
     {
                                                   ;

       __detail::__thread_relax();

       __current = __current & ~_S_lock_bit;
                                            ;
     }
                                      ;
   return reinterpret_cast<pointer>(__current);
 }


 void
 unlock(memory_order __o) const noexcept
 {
                                          ;
   _M_val.fetch_sub(1, __o);
                                           ;
 }



 void
 _M_swap_unlock(__count_type& __c, memory_order __o) noexcept
 {
   if (__o != memory_order_seq_cst)
     __o = memory_order_release;
   auto __x = reinterpret_cast<uintptr_t>(__c._M_pi);
                                          ;
   __x = _M_val.exchange(__x, __o);
                                           ;
   __c._M_pi = reinterpret_cast<pointer>(__x & ~_S_lock_bit);
 }



 void
 _M_wait_unlock(memory_order __o) const noexcept
 {
                                          ;
   auto __v = _M_val.fetch_sub(1, memory_order_relaxed);
                                           ;
   _M_val.wait(__v & ~_S_lock_bit, __o);
 }

 void
 notify_one() noexcept
 {
                                          ;
   _M_val.notify_one();
                                           ;
 }

 void
 notify_all() noexcept
 {
                                          ;
   _M_val.notify_all();
                                           ;
 }


      private:
 mutable __atomic_base<uintptr_t> _M_val{0};
 static constexpr uintptr_t _S_lock_bit{1};
      };

      typename _Tp::element_type* _M_ptr = nullptr;
      _Atomic_count _M_refcount;

      static typename _Atomic_count::pointer
      _S_add_ref(typename _Atomic_count::pointer __p)
      {
 if (__p)
   {
     if constexpr (__is_shared_ptr<_Tp>)
       __p->_M_add_ref_copy();
     else
       __p->_M_weak_add_ref();
   }
 return __p;
      }

      constexpr _Sp_atomic() noexcept = default;

      explicit
      _Sp_atomic(value_type __r) noexcept
      : _M_ptr(__r._M_ptr), _M_refcount(std::move(__r._M_refcount))
      { }

      ~_Sp_atomic() = default;

      _Sp_atomic(const _Sp_atomic&) = delete;
      void operator=(const _Sp_atomic&) = delete;

      value_type
      load(memory_order __o) const noexcept
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__o != memory_order_release && __o != memory_order_acq_rel), false)) std::__glibcxx_assert_fail(); } while (false);



 if (__o != memory_order_seq_cst)
   __o = memory_order_acquire;

 value_type __ret;
 auto __pi = _M_refcount.lock(__o);
 __ret._M_ptr = _M_ptr;
 __ret._M_refcount._M_pi = _S_add_ref(__pi);
 _M_refcount.unlock(memory_order_relaxed);
 return __ret;
      }

      void
      swap(value_type& __r, memory_order __o) noexcept
      {
 _M_refcount.lock(memory_order_acquire);
 std::swap(_M_ptr, __r._M_ptr);
 _M_refcount._M_swap_unlock(__r._M_refcount, __o);
      }

      bool
      compare_exchange_strong(value_type& __expected, value_type __desired,
         memory_order __o, memory_order __o2) noexcept
      {
 bool __result = true;
 auto __pi = _M_refcount.lock(memory_order_acquire);
 if (_M_ptr == __expected._M_ptr
       && __pi == __expected._M_refcount._M_pi)
   {
     _M_ptr = __desired._M_ptr;
     _M_refcount._M_swap_unlock(__desired._M_refcount, __o);
   }
 else
   {
     _Tp __sink = std::move(__expected);
     __expected._M_ptr = _M_ptr;
     __expected._M_refcount._M_pi = _S_add_ref(__pi);
     _M_refcount.unlock(__o2);
     __result = false;
   }
 return __result;
      }


      void
      wait(value_type __old, memory_order __o) const noexcept
      {
 auto __pi = _M_refcount.lock(memory_order_acquire);
 if (_M_ptr == __old._M_ptr && __pi == __old._M_refcount._M_pi)
   _M_refcount._M_wait_unlock(__o);
 else
   _M_refcount.unlock(memory_order_relaxed);
      }

      void
      notify_one() noexcept
      {
 _M_refcount.notify_one();
      }

      void
      notify_all() noexcept
      {
 _M_refcount.notify_all();
      }

    };

  template<typename _Tp>
    struct atomic<shared_ptr<_Tp>>
    {
    public:
      using value_type = shared_ptr<_Tp>;

      static constexpr bool is_always_lock_free = false;

      bool
      is_lock_free() const noexcept
      { return false; }

      constexpr atomic() noexcept = default;



      constexpr atomic(nullptr_t) noexcept : atomic() { }

      atomic(shared_ptr<_Tp> __r) noexcept
      : _M_impl(std::move(__r))
      { }

      atomic(const atomic&) = delete;
      void operator=(const atomic&) = delete;

      shared_ptr<_Tp>
      load(memory_order __o = memory_order_seq_cst) const noexcept
      { return _M_impl.load(__o); }

      operator shared_ptr<_Tp>() const noexcept
      { return _M_impl.load(memory_order_seq_cst); }

      void
      store(shared_ptr<_Tp> __desired,
     memory_order __o = memory_order_seq_cst) noexcept
      { _M_impl.swap(__desired, __o); }

      void
      operator=(shared_ptr<_Tp> __desired) noexcept
      { _M_impl.swap(__desired, memory_order_seq_cst); }



      void
      operator=(nullptr_t) noexcept
      { store(nullptr); }

      shared_ptr<_Tp>
      exchange(shared_ptr<_Tp> __desired,
        memory_order __o = memory_order_seq_cst) noexcept
      {
 _M_impl.swap(__desired, __o);
 return __desired;
      }

      bool
      compare_exchange_strong(shared_ptr<_Tp>& __expected,
         shared_ptr<_Tp> __desired,
         memory_order __o, memory_order __o2) noexcept
      {
 return _M_impl.compare_exchange_strong(__expected, __desired, __o, __o2);
      }

      bool
      compare_exchange_strong(value_type& __expected, value_type __desired,
         memory_order __o = memory_order_seq_cst) noexcept
      {
 memory_order __o2;
 switch (__o)
 {
 case memory_order_acq_rel:
   __o2 = memory_order_acquire;
   break;
 case memory_order_release:
   __o2 = memory_order_relaxed;
   break;
 default:
   __o2 = __o;
 }
 return compare_exchange_strong(__expected, std::move(__desired),
           __o, __o2);
      }

      bool
      compare_exchange_weak(value_type& __expected, value_type __desired,
       memory_order __o, memory_order __o2) noexcept
      {
 return compare_exchange_strong(__expected, std::move(__desired),
           __o, __o2);
      }

      bool
      compare_exchange_weak(value_type& __expected, value_type __desired,
       memory_order __o = memory_order_seq_cst) noexcept
      {
 return compare_exchange_strong(__expected, std::move(__desired), __o);
      }


      void
      wait(value_type __old,
    memory_order __o = memory_order_seq_cst) const noexcept
      {
 _M_impl.wait(std::move(__old), __o);
      }

      void
      notify_one() noexcept
      {
 _M_impl.notify_one();
      }

      void
      notify_all() noexcept
      {
 _M_impl.notify_all();
      }


    private:
      _Sp_atomic<shared_ptr<_Tp>> _M_impl;
    };

  template<typename _Tp>
    struct atomic<weak_ptr<_Tp>>
    {
    public:
      using value_type = weak_ptr<_Tp>;

      static constexpr bool is_always_lock_free = false;

      bool
      is_lock_free() const noexcept
      { return false; }

      constexpr atomic() noexcept = default;

      atomic(weak_ptr<_Tp> __r) noexcept
     : _M_impl(move(__r))
      { }

      atomic(const atomic&) = delete;
      void operator=(const atomic&) = delete;

      weak_ptr<_Tp>
      load(memory_order __o = memory_order_seq_cst) const noexcept
      { return _M_impl.load(__o); }

      operator weak_ptr<_Tp>() const noexcept
      { return _M_impl.load(memory_order_seq_cst); }

      void
      store(weak_ptr<_Tp> __desired,
     memory_order __o = memory_order_seq_cst) noexcept
      { _M_impl.swap(__desired, __o); }

      void
      operator=(weak_ptr<_Tp> __desired) noexcept
      { _M_impl.swap(__desired, memory_order_seq_cst); }

      weak_ptr<_Tp>
      exchange(weak_ptr<_Tp> __desired,
        memory_order __o = memory_order_seq_cst) noexcept
      {
 _M_impl.swap(__desired, __o);
 return __desired;
      }

      bool
      compare_exchange_strong(weak_ptr<_Tp>& __expected,
         weak_ptr<_Tp> __desired,
         memory_order __o, memory_order __o2) noexcept
      {
 return _M_impl.compare_exchange_strong(__expected, __desired, __o, __o2);
      }

      bool
      compare_exchange_strong(value_type& __expected, value_type __desired,
         memory_order __o = memory_order_seq_cst) noexcept
      {
 memory_order __o2;
 switch (__o)
 {
 case memory_order_acq_rel:
   __o2 = memory_order_acquire;
   break;
 case memory_order_release:
   __o2 = memory_order_relaxed;
   break;
 default:
   __o2 = __o;
 }
 return compare_exchange_strong(__expected, std::move(__desired),
           __o, __o2);
      }

      bool
      compare_exchange_weak(value_type& __expected, value_type __desired,
       memory_order __o, memory_order __o2) noexcept
      {
 return compare_exchange_strong(__expected, std::move(__desired),
           __o, __o2);
      }

      bool
      compare_exchange_weak(value_type& __expected, value_type __desired,
       memory_order __o = memory_order_seq_cst) noexcept
      {
 return compare_exchange_strong(__expected, std::move(__desired), __o);
      }


      void
      wait(value_type __old,
    memory_order __o = memory_order_seq_cst) const noexcept
      {
 _M_impl.wait(std::move(__old), __o);
      }

      void
      notify_one() noexcept
      {
 _M_impl.notify_one();
      }

      void
      notify_all() noexcept
      {
 _M_impl.notify_all();
      }


    private:
      _Sp_atomic<weak_ptr<_Tp>> _M_impl;
    };




}
# 82 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/memory" 2 3




# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/backward/auto_ptr.h" 1 3
# 36 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/backward/auto_ptr.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 47 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/backward/auto_ptr.h" 3
  template<typename _Tp1>
    struct auto_ptr_ref
    {
      _Tp1* _M_ptr;

      explicit
      auto_ptr_ref(_Tp1* __p): _M_ptr(__p) { }
    } __attribute__ ((__deprecated__));

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
# 92 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/backward/auto_ptr.h" 3
  template<typename _Tp>
    class auto_ptr
    {
    private:
      _Tp* _M_ptr;

    public:

      typedef _Tp element_type;







      explicit
      auto_ptr(element_type* __p = 0) throw() : _M_ptr(__p) { }
# 118 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/backward/auto_ptr.h" 3
      auto_ptr(auto_ptr& __a) throw() : _M_ptr(__a.release()) { }
# 130 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/backward/auto_ptr.h" 3
      template<typename _Tp1>
        auto_ptr(auto_ptr<_Tp1>& __a) throw() : _M_ptr(__a.release()) { }
# 141 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/backward/auto_ptr.h" 3
      auto_ptr&
      operator=(auto_ptr& __a) throw()
      {
 reset(__a.release());
 return *this;
      }
# 158 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/backward/auto_ptr.h" 3
      template<typename _Tp1>
        auto_ptr&
        operator=(auto_ptr<_Tp1>& __a) throw()
        {
   reset(__a.release());
   return *this;
 }
# 176 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/backward/auto_ptr.h" 3
      ~auto_ptr() { delete _M_ptr; }
# 186 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/backward/auto_ptr.h" 3
      element_type&
      operator*() const throw()
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(_M_ptr != 0), false)) std::__glibcxx_assert_fail(); } while (false);
 return *_M_ptr;
      }







      element_type*
      operator->() const throw()
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(_M_ptr != 0), false)) std::__glibcxx_assert_fail(); } while (false);
 return _M_ptr;
      }
# 216 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/backward/auto_ptr.h" 3
      element_type*
      get() const throw() { return _M_ptr; }
# 230 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/backward/auto_ptr.h" 3
      element_type*
      release() throw()
      {
 element_type* __tmp = _M_ptr;
 _M_ptr = 0;
 return __tmp;
      }
# 245 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/backward/auto_ptr.h" 3
      void
      reset(element_type* __p = 0) throw()
      {
 if (__p != _M_ptr)
   {
     delete _M_ptr;
     _M_ptr = __p;
   }
      }
# 270 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/backward/auto_ptr.h" 3
      auto_ptr(auto_ptr_ref<element_type> __ref) throw()
      : _M_ptr(__ref._M_ptr) { }

      auto_ptr&
      operator=(auto_ptr_ref<element_type> __ref) throw()
      {
 if (__ref._M_ptr != this->get())
   {
     delete _M_ptr;
     _M_ptr = __ref._M_ptr;
   }
 return *this;
      }

      template<typename _Tp1>
        operator auto_ptr_ref<_Tp1>() throw()
        { return auto_ptr_ref<_Tp1>(this->release()); }

      template<typename _Tp1>
        operator auto_ptr<_Tp1>() throw()
        { return auto_ptr<_Tp1>(this->release()); }
    } __attribute__ ((__deprecated__ ("use '" "std::unique_ptr" "' instead")));



  template<>
    class auto_ptr<void>
    {
    public:
      typedef void element_type;
    } __attribute__ ((__deprecated__));



  template<_Lock_policy _Lp>
  template<typename _Tp>
    inline
    __shared_count<_Lp>::__shared_count(std::auto_ptr<_Tp>&& __r)
    : _M_pi(new _Sp_counted_ptr<_Tp*, _Lp>(__r.get()))
    { __r.release(); }

  template<typename _Tp, _Lock_policy _Lp>
  template<typename _Tp1, typename>
    inline
    __shared_ptr<_Tp, _Lp>::__shared_ptr(std::auto_ptr<_Tp1>&& __r)
    : _M_ptr(__r.get()), _M_refcount()
    {

      static_assert( sizeof(_Tp1) > 0, "incomplete type" );
      _Tp1* __tmp = __r.get();
      _M_refcount = __shared_count<_Lp>(std::move(__r));
      _M_enable_shared_from_this_with(__tmp);
    }

  template<typename _Tp>
  template<typename _Tp1, typename>
    inline
    shared_ptr<_Tp>::shared_ptr(std::auto_ptr<_Tp1>&& __r)
    : __shared_ptr<_Tp>(std::move(__r)) { }


  template<typename _Tp, typename _Dp>
  template<typename _Up, typename>
    inline
    unique_ptr<_Tp, _Dp>::unique_ptr(auto_ptr<_Up>&& __u) noexcept
    : _M_t(__u.release(), deleter_type()) { }


#pragma GCC diagnostic pop


}
# 87 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/memory" 2 3



# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ranges_uninitialized.h" 1 3
# 38 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ranges_uninitialized.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

namespace ranges
{
  namespace __detail
  {
    template<typename _Tp>
      constexpr void*
      __voidify(_Tp& __obj) noexcept
      {
 return const_cast<void*>
   (static_cast<const volatile void*>(std::__addressof(__obj)));
      }

    template<typename _Iter>
      concept __nothrow_input_iterator
 = (input_iterator<_Iter>
    && is_lvalue_reference_v<iter_reference_t<_Iter>>
    && same_as<remove_cvref_t<iter_reference_t<_Iter>>,
        iter_value_t<_Iter>>);

    template<typename _Sent, typename _Iter>
      concept __nothrow_sentinel = sentinel_for<_Sent, _Iter>;

    template<typename _Range>
      concept __nothrow_input_range
 = (range<_Range>
    && __nothrow_input_iterator<iterator_t<_Range>>
    && __nothrow_sentinel<sentinel_t<_Range>, iterator_t<_Range>>);

    template<typename _Iter>
      concept __nothrow_forward_iterator
 = (__nothrow_input_iterator<_Iter>
    && forward_iterator<_Iter>
    && __nothrow_sentinel<_Iter, _Iter>);

    template<typename _Range>
      concept __nothrow_forward_range
 = (__nothrow_input_range<_Range>
    && __nothrow_forward_iterator<iterator_t<_Range>>);
  }

  struct __destroy_fn
  {
    template<__detail::__nothrow_input_iterator _Iter,
      __detail::__nothrow_sentinel<_Iter> _Sent>
      requires destructible<iter_value_t<_Iter>>
      constexpr _Iter
      operator()(_Iter __first, _Sent __last) const noexcept;

    template<__detail::__nothrow_input_range _Range>
      requires destructible<range_value_t<_Range>>
      constexpr borrowed_iterator_t<_Range>
      operator()(_Range&& __r) const noexcept;
  };

  inline constexpr __destroy_fn destroy{};

  namespace __detail
  {
    template<typename _Iter>
      requires destructible<iter_value_t<_Iter>>
      struct _DestroyGuard
      {
      private:
 _Iter _M_first;
 const _Iter* _M_cur;

      public:
 explicit
 _DestroyGuard(const _Iter& __iter)
   : _M_first(__iter), _M_cur(std::__addressof(__iter))
 { }

 void
 release() noexcept
 { _M_cur = nullptr; }

 ~_DestroyGuard()
 {
   if (_M_cur != nullptr)
     ranges::destroy(std::move(_M_first), *_M_cur);
 }
      };

    template<typename _Iter>
      requires destructible<iter_value_t<_Iter>>
 && is_trivially_destructible_v<iter_value_t<_Iter>>
      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_value_t<_Iter>>
      _Iter
      operator()(_Iter __first, _Sent __last) const
      {
 using _ValueType = remove_reference_t<iter_reference_t<_Iter>>;
 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<range_value_t<_Range>>
      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_value_t<_Iter>>
      _Iter
      operator()(_Iter __first, iter_difference_t<_Iter> __n) const
      {
 using _ValueType = remove_reference_t<iter_reference_t<_Iter>>;
 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_value_t<_Iter>>
      _Iter
      operator()(_Iter __first, _Sent __last) const
      {
 using _ValueType = remove_reference_t<iter_reference_t<_Iter>>;
 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<range_value_t<_Range>>
      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_value_t<_Iter>>
      _Iter
      operator()(_Iter __first, iter_difference_t<_Iter> __n) const
      {
 using _ValueType = remove_reference_t<iter_reference_t<_Iter>>;
 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<typename _Iter, typename _Out>
    using uninitialized_copy_result = in_out_result<_Iter, _Out>;

  struct __uninitialized_copy_fn
  {
    template<input_iterator _Iter, sentinel_for<_Iter> _ISent,
      __detail::__nothrow_forward_iterator _Out,
      __detail::__nothrow_sentinel<_Out> _OSent>
      requires constructible_from<iter_value_t<_Out>, iter_reference_t<_Iter>>
      uninitialized_copy_result<_Iter, _Out>
      operator()(_Iter __ifirst, _ISent __ilast,
   _Out __ofirst, _OSent __olast) const
      {
 using _OutType = remove_reference_t<iter_reference_t<_Out>>;
 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<input_range _IRange, __detail::__nothrow_forward_range _ORange>
      requires constructible_from<range_value_t<_ORange>,
      range_reference_t<_IRange>>
      uninitialized_copy_result<borrowed_iterator_t<_IRange>,
    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<typename _Iter, typename _Out>
    using uninitialized_copy_n_result = in_out_result<_Iter, _Out>;

  struct __uninitialized_copy_n_fn
  {
    template<input_iterator _Iter, __detail::__nothrow_forward_iterator _Out,
      __detail::__nothrow_sentinel<_Out> _Sent>
      requires constructible_from<iter_value_t<_Out>, 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<iter_reference_t<_Out>>;
 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<typename _Iter, typename _Out>
    using uninitialized_move_result = in_out_result<_Iter, _Out>;

  struct __uninitialized_move_fn
  {
    template<input_iterator _Iter, sentinel_for<_Iter> _ISent,
      __detail::__nothrow_forward_iterator _Out,
      __detail::__nothrow_sentinel<_Out> _OSent>
      requires constructible_from<iter_value_t<_Out>,
      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<iter_reference_t<_Out>>;
 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<input_range _IRange, __detail::__nothrow_forward_range _ORange>
      requires constructible_from<range_value_t<_ORange>,
        range_rvalue_reference_t<_IRange>>
      uninitialized_move_result<borrowed_iterator_t<_IRange>,
    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<typename _Iter, typename _Out>
    using uninitialized_move_n_result = in_out_result<_Iter, _Out>;

  struct __uninitialized_move_n_fn
  {
    template<input_iterator _Iter, __detail::__nothrow_forward_iterator _Out,
      __detail::__nothrow_sentinel<_Out> _Sent>
 requires constructible_from<iter_value_t<_Out>,
        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<iter_reference_t<_Out>>;
 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<iter_value_t<_Iter>, const _Tp&>
      _Iter
      operator()(_Iter __first, _Sent __last, const _Tp& __x) const
      {
 using _ValueType = remove_reference_t<iter_reference_t<_Iter>>;
 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<range_value_t<_Range>, 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<iter_value_t<_Iter>, const _Tp&>
      _Iter
      operator()(_Iter __first, iter_difference_t<_Iter> __n,
   const _Tp& __x) const
      {
 using _ValueType = remove_reference_t<iter_reference_t<_Iter>>;
 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<typename _Tp, typename... _Args>
      requires requires {
 ::new (std::declval<void*>()) _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<destructible _Tp>
      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<iter_value_t<_Iter>>
    constexpr _Iter
    __destroy_fn::operator()(_Iter __first, _Sent __last) const noexcept
    {
      if constexpr (is_trivially_destructible_v<iter_value_t<_Iter>>)
 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<range_value_t<_Range>>
    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<iter_value_t<_Iter>>
      constexpr _Iter
      operator()(_Iter __first, iter_difference_t<_Iter> __n) const noexcept
      {
 if constexpr (is_trivially_destructible_v<iter_value_t<_Iter>>)
   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{};
}

}
# 91 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/memory" 2 3




# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/out_ptr.h" 1 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/out_ptr.h" 3

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 36 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/out_ptr.h" 2 3






namespace std __attribute__ ((__visibility__ ("default")))
{
# 54 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/out_ptr.h" 3
  template<typename _Smart, typename _Pointer, typename... _Args>
    class out_ptr_t
    {

      static_assert(!__is_shared_ptr<_Smart> || sizeof...(_Args) != 0,
      "a deleter must be used when adapting std::shared_ptr "
      "with std::out_ptr");


    public:
      explicit
      out_ptr_t(_Smart& __smart, _Args... __args)
      : _M_impl{__smart, std::forward<_Args>(__args)...}
      {
 if constexpr (requires { _M_impl._M_out_init(); })
   _M_impl._M_out_init();
      }

      out_ptr_t(const out_ptr_t&) = delete;

      ~out_ptr_t() = default;

      operator _Pointer*() const noexcept
      { return _M_impl._M_get(); }

      operator void**() const noexcept requires (!same_as<_Pointer, void*>)
      {
 static_assert(is_pointer_v<_Pointer>);
 _Pointer* __p = *this;
 return static_cast<void**>(static_cast<void*>(__p));
      }

    private:

      template<typename, typename, typename...>
 struct _Impl
 {



   _Impl(_Smart& __s, _Args&&... __args)
   : _M_smart(__s), _M_args(std::forward<_Args>(__args)...)
   { }


   void
   _M_out_init()
   {


     if constexpr (requires { _M_smart.reset(); })
       _M_smart.reset();
     else
       _M_smart = _Smart();
   }



   void
   _M_inout_init()
   { _M_ptr = _M_smart.release(); }


   _Pointer*
   _M_get() const
   { return __builtin_addressof(const_cast<_Pointer&>(_M_ptr)); }


   ~_Impl() noexcept(false);

   _Smart& _M_smart;
   [[no_unique_address]] _Pointer _M_ptr{};
   [[no_unique_address]] tuple<_Args...> _M_args;
 };


      template<typename _Tp>
 struct _Impl<_Tp*, _Tp*>
 {
   void
   _M_out_init()
   { _M_p = nullptr; }

   void
   _M_inout_init()
   { }

   _Tp**
   _M_get() const
   { return __builtin_addressof(const_cast<_Tp*&>(_M_p)); }

   _Tp*& _M_p;
 };


      template<typename _Tp, typename _Ptr> requires (!is_same_v<_Ptr, _Tp*>)
 struct _Impl<_Tp*, _Ptr>
 {
   explicit
   _Impl(_Tp*& __p)
   : _M_p(__p)
   { }

   void
   _M_out_init()
   { _M_p = nullptr; }

   void
   _M_inout_init()
   { _M_ptr = _M_p; }

   _Pointer*
   _M_get() const
   { return __builtin_addressof(const_cast<_Pointer&>(_M_ptr)); }

   ~_Impl() { _M_p = static_cast<_Tp*>(_M_ptr); }

   _Tp*& _M_p;
   _Pointer _M_ptr{};
 };







      template<typename _Tp, typename _Del>
 struct _Impl<unique_ptr<_Tp, _Del>,
       typename unique_ptr<_Tp, _Del>::pointer>
 {
   void
   _M_out_init()
   { _M_smart.reset(); }

   _Pointer*
   _M_get() const noexcept
   { return __builtin_addressof(_M_smart._M_t._M_ptr()); }

   _Smart& _M_smart;
 };




      template<typename _Tp, typename _Del, typename _Del2>
 struct _Impl<unique_ptr<_Tp, _Del>,
       typename unique_ptr<_Tp, _Del>::pointer, _Del2>
 {
   void
   _M_out_init()
   { _M_smart.reset(); }

   _Pointer*
   _M_get() const noexcept
   { return __builtin_addressof(_M_smart._M_t._M_ptr()); }

   ~_Impl()
   {
     if (_M_smart.get())
       _M_smart._M_t._M_deleter() = std::forward<_Del2>(_M_del);
   }

   _Smart& _M_smart;
   [[no_unique_address]] _Del2 _M_del;
 };
# 228 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/out_ptr.h" 3
      template<typename _Tp, typename _Del, typename _Alloc>
 requires (is_base_of_v<__shared_ptr<_Tp>, shared_ptr<_Tp>>)
 struct _Impl<shared_ptr<_Tp>,
       typename shared_ptr<_Tp>::element_type*, _Del, _Alloc>
 {
   _Impl(_Smart& __s, _Del __d, _Alloc __a = _Alloc())
   : _M_smart(__s)
   {


     _M_smart.reset();



     typename _Scd::__allocator_type __a2(__a);
     auto __mem = __a2.allocate(1);
     ::new (__mem) _Scd(nullptr, std::forward<_Del>(__d),
          std::forward<_Alloc>(__a));
     _M_smart._M_refcount._M_pi = __mem;
   }

   _Pointer*
   _M_get() const noexcept
   { return __builtin_addressof(_M_smart._M_ptr); }

   ~_Impl()
   {
     auto& __pi = _M_smart._M_refcount._M_pi;

     if (_Sp __ptr = _M_smart.get())
       static_cast<_Scd*>(__pi)->_M_impl._M_ptr = __ptr;
     else
       std::__exchange(__pi, nullptr)->_M_destroy();
   }

   _Smart& _M_smart;

   using _Sp = typename _Smart::element_type*;
   using _Scd = _Sp_counted_deleter<_Sp, decay_t<_Del>,
        remove_cvref_t<_Alloc>,
        __default_lock_policy>;
 };


      template<typename _Tp, typename _Del>
 requires (is_base_of_v<__shared_ptr<_Tp>, shared_ptr<_Tp>>)
 struct _Impl<shared_ptr<_Tp>,
       typename shared_ptr<_Tp>::element_type*, _Del>
 : _Impl<_Smart, _Pointer, _Del, allocator<void>>
 {
   using _Impl<_Smart, _Pointer, _Del, allocator<void>>::_Impl;
 };


      using _Impl_t = _Impl<_Smart, _Pointer, _Args...>;

      _Impl_t _M_impl;

      template<typename, typename, typename...> friend class inout_ptr_t;
    };
# 297 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/out_ptr.h" 3
  template<typename _Smart, typename _Pointer, typename... _Args>
    class inout_ptr_t
    {

      static_assert(!__is_shared_ptr<_Smart>,
      "std::inout_ptr can not be used to wrap std::shared_ptr");


    public:
      explicit
      inout_ptr_t(_Smart& __smart, _Args... __args)
      : _M_impl{__smart, std::forward<_Args>(__args)...}
      {
 if constexpr (requires { _M_impl._M_inout_init(); })
   _M_impl._M_inout_init();
      }

      inout_ptr_t(const inout_ptr_t&) = delete;

      ~inout_ptr_t() = default;

      operator _Pointer*() const noexcept
      { return _M_impl._M_get(); }

      operator void**() const noexcept requires (!same_as<_Pointer, void*>)
      {
 static_assert(is_pointer_v<_Pointer>);
 _Pointer* __p = *this;
 return static_cast<void**>(static_cast<void*>(__p));
      }

    private:


      using _Out_ptr_t
 = __conditional_t<__is_shared_ptr<_Smart>,
     out_ptr_t<void*, void*>,
     out_ptr_t<_Smart, _Pointer, _Args...>>;



      using _Impl_t = typename _Out_ptr_t::_Impl_t;
      _Impl_t _M_impl;
    };


namespace __detail
{

  template<typename _Tp>
    consteval auto
    __pointer_of()
    {
      if constexpr (requires { typename _Tp::pointer; })
 return type_identity<typename _Tp::pointer>{};
      else if constexpr (requires { typename _Tp::element_type; })
 return type_identity<typename _Tp::element_type*>{};
      else
 {
   using _Traits = pointer_traits<_Tp>;
   if constexpr (requires { typename _Traits::element_type; })
     return type_identity<typename _Traits::element_type*>{};
 }

    }


  template<typename _Smart, typename _Ptr>
    consteval auto
    __pointer_of_or()
    {
      using _TypeId = decltype(__detail::__pointer_of<_Smart>());
      if constexpr (is_void_v<_TypeId>)
 return type_identity<_Ptr>{};
      else
 return _TypeId{};
    }


  template<typename _Ptr, typename _Smart>
    consteval auto
    __choose_ptr()
    {
      if constexpr (!is_void_v<_Ptr>)
 return type_identity<_Ptr>{};
      else
 return __detail::__pointer_of<_Smart>();
    }

  template<typename _Smart, typename _Sp, typename... _Args>
    concept __resettable = requires (_Smart& __s) {
      __s.reset(std::declval<_Sp>(), std::declval<_Args>()...);
    };
}
# 402 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/out_ptr.h" 3
  template<typename _Pointer = void, typename _Smart, typename... _Args>
    inline auto
    out_ptr(_Smart& __s, _Args&&... __args)
    {
      using _TypeId = decltype(__detail::__choose_ptr<_Pointer, _Smart>());
      static_assert(!is_void_v<_TypeId>, "first argument to std::out_ptr "
      "must be a pointer-like type");

      using _Ret = out_ptr_t<_Smart, typename _TypeId::type, _Args&&...>;
      return _Ret(__s, std::forward<_Args>(__args)...);
    }
# 423 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/out_ptr.h" 3
  template<typename _Pointer = void, typename _Smart, typename... _Args>
    inline auto
    inout_ptr(_Smart& __s, _Args&&... __args)
    {
      using _TypeId = decltype(__detail::__choose_ptr<_Pointer, _Smart>());
      static_assert(!is_void_v<_TypeId>, "first argument to std::inout_ptr "
      "must be a pointer-like type");

      using _Ret = inout_ptr_t<_Smart, typename _TypeId::type, _Args&&...>;
      return _Ret(__s, std::forward<_Args>(__args)...);
    }


  template<typename _Smart, typename _Pointer, typename... _Args>
  template<typename _Smart2, typename _Pointer2, typename... _Args2>
    inline
    out_ptr_t<_Smart, _Pointer, _Args...>::
    _Impl<_Smart2, _Pointer2, _Args2...>::~_Impl()
    {
      using _TypeId = decltype(__detail::__pointer_of_or<_Smart, _Pointer>());
      using _Sp = typename _TypeId::type;

      if (!_M_ptr)
 return;

      _Smart& __s = _M_smart;
      _Pointer& __p = _M_ptr;

      auto __reset = [&](auto&&... __args) {
 if constexpr (__detail::__resettable<_Smart, _Sp, _Args...>)
   __s.reset(static_cast<_Sp>(__p), std::forward<_Args>(__args)...);
 else if constexpr (is_constructible_v<_Smart, _Sp, _Args...>)
   __s = _Smart(static_cast<_Sp>(__p), std::forward<_Args>(__args)...);
 else
   static_assert(is_constructible_v<_Smart, _Sp, _Args...>);
      };

      if constexpr (sizeof...(_Args) >= 2)
 std::apply(__reset, std::move(_M_args));
      else if constexpr (sizeof...(_Args) == 1)
 __reset(std::get<0>(std::move(_M_args)));
      else
 __reset();
    }



}
# 96 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/memory" 2 3
# 115 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/memory" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 116 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/memory" 2 3
# 171 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/memory" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/pstl/glue_memory_defs.h" 1 3
# 13 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/pstl/glue_memory_defs.h" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/pstl/execution_defs.h" 1 3
# 15 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/pstl/execution_defs.h" 3
namespace __pstl
{
namespace execution
{
inline namespace v1
{


class sequenced_policy
{
};


class parallel_policy
{
};


class parallel_unsequenced_policy
{
};

class unsequenced_policy
{
};


inline constexpr sequenced_policy seq{};
inline constexpr parallel_policy par{};
inline constexpr parallel_unsequenced_policy par_unseq{};
inline constexpr unsequenced_policy unseq{};


template <class _Tp>
struct is_execution_policy : std::false_type
{
};

template <>
struct is_execution_policy<__pstl::execution::sequenced_policy> : std::true_type
{
};
template <>
struct is_execution_policy<__pstl::execution::parallel_policy> : std::true_type
{
};
template <>
struct is_execution_policy<__pstl::execution::parallel_unsequenced_policy> : std::true_type
{
};
template <>
struct is_execution_policy<__pstl::execution::unsequenced_policy> : std::true_type
{
};


template <class _Tp>
constexpr bool is_execution_policy_v = __pstl::execution::is_execution_policy<_Tp>::value;


}
}

namespace __internal
{
template <class _ExecPolicy, class _Tp>

using __enable_if_execution_policy =
    typename std::enable_if<__pstl::execution::is_execution_policy<std::__remove_cvref_t<_ExecPolicy>>::value,
                            _Tp>::type;






template <class _IsVector>
struct __serial_tag;
template <class _IsVector>
struct __parallel_tag;

}

}
# 14 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/pstl/glue_memory_defs.h" 2 3

namespace std
{



template <class _ExecutionPolicy, class _InputIterator, class _ForwardIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
uninitialized_copy(_ExecutionPolicy&& __exec, _InputIterator __first, _InputIterator __last, _ForwardIterator __result);

template <class _ExecutionPolicy, class _InputIterator, class _Size, class _ForwardIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
uninitialized_copy_n(_ExecutionPolicy&& __exec, _InputIterator __first, _Size __n, _ForwardIterator __result);



template <class _ExecutionPolicy, class _InputIterator, class _ForwardIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
uninitialized_move(_ExecutionPolicy&& __exec, _InputIterator __first, _InputIterator __last, _ForwardIterator __result);

template <class _ExecutionPolicy, class _InputIterator, class _Size, class _ForwardIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
uninitialized_move_n(_ExecutionPolicy&& __exec, _InputIterator __first, _Size __n, _ForwardIterator __result);



template <class _ExecutionPolicy, class _ForwardIterator, class _Tp>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
uninitialized_fill(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value);

template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Tp>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
uninitialized_fill_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n, const _Tp& __value);



template <class _ExecutionPolicy, class _ForwardIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
destroy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);

template <class _ExecutionPolicy, class _ForwardIterator, class _Size>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
destroy_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n);



template <class _ExecutionPolicy, class _ForwardIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
uninitialized_default_construct(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);

template <class _ExecutionPolicy, class _ForwardIterator, class _Size>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
uninitialized_default_construct_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n);



template <class _ExecutionPolicy, class _ForwardIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
uninitialized_value_construct(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);

template <class _ExecutionPolicy, class _ForwardIterator, class _Size>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
uninitialized_value_construct_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n);

}
# 172 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/memory" 2 3
# 31 "/home/avi/scylla-maint/seastar/include/seastar/core/future.hh" 2


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/utility" 1 3
# 59 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/utility" 3
# 68 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/utility" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_relops.h" 1 3
# 62 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_relops.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{


  namespace rel_ops
  {
# 86 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_relops.h" 3
    template <class _Tp>
      inline bool
      operator!=(const _Tp& __x, const _Tp& __y)
      { return !(__x == __y); }
# 99 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_relops.h" 3
    template <class _Tp>
      inline bool
      operator>(const _Tp& __x, const _Tp& __y)
      { return __y < __x; }
# 112 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_relops.h" 3
    template <class _Tp>
      inline bool
      operator<=(const _Tp& __x, const _Tp& __y)
      { return !(__y < __x); }
# 125 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_relops.h" 3
    template <class _Tp>
      inline bool
      operator>=(const _Tp& __x, const _Tp& __y)
      { return !(__x < __y); }
  }


}
# 69 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/utility" 2 3
# 96 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/utility" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 97 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/utility" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{




  template <typename _Tp, typename _Up = _Tp>
    constexpr
    inline _Tp
    exchange(_Tp& __obj, _Up&& __new_val)
    noexcept(__and_<is_nothrow_move_constructible<_Tp>,
      is_nothrow_assignable<_Tp&, _Up>>::value)
    { return std::__exchange(__obj, std::forward<_Up>(__new_val)); }



  template<typename _Tp>
    [[nodiscard]]
    constexpr add_const_t<_Tp>&
    as_const(_Tp& __t) noexcept
    { return __t; }

  template<typename _Tp>
    void as_const(const _Tp&&) = delete;



  template<typename _Tp, typename _Up>
    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<typename _Tp, typename _Up>
    constexpr bool
    cmp_not_equal(_Tp __t, _Up __u) noexcept
    { return !std::cmp_equal(__t, __u); }

  template<typename _Tp, typename _Up>
    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<typename _Tp, typename _Up>
    constexpr bool
    cmp_greater(_Tp __t, _Up __u) noexcept
    { return std::cmp_less(__u, __t); }

  template<typename _Tp, typename _Up>
    constexpr bool
    cmp_less_equal(_Tp __t, _Up __u) noexcept
    { return !std::cmp_less(__u, __t); }

  template<typename _Tp, typename _Up>
    constexpr bool
    cmp_greater_equal(_Tp __t, _Up __u) noexcept
    { return !std::cmp_less(__t, __u); }

  template<typename _Res, typename _Tp>
    constexpr bool
    in_range(_Tp __t) noexcept
    {
      static_assert(__is_standard_integer<_Res>::value);
      static_assert(__is_standard_integer<_Tp>::value);
      using __gnu_cxx::__int_traits;

      if constexpr (is_signed_v<_Tp> == is_signed_v<_Res>)
 return __int_traits<_Res>::__min <= __t
   && __t <= __int_traits<_Res>::__max;
      else if constexpr (is_signed_v<_Tp>)
 return __t >= 0
   && make_unsigned_t<_Tp>(__t) <= __int_traits<_Res>::__max;
      else
 return __t <= make_unsigned_t<_Res>(__int_traits<_Res>::__max);
    }




  template<typename _Tp>
    [[nodiscard]]
    constexpr underlying_type_t<_Tp>
    to_underlying(_Tp __value) noexcept
    { return static_cast<underlying_type_t<_Tp>>(__value); }
# 216 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/utility" 3
  [[noreturn,__gnu__::__always_inline__]]
  inline void
  unreachable()
  {





    __builtin_unreachable();

  }



}
# 34 "/home/avi/scylla-maint/seastar/include/seastar/core/future.hh" 2


# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/task.hh" 1
# 24 "/home/avi/scylla-maint/seastar/include/seastar/core/task.hh"
# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/scheduling.hh" 1
# 25 "/home/avi/scylla-maint/seastar/include/seastar/core/scheduling.hh"
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/chrono" 1 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/chrono" 3







# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/chrono.h" 1 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/chrono.h" 3



# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ratio" 1 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ratio" 3
# 43 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ratio" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 44 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ratio" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{
# 59 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ratio" 3
  template<intmax_t _Pn>
    struct __static_sign
    : integral_constant<intmax_t, (_Pn < 0) ? -1 : 1>
    { };

  template<intmax_t _Pn>
    struct __static_abs
    : integral_constant<intmax_t, _Pn * __static_sign<_Pn>::value>
    { };

  template<intmax_t _Pn, intmax_t _Qn>
    struct __static_gcd
    : __static_gcd<_Qn, (_Pn % _Qn)>
    { };

  template<intmax_t _Pn>
    struct __static_gcd<_Pn, 0>
    : integral_constant<intmax_t, __static_abs<_Pn>::value>
    { };

  template<intmax_t _Qn>
    struct __static_gcd<0, _Qn>
    : integral_constant<intmax_t, __static_abs<_Qn>::value>
    { };







  template<intmax_t _Pn, intmax_t _Qn>
    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 <= 9223372036854775807L,
      "overflow in multiplication");
      static_assert((__a0 * __b1 + __b0 * __a1) * __c
      <= 9223372036854775807L - __b0 * __a0,
      "overflow in multiplication");

    public:
      static const intmax_t value = _Pn * _Qn;
    };



  template<uintmax_t __hi1, uintmax_t __lo1, uintmax_t __hi2, uintmax_t __lo2>
    struct __big_less
    : integral_constant<bool, (__hi1 < __hi2
          || (__hi1 == __hi2 && __lo1 < __lo2))>
    { };

  template<uintmax_t __hi1, uintmax_t __lo1, uintmax_t __hi2, uintmax_t __lo2>
    struct __big_add
    {
      static constexpr uintmax_t __lo = __lo1 + __lo2;
      static constexpr uintmax_t __hi = (__hi1 + __hi2 +
      (__lo1 + __lo2 < __lo1));
    };


  template<uintmax_t __hi1, uintmax_t __lo1, uintmax_t __hi2, uintmax_t __lo2>
    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<uintmax_t __x, uintmax_t __y>
    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<uintmax_t __n1, uintmax_t __n0, uintmax_t __d>
    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<uintmax_t __n1, uintmax_t __n0, uintmax_t __d>
    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");
    };
# 268 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ratio" 3
  template<intmax_t _Num, intmax_t _Den = 1>
    struct ratio
    {
      static_assert(_Den != 0, "denominator cannot be zero");
      static_assert(_Num >= -9223372036854775807L && _Den >= -9223372036854775807L,
      "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<num, den> type;
    };
# 295 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ratio" 3
  template<typename _Tp>
    struct __is_ratio
    : std::false_type
    { };

  template<intmax_t _Num, intmax_t _Den>
    struct __is_ratio<ratio<_Num, _Den>>
    : std::true_type
    { };


  template<typename _Tp>
    constexpr bool __is_ratio_v = false;
  template<intmax_t _Num, intmax_t _Den>
    constexpr bool __is_ratio_v<ratio<_Num, _Den>> = true;


  template<typename _R1, typename _R2>
    constexpr bool
    __are_both_ratios() noexcept
    {

      if constexpr (__is_ratio_v<_R1>)
 if constexpr (__is_ratio_v<_R2>)
   return true;
      return false;



    }

  template<typename _R1, typename _R2>
    struct __ratio_multiply
    {
      static_assert(std::__are_both_ratios<_R1, _R2>(),
      "both template arguments must be a std::ratio");

    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;
    };
# 360 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ratio" 3
  template<typename _R1, typename _R2>
    using ratio_multiply = typename __ratio_multiply<_R1, _R2>::type;



  template<typename _R1, typename _R2>
    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;
    };
# 389 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ratio" 3
  template<typename _R1, typename _R2>
    using ratio_divide = typename __ratio_divide<_R1, _R2>::type;


  template<typename _R1, typename _R2>
    struct ratio_equal
    : integral_constant<bool, _R1::num == _R2::num && _R1::den == _R2::den>
    {
      static_assert(std::__are_both_ratios<_R1, _R2>(),
      "both template arguments must be a std::ratio");
    };


  template<typename _R1, typename _R2>
    struct ratio_not_equal
    : integral_constant<bool, !ratio_equal<_R1, _R2>::value>
    { };




  template<typename _R1, typename _R2,
           typename _Left = __big_mul<_R1::num,_R2::den>,
           typename _Right = __big_mul<_R2::num,_R1::den> >
    struct __ratio_less_impl_1
    : integral_constant<bool, __big_less<_Left::__hi, _Left::__lo,
           _Right::__hi, _Right::__lo>::value>
    { };

  template<typename _R1, typename _R2,
    bool = (_R1::num == 0 || _R2::num == 0
     || (__static_sign<_R1::num>::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<typename _R1, typename _R2>
    struct __ratio_less_impl<_R1, _R2, true, false>
    : integral_constant<bool, _R1::num < _R2::num>
    { };

  template<typename _R1, typename _R2>
    struct __ratio_less_impl<_R1, _R2, false, true>
    : __ratio_less_impl_1<ratio<-_R2::num, _R2::den>,
           ratio<-_R1::num, _R1::den> >::type
    { };




  template<typename _R1, typename _R2>
    struct ratio_less
    : __ratio_less_impl<_R1, _R2>::type
    {
      static_assert(std::__are_both_ratios<_R1, _R2>(),
      "both template arguments must be a std::ratio");
    };


  template<typename _R1, typename _R2>
    struct ratio_less_equal
    : integral_constant<bool, !ratio_less<_R2, _R1>::value>
    { };


  template<typename _R1, typename _R2>
    struct ratio_greater
    : integral_constant<bool, ratio_less<_R2, _R1>::value>
    { };


  template<typename _R1, typename _R2>
    struct ratio_greater_equal
    : integral_constant<bool, !ratio_less<_R1, _R2>::value>
    { };


  template <typename _R1, typename _R2>
    inline constexpr bool ratio_equal_v = ratio_equal<_R1, _R2>::value;
  template <typename _R1, typename _R2>
    inline constexpr bool ratio_not_equal_v = ratio_not_equal<_R1, _R2>::value;
  template <typename _R1, typename _R2>
    inline constexpr bool ratio_less_v = ratio_less<_R1, _R2>::value;
  template <typename _R1, typename _R2>
    inline constexpr bool ratio_less_equal_v
      = ratio_less_equal<_R1, _R2>::value;
  template <typename _R1, typename _R2>
    inline constexpr bool ratio_greater_v = ratio_greater<_R1, _R2>::value;
  template <typename _R1, typename _R2>
    inline constexpr bool ratio_greater_equal_v
      = ratio_greater_equal<_R1, _R2>::value;




  template<typename _R1, typename _R2,
      bool = (_R1::num >= 0),
      bool = (_R2::num >= 0),
      bool = ratio_less<ratio<__static_abs<_R1::num>::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<typename _R1, typename _R2, bool __b>
    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 <= 9223372036854775807L, "overflow in addition");
      typedef __big_mul<_R1::den / __g2, __d2> __d_final;
      static_assert(__d_final::__hi == 0 &&
        __d_final::__lo <= 9223372036854775807L, "overflow in addition");
    public:
      typedef ratio<__n_final::__quot_lo, __d_final::__lo> type;
    };

  template<typename _R1, typename _R2>
    struct __ratio_add_impl<_R1, _R2, false, true, true>
    : __ratio_add_impl<_R2, _R1>
    { };


  template<typename _R1, typename _R2>
    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 <= 9223372036854775807L, "overflow in addition");
      typedef __big_mul<_R1::den / __g2, __d2> __d_final;
      static_assert(__d_final::__hi == 0 &&
        __d_final::__lo <= 9223372036854775807L, "overflow in addition");
    public:
      typedef ratio<__n_final::__quot_lo, __d_final::__lo> type;
    };

  template<typename _R1, typename _R2>
    struct __ratio_add
    {
      static_assert(std::__are_both_ratios<_R1, _R2>(),
      "both template arguments must be a std::ratio");

      typedef typename __ratio_add_impl<_R1, _R2>::type type;
      static constexpr intmax_t num = type::num;
      static constexpr intmax_t den = type::den;
    };
# 578 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ratio" 3
  template<typename _R1, typename _R2>
    using ratio_add = typename __ratio_add<_R1, _R2>::type;



  template<typename _R1, typename _R2>
    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;
    };
# 605 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ratio" 3
  template<typename _R1, typename _R2>
    using ratio_subtract = typename __ratio_subtract<_R1, _R2>::type;
# 618 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ratio" 3
  using atto = ratio< 1, 1000000000000000000>;
  using femto = ratio< 1, 1000000000000000>;
  using pico = ratio< 1, 1000000000000>;
  using nano = ratio< 1, 1000000000>;
  using micro = ratio< 1, 1000000>;
  using milli = ratio< 1, 1000>;
  using centi = ratio< 1, 100>;
  using deci = ratio< 1, 10>;
  using deca = ratio< 10, 1>;
  using hecto = ratio< 100, 1>;
  using kilo = ratio< 1000, 1>;
  using mega = ratio< 1000000, 1>;
  using giga = ratio< 1000000000, 1>;
  using tera = ratio< 1000000000000, 1>;
  using peta = ratio< 1000000000000000, 1>;
  using exa = ratio< 1000000000000000000, 1>;
# 647 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ratio" 3
}
# 38 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/chrono.h" 2 3


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ctime" 1 3
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ctime" 3
# 41 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/chrono.h" 2 3






# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/chrono.h" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{



  namespace filesystem { struct __file_clock; };


  namespace chrono
  {




    template<typename _Rep, typename _Period = ratio<1>>
      class duration;


    template<typename _Clock, typename _Dur = typename _Clock::duration>
      class time_point;

  }
# 79 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/chrono.h" 3
  template<typename _CT, typename _Period1, typename _Period2, typename = void>
    struct __duration_common_type
    { };

  template<typename _CT, typename _Period1, typename _Period2>
    struct __duration_common_type<_CT, _Period1, _Period2,
      __void_t<typename _CT::type>>
    {
    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<typename _Rep1, typename _Period1, typename _Rep2, typename _Period2>
    struct common_type<chrono::duration<_Rep1, _Period1>,
         chrono::duration<_Rep2, _Period2>>
    : __duration_common_type<common_type<_Rep1, _Rep2>,
        typename _Period1::type,
        typename _Period2::type>
    { };


  template<typename _Rep, typename _Period>
    struct common_type<chrono::duration<_Rep, _Period>,
         chrono::duration<_Rep, _Period>>
    {
      using type = chrono::duration<typename common_type<_Rep>::type,
        typename _Period::type>;
    };


  template<typename _Rep, typename _Period>
    struct common_type<chrono::duration<_Rep, _Period>>
    {
      using type = chrono::duration<typename common_type<_Rep>::type,
        typename _Period::type>;
    };






  template<typename _CT, typename _Clock, typename = void>
    struct __timepoint_common_type
    { };

  template<typename _CT, typename _Clock>
    struct __timepoint_common_type<_CT, _Clock, __void_t<typename _CT::type>>
    {
      using type = chrono::time_point<_Clock, typename _CT::type>;
    };







  template<typename _Clock, typename _Duration1, typename _Duration2>
    struct common_type<chrono::time_point<_Clock, _Duration1>,
         chrono::time_point<_Clock, _Duration2>>
    : __timepoint_common_type<common_type<_Duration1, _Duration2>, _Clock>
    { };


  template<typename _Clock, typename _Duration>
    struct common_type<chrono::time_point<_Clock, _Duration>,
         chrono::time_point<_Clock, _Duration>>
    { using type = chrono::time_point<_Clock, _Duration>; };


  template<typename _Clock, typename _Duration>
    struct common_type<chrono::time_point<_Clock, _Duration>>
    { using type = chrono::time_point<_Clock, _Duration>; };




  namespace chrono
  {






    template<typename _ToDur, typename _CF, typename _CR,
      bool _NumIsOne = false, bool _DenIsOne = false>
      struct __duration_cast_impl
      {
 template<typename _Rep, typename _Period>
   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<typename _ToDur, typename _CF, typename _CR>
      struct __duration_cast_impl<_ToDur, _CF, _CR, true, true>
      {
 template<typename _Rep, typename _Period>
   static constexpr _ToDur
   __cast(const duration<_Rep, _Period>& __d)
   {
     typedef typename _ToDur::rep __to_rep;
     return _ToDur(static_cast<__to_rep>(__d.count()));
   }
      };

    template<typename _ToDur, typename _CF, typename _CR>
      struct __duration_cast_impl<_ToDur, _CF, _CR, true, false>
      {
 template<typename _Rep, typename _Period>
   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<typename _ToDur, typename _CF, typename _CR>
      struct __duration_cast_impl<_ToDur, _CF, _CR, false, true>
      {
 template<typename _Rep, typename _Period>
   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<typename _Tp>
      struct __is_duration
      : std::false_type
      { };

    template<typename _Rep, typename _Period>
      struct __is_duration<duration<_Rep, _Period>>
      : std::true_type
      { };

    template<typename _Tp>
      using __enable_if_is_duration
 = typename enable_if<__is_duration<_Tp>::value, _Tp>::type;

    template<typename _Tp>
      using __disable_if_is_duration
 = typename enable_if<!__is_duration<_Tp>::value, _Tp>::type;


    template<typename _Tp>
      inline constexpr bool __is_duration_v = false;
    template<typename _Rep, typename _Period>
      inline constexpr bool __is_duration_v<duration<_Rep, _Period>> = true;
    template<typename _Tp>
      inline constexpr bool __is_time_point_v = false;
    template<typename _Clock, typename _Dur>
      inline constexpr bool __is_time_point_v<time_point<_Clock, _Dur>> = true;
# 272 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/chrono.h" 3
    template<typename _ToDur, typename _Rep, typename _Period>
      [[__nodiscard__]]
      constexpr __enable_if_is_duration<_ToDur>
      duration_cast(const duration<_Rep, _Period>& __d)
      {

 if constexpr (is_same_v<_ToDur, duration<_Rep, _Period>>)
   return __d;
 else
   {

   using __to_period = typename _ToDur::period;
   using __to_rep = typename _ToDur::rep;
   using __cf = ratio_divide<_Period, __to_period>;
   using __cr = typename common_type<__to_rep, _Rep, intmax_t>::type;
   using __dc = __duration_cast_impl<_ToDur, __cf, __cr,
         __cf::num == 1, __cf::den == 1>;
   return __dc::__cast(__d);

   }

      }
# 306 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/chrono.h" 3
    template<typename _Rep>
      struct treat_as_floating_point
      : is_floating_point<_Rep>
      { };


    template <typename _Rep>
      inline constexpr bool treat_as_floating_point_v =
 treat_as_floating_point<_Rep>::value;

    template<>
      inline constexpr bool treat_as_floating_point_v<int> = false;
    template<>
      inline constexpr bool treat_as_floating_point_v<long> = false;
    template<>
      inline constexpr bool treat_as_floating_point_v<long long> = false;
    template<>
      inline constexpr bool treat_as_floating_point_v<float> = true;
    template<>
      inline constexpr bool treat_as_floating_point_v<double> = true;
    template<>
      inline constexpr bool treat_as_floating_point_v<long double> = true;




    template<typename _Tp>
      inline constexpr bool is_clock_v = false;

    template<typename _Tp>
      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<const bool*>;
 { _Tp::now() } -> same_as<typename _Tp::time_point>;
 requires same_as<typename _Tp::duration,
    duration<typename _Tp::rep, typename _Tp::period>>;
 requires same_as<typename _Tp::time_point::duration,
    typename _Tp::duration>;
      }
    inline constexpr bool is_clock_v<_Tp> = true;
# 369 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/chrono.h" 3
    template<typename _Tp>
      struct is_clock
      : bool_constant<is_clock_v<_Tp>>
      { };
# 386 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/chrono.h" 3
    template<typename _ToDur, typename _Rep, typename _Period>
      [[nodiscard]] 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;
      }
# 406 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/chrono.h" 3
    template<typename _ToDur, typename _Rep, typename _Period>
      [[nodiscard]] 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;
      }
# 427 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/chrono.h" 3
    template <typename _ToDur, typename _Rep, typename _Period>
      [[nodiscard]] constexpr
      enable_if_t<
 __and_<__is_duration<_ToDur>,
        __not_<treat_as_floating_point<typename _ToDur::rep>>>::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<typename _Rep, typename _Period>
      [[nodiscard]] constexpr
      enable_if_t<numeric_limits<_Rep>::is_signed, duration<_Rep, _Period>>
      abs(duration<_Rep, _Period> __d)
      {
 if (__d >= __d.zero())
   return __d;
 return -__d;
      }


    namespace __detail { using chrono::ceil; }
# 494 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/chrono.h" 3
    template<typename _Rep>
      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<typename _Rep, typename _Period>
      class duration
      {
 static_assert(!__is_duration<_Rep>::value,
        "rep cannot be a std::chrono::duration");
 static_assert(__is_ratio<_Period>::value,
        "period must be a specialization of std::ratio");
 static_assert(_Period::num > 0, "period must be positive");

 template<typename _Rep2>
   using __is_float = treat_as_floating_point<_Rep2>;

 static constexpr intmax_t
 _S_gcd(intmax_t __m, intmax_t __n) noexcept
 {



   do
     {
       intmax_t __rem = __m % __n;
       __m = __n;
       __n = __rem;
     }
   while (__n != 0);
   return __m;





 }





 template<typename _R1, typename _R2,
   intmax_t __gcd1 = _S_gcd(_R1::num, _R2::num),
   intmax_t __gcd2 = _S_gcd(_R1::den, _R2::den)>
   using __divide = ratio<(_R1::num / __gcd1) * (_R2::den / __gcd2),
     (_R1::den / __gcd2) * (_R2::num / __gcd1)>;


 template<typename _Period2>
   using __is_harmonic
     = __bool_constant<__divide<_Period2, _Period>::den == 1>;

      public:

 using rep = _Rep;
 using period = typename _Period::type;


 constexpr duration() = default;

 duration(const duration&) = default;



 template<typename _Rep2, typename = _Require<
   is_convertible<const _Rep2&, rep>,
   __or_<__is_float<rep>, __not_<__is_float<_Rep2>>>>>
   constexpr explicit duration(const _Rep2& __rep)
   : __r(static_cast<rep>(__rep)) { }

 template<typename _Rep2, typename _Period2, typename = _Require<
   is_convertible<const _Rep2&, rep>,
   __or_<__is_float<rep>,
         __and_<__is_harmonic<_Period2>,
         __not_<__is_float<_Rep2>>>>>>
   constexpr duration(const duration<_Rep2, _Period2>& __d)
   : __r(duration_cast<duration>(__d).count()) { }

 ~duration() = default;
 duration& operator=(const duration&) = default;


 constexpr rep
 count() const
 { return __r; }



 constexpr duration<typename common_type<rep>::type, period>
 operator+() const
 { return duration<typename common_type<rep>::type, period>(__r); }

 constexpr duration<typename common_type<rep>::type, period>
 operator-() const
 { return duration<typename common_type<rep>::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<typename _Rep2 = rep>
   constexpr
   __enable_if_t<!treat_as_floating_point<_Rep2>::value, duration&>
   operator%=(const rep& __rhs)
   {
     __r %= __rhs;
     return *this;
   }

 template<typename _Rep2 = rep>
   constexpr
   __enable_if_t<!treat_as_floating_point<_Rep2>::value, duration&>
   operator%=(const duration& __d)
   {
     __r %= __d.count();
     return *this;
   }


 static constexpr duration
 zero() noexcept
 { return duration(duration_values<rep>::zero()); }

 static constexpr duration
 min() noexcept
 { return duration(duration_values<rep>::min()); }

 static constexpr duration
 max() noexcept
 { return duration(duration_values<rep>::max()); }

      private:
 rep __r;
      };





    template<typename _Rep1, typename _Period1,
      typename _Rep2, typename _Period2>
      constexpr typename common_type<duration<_Rep1, _Period1>,
         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<typename _Rep1, typename _Period1,
      typename _Rep2, typename _Period2>
      constexpr typename common_type<duration<_Rep1, _Period1>,
         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());
      }
# 727 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/chrono.h" 3
    template<typename _Rep1, typename _Rep2,
      typename _CRep = typename common_type<_Rep1, _Rep2>::type>
      using __common_rep_t = typename
 enable_if<is_convertible<const _Rep2&, _CRep>::value, _CRep>::type;
# 739 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/chrono.h" 3
    template<typename _Rep1, typename _Period, typename _Rep2>
      constexpr duration<__common_rep_t<_Rep1, _Rep2>, _Period>
      operator*(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
      {
 typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period>
   __cd;
 return __cd(__cd(__d).count() * __s);
      }

    template<typename _Rep1, typename _Rep2, typename _Period>
      constexpr duration<__common_rep_t<_Rep2, _Rep1>, _Period>
      operator*(const _Rep1& __s, const duration<_Rep2, _Period>& __d)
      { return __d * __s; }

    template<typename _Rep1, typename _Period, typename _Rep2>
      constexpr
      duration<__common_rep_t<_Rep1, __disable_if_is_duration<_Rep2>>, _Period>
      operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
      {
 typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period>
   __cd;
 return __cd(__cd(__d).count() / __s);
      }

    template<typename _Rep1, typename _Period1,
      typename _Rep2, typename _Period2>
      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<typename _Rep1, typename _Period, typename _Rep2>
      constexpr
      duration<__common_rep_t<_Rep1, __disable_if_is_duration<_Rep2>>, _Period>
      operator%(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
      {
 typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period>
   __cd;
 return __cd(__cd(__d).count() % __s);
      }

    template<typename _Rep1, typename _Period1,
      typename _Rep2, typename _Period2>
      constexpr typename common_type<duration<_Rep1, _Period1>,
         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());
      }
# 807 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/chrono.h" 3
    template<typename _Rep1, typename _Period1,
      typename _Rep2, typename _Period2>
      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<typename _Rep1, typename _Period1,
      typename _Rep2, typename _Period2>
      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<typename _Rep1, typename _Period1,
      typename _Rep2, typename _Period2>
      requires three_way_comparable<common_type_t<_Rep1, _Rep2>>
      constexpr auto
      operator<=>(const duration<_Rep1, _Period1>& __lhs,
    const duration<_Rep2, _Period2>& __rhs)
      {
 using __ct = common_type_t<duration<_Rep1, _Period1>,
       duration<_Rep2, _Period2>>;
 return __ct(__lhs).count() <=> __ct(__rhs).count();
      }
# 852 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/chrono.h" 3
    template<typename _Rep1, typename _Period1,
      typename _Rep2, typename _Period2>
      constexpr bool
      operator<=(const duration<_Rep1, _Period1>& __lhs,
   const duration<_Rep2, _Period2>& __rhs)
      { return !(__rhs < __lhs); }

    template<typename _Rep1, typename _Period1,
      typename _Rep2, typename _Period2>
      constexpr bool
      operator>(const duration<_Rep1, _Period1>& __lhs,
  const duration<_Rep2, _Period2>& __rhs)
      { return __rhs < __lhs; }

    template<typename _Rep1, typename _Period1,
      typename _Rep2, typename _Period2>
      constexpr bool
      operator>=(const duration<_Rep1, _Period1>& __lhs,
   const duration<_Rep2, _Period2>& __rhs)
      { return !(__lhs < __rhs); }
# 888 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/chrono.h" 3
    using nanoseconds = duration<int64_t, nano>;


    using microseconds = duration<int64_t, micro>;


    using milliseconds = duration<int64_t, milli>;


    using seconds = duration<int64_t>;


    using minutes = duration<int64_t, ratio< 60>>;


    using hours = duration<int64_t, ratio<3600>>;



    using days = duration<int64_t, ratio<86400>>;


    using weeks = duration<int64_t, ratio<604800>>;


    using years = duration<int64_t, ratio<31556952>>;


    using months = duration<int64_t, ratio<2629746>>;




    template<typename _Clock, typename _Dur>
      class time_point
      {
 static_assert(__is_duration<_Dur>::value,
     "duration must be a specialization of std::chrono::duration");

      public:
 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<typename _Dur2,
   typename = _Require<is_convertible<_Dur2, _Dur>>>
   constexpr time_point(const time_point<clock, _Dur2>& __t)
   : __d(__t.time_since_epoch())
   { }


 constexpr duration
 time_since_epoch() const
 { return __d; }


 constexpr time_point&
 operator++()
 {
   ++__d;
   return *this;
 }

 constexpr time_point
 operator++(int)
 { return time_point{__d++}; }

 constexpr time_point&
 operator--()
 {
   --__d;
   return *this;
 }

 constexpr time_point
 operator--(int)
 { return time_point{__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;
      };
# 1016 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/chrono.h" 3
    template<typename _ToDur, typename _Clock, typename _Dur>
      [[__nodiscard__]] constexpr
      __enable_if_t<__is_duration<_ToDur>::value, time_point<_Clock, _ToDur>>
      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()));
      }
# 1038 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/chrono.h" 3
    template<typename _ToDur, typename _Clock, typename _Dur>
      [[nodiscard]] constexpr
      enable_if_t<__is_duration_v<_ToDur>, time_point<_Clock, _ToDur>>
      floor(const time_point<_Clock, _Dur>& __tp)
      {
 return time_point<_Clock, _ToDur>{
     chrono::floor<_ToDur>(__tp.time_since_epoch())};
      }
# 1059 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/chrono.h" 3
    template<typename _ToDur, typename _Clock, typename _Dur>
      [[nodiscard]] constexpr
      enable_if_t<__is_duration_v<_ToDur>, time_point<_Clock, _ToDur>>
      ceil(const time_point<_Clock, _Dur>& __tp)
      {
 return time_point<_Clock, _ToDur>{
     chrono::ceil<_ToDur>(__tp.time_since_epoch())};
      }
# 1081 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/chrono.h" 3
    template<typename _ToDur, typename _Clock, typename _Dur>
      [[nodiscard]] constexpr
      enable_if_t<__is_duration_v<_ToDur>
      && !treat_as_floating_point_v<typename _ToDur::rep>,
    time_point<_Clock, _ToDur>>
      round(const time_point<_Clock, _Dur>& __tp)
      {
 return time_point<_Clock, _ToDur>{
     chrono::round<_ToDur>(__tp.time_since_epoch())};
      }






    template<typename _Clock, typename _Dur1,
      typename _Rep2, typename _Period2>
      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<typename _Rep1, typename _Period1,
      typename _Clock, typename _Dur2>
      constexpr time_point<_Clock,
 typename common_type<duration<_Rep1, _Period1>, _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<typename _Clock, typename _Dur1,
      typename _Rep2, typename _Period2>
      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<typename _Clock, typename _Dur1, typename _Dur2>
      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<typename _Clock, typename _Dur1, typename _Dur2>
      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<typename _Clock, typename _Dur1,
      three_way_comparable_with<_Dur1> _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(); }
# 1172 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/chrono.h" 3
    template<typename _Clock, typename _Dur1, typename _Dur2>
      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<typename _Clock, typename _Dur1, typename _Dur2>
      constexpr bool
      operator<=(const time_point<_Clock, _Dur1>& __lhs,
   const time_point<_Clock, _Dur2>& __rhs)
      { return !(__rhs < __lhs); }

    template<typename _Clock, typename _Dur1, typename _Dur2>
      constexpr bool
      operator>(const time_point<_Clock, _Dur1>& __lhs,
  const time_point<_Clock, _Dur2>& __rhs)
      { return __rhs < __lhs; }

    template<typename _Clock, typename _Dur1, typename _Dur2>
      constexpr bool
      operator>=(const time_point<_Clock, _Dur1>& __lhs,
   const time_point<_Clock, _Dur2>& __rhs)
      { return !(__lhs < __rhs); }
# 1217 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/chrono.h" 3
inline namespace _V2 {







    struct system_clock
    {
      typedef chrono::nanoseconds duration;
      typedef duration::rep rep;
      typedef duration::period period;
      typedef chrono::time_point<system_clock, duration> 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<chrono::seconds>
      (__t.time_since_epoch()).count());
      }

      static time_point
      from_time_t(std::time_t __t) noexcept
      {
 typedef chrono::time_point<system_clock, seconds> __from;
 return time_point_cast<system_clock::duration>
        (__from(chrono::seconds(__t)));
      }
    };
# 1265 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/chrono.h" 3
    struct steady_clock
    {
      typedef chrono::nanoseconds duration;
      typedef duration::rep rep;
      typedef duration::period period;
      typedef chrono::time_point<steady_clock, duration> time_point;

      static constexpr bool is_steady = true;

      static time_point
      now() noexcept;
    };
# 1287 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/chrono.h" 3
    using high_resolution_clock = system_clock;

}




    template<typename _Duration>
      using sys_time = time_point<system_clock, _Duration>;
    using sys_seconds = sys_time<seconds>;
    using sys_days = sys_time<days>;

    using file_clock = ::std::filesystem::__file_clock;

    template<typename _Duration>
      using file_time = time_point<file_clock, _Duration>;

    template<> struct is_clock<system_clock> : true_type { };
    template<> struct is_clock<steady_clock> : true_type { };
    template<> struct is_clock<file_clock> : true_type { };

    template<> inline constexpr bool is_clock_v<system_clock> = true;
    template<> inline constexpr bool is_clock_v<steady_clock> = true;
    template<> inline constexpr bool is_clock_v<file_clock> = true;


  }


  inline namespace literals
  {
# 1342 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/chrono.h" 3
  inline namespace chrono_literals
  {



#pragma GCC diagnostic push


    template<typename _Dur, char... _Digits>
      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<long double, ratio<3600,1>>
    operator""h(long double __hours)
    { return chrono::duration<long double, ratio<3600,1>>{__hours}; }


    template <char... _Digits>
      constexpr chrono::hours
      operator""h()
      { return __check_overflow<chrono::hours, _Digits...>(); }


    constexpr chrono::duration<long double, ratio<60,1>>
    operator""min(long double __mins)
    { return chrono::duration<long double, ratio<60,1>>{__mins}; }


    template <char... _Digits>
      constexpr chrono::minutes
      operator""min()
      { return __check_overflow<chrono::minutes, _Digits...>(); }


    constexpr chrono::duration<long double>
    operator""s(long double __secs)
    { return chrono::duration<long double>{__secs}; }


    template <char... _Digits>
      constexpr chrono::seconds
      operator""s()
      { return __check_overflow<chrono::seconds, _Digits...>(); }


    constexpr chrono::duration<long double, milli>
    operator""ms(long double __msecs)
    { return chrono::duration<long double, milli>{__msecs}; }


    template <char... _Digits>
      constexpr chrono::milliseconds
      operator""ms()
      { return __check_overflow<chrono::milliseconds, _Digits...>(); }


    constexpr chrono::duration<long double, micro>
    operator""us(long double __usecs)
    { return chrono::duration<long double, micro>{__usecs}; }


    template <char... _Digits>
      constexpr chrono::microseconds
      operator""us()
      { return __check_overflow<chrono::microseconds, _Digits...>(); }


    constexpr chrono::duration<long double, nano>
    operator""ns(long double __nsecs)
    { return chrono::duration<long double, nano>{__nsecs}; }


    template <char... _Digits>
      constexpr chrono::nanoseconds
      operator""ns()
      { return __check_overflow<chrono::nanoseconds, _Digits...>(); }

#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<typename _Dur>
 static
 chrono::file_time<common_type_t<_Dur, chrono::seconds>>
 from_sys(const chrono::sys_time<_Dur>& __t) noexcept
 { return _S_from_sys(__t); }


      template<typename _Dur>
 static
 chrono::sys_time<common_type_t<_Dur, chrono::seconds>>
 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<typename _Dur>
 static
 chrono::time_point<__file_clock, common_type_t<_Dur, chrono::seconds>>
 _S_from_sys(const chrono::time_point<__sys_clock, _Dur>& __t) noexcept
 {
   using _CDur = common_type_t<_Dur, chrono::seconds>;
   using __file_time = chrono::time_point<__file_clock, _CDur>;
   return __file_time{__t.time_since_epoch()} - _S_epoch_diff;
 }


      template<typename _Dur>
 static
 chrono::time_point<__sys_clock, common_type_t<_Dur, chrono::seconds>>
 _S_to_sys(const chrono::time_point<__file_clock, _Dur>& __t) noexcept
 {
   using _CDur = common_type_t<_Dur, chrono::seconds>;
   using __sys_time = chrono::time_point<__sys_clock, _CDur>;
   return __sys_time{__t.time_since_epoch()} + _S_epoch_diff;
 }
    };
  }



}
# 42 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/chrono" 2 3



# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/sstream" 1 3
# 37 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/sstream" 3



# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/istream" 1 3
# 37 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/istream" 3






namespace std __attribute__ ((__visibility__ ("default")))
{
# 59 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/istream" 3
  template<typename _CharT, typename _Traits>
    class basic_istream : virtual public basic_ios<_CharT, _Traits>
    {
    public:

      typedef _CharT char_type;
      typedef typename _Traits::int_type int_type;
      typedef typename _Traits::pos_type pos_type;
      typedef typename _Traits::off_type off_type;
      typedef _Traits traits_type;


      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
      typedef basic_ios<_CharT, _Traits> __ios_type;
      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> >
        __num_get_type;
      typedef ctype<_CharT> __ctype_type;

    protected:





      streamsize _M_gcount;

    public:







      explicit
      basic_istream(__streambuf_type* __sb)
      : _M_gcount(streamsize(0))
      { this->init(__sb); }






      virtual
      ~basic_istream()
      { _M_gcount = streamsize(0); }


      class sentry;
      friend class sentry;
# 121 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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;
      }
# 169 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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); }
# 215 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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); }
# 324 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/istream" 3
      __istream_type&
      operator>>(void*& __p)
      { return _M_extract(__p); }
# 348 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/istream" 3
      __istream_type&
      operator>>(__streambuf_type* __sb);
# 358 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/istream" 3
      streamsize
      gcount() const
      { return _M_gcount; }
# 391 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/istream" 3
      int_type
      get();
# 405 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/istream" 3
      __istream_type&
      get(char_type& __c);
# 432 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/istream" 3
      __istream_type&
      get(char_type* __s, streamsize __n, char_type __delim);
# 443 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/istream" 3
      __istream_type&
      get(char_type* __s, streamsize __n)
      { return this->get(__s, __n, this->widen('\n')); }
# 466 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/istream" 3
      __istream_type&
      get(__streambuf_type& __sb, char_type __delim);
# 476 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/istream" 3
      __istream_type&
      get(__streambuf_type& __sb)
      { return this->get(__sb, this->widen('\n')); }
# 505 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/istream" 3
      __istream_type&
      getline(char_type* __s, streamsize __n, char_type __delim);
# 516 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/istream" 3
      __istream_type&
      getline(char_type* __s, streamsize __n)
      { return this->getline(__s, __n, this->widen('\n')); }
# 540 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/istream" 3
      __istream_type&
      ignore(streamsize __n, int_type __delim);

      __istream_type&
      ignore(streamsize __n);

      __istream_type&
      ignore();
# 557 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/istream" 3
      int_type
      peek();
# 575 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/istream" 3
      __istream_type&
      read(char_type* __s, streamsize __n);
# 594 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/istream" 3
      streamsize
      readsome(char_type* __s, streamsize __n);
# 611 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/istream" 3
      __istream_type&
      putback(char_type __c);
# 627 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/istream" 3
      __istream_type&
      unget();
# 645 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/istream" 3
      int
      sync();
# 660 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/istream" 3
      pos_type
      tellg();
# 675 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/istream" 3
      __istream_type&
      seekg(pos_type);
# 691 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/istream" 3
      __istream_type&
      seekg(off_type, ios_base::seekdir);


    protected:
      basic_istream()
      : _M_gcount(streamsize(0))
      { this->init(0); }


      basic_istream(const basic_istream&) = delete;

      basic_istream(basic_istream&& __rhs)
      : __ios_type(), _M_gcount(__rhs._M_gcount)
      {
 __ios_type::move(__rhs);
 __rhs._M_gcount = 0;
      }



      basic_istream& operator=(const basic_istream&) = delete;

      basic_istream&
      operator=(basic_istream&& __rhs)
      {
 swap(__rhs);
 return *this;
      }

      void
      swap(basic_istream& __rhs)
      {
 __ios_type::swap(__rhs);
 std::swap(_M_gcount, __rhs._M_gcount);
      }


      template<typename _ValueT>
 __istream_type&
 _M_extract(_ValueT& __v);
    };


  template<>
    basic_istream<char>&
    basic_istream<char>::
    getline(char_type* __s, streamsize __n, char_type __delim);

  template<>
    basic_istream<char>&
    basic_istream<char>::
    ignore(streamsize __n);

  template<>
    basic_istream<char>&
    basic_istream<char>::
    ignore(streamsize __n, int_type __delim);


  template<>
    basic_istream<wchar_t>&
    basic_istream<wchar_t>::
    getline(char_type* __s, streamsize __n, char_type __delim);

  template<>
    basic_istream<wchar_t>&
    basic_istream<wchar_t>::
    ignore(streamsize __n);

  template<>
    basic_istream<wchar_t>&
    basic_istream<wchar_t>::
    ignore(streamsize __n, int_type __delim);
# 775 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/istream" 3
  template<typename _CharT, typename _Traits>
    class basic_istream<_CharT, _Traits>::sentry
    {

      bool _M_ok;

    public:

      typedef _Traits traits_type;
      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef typename __istream_type::__ctype_type __ctype_type;
      typedef typename _Traits::int_type __int_type;
# 811 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/istream" 3
      explicit
      sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false);
# 822 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/istream" 3
      explicit

      operator bool() const
      { return _M_ok; }
    };
# 840 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/istream" 3
  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c);

  template<class _Traits>
    inline basic_istream<char, _Traits>&
    operator>>(basic_istream<char, _Traits>& __in, unsigned char& __c)
    { return (__in >> reinterpret_cast<char&>(__c)); }

  template<class _Traits>
    inline basic_istream<char, _Traits>&
    operator>>(basic_istream<char, _Traits>& __in, signed char& __c)
    { return (__in >> reinterpret_cast<char&>(__c)); }



  template<typename _CharT, typename _Traits>
    void
    __istream_extract(basic_istream<_CharT, _Traits>&, _CharT*, streamsize);

  void __istream_extract(istream&, char*, streamsize);
# 947 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/istream" 3
  template<typename _CharT, typename _Traits, size_t _Num>
    inline basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT (&__s)[_Num])
    {
      static_assert(_Num <= __gnu_cxx::__numeric_traits<streamsize>::__max);
      std::__istream_extract(__in, __s, _Num);
      return __in;
    }

  template<class _Traits, size_t _Num>
    inline basic_istream<char, _Traits>&
    operator>>(basic_istream<char, _Traits>& __in, unsigned char (&__s)[_Num])
    { return __in >> reinterpret_cast<char(&)[_Num]>(__s); }

  template<class _Traits, size_t _Num>
    inline basic_istream<char, _Traits>&
    operator>>(basic_istream<char, _Traits>& __in, signed char (&__s)[_Num])
    { return __in >> reinterpret_cast<char(&)[_Num]>(__s); }
# 979 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/istream" 3
  template<typename _CharT, typename _Traits>
    class basic_iostream
    : public basic_istream<_CharT, _Traits>,
      public basic_ostream<_CharT, _Traits>
    {
    public:



      typedef _CharT char_type;
      typedef typename _Traits::int_type int_type;
      typedef typename _Traits::pos_type pos_type;
      typedef typename _Traits::off_type off_type;
      typedef _Traits traits_type;


      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef basic_ostream<_CharT, _Traits> __ostream_type;







      explicit
      basic_iostream(basic_streambuf<_CharT, _Traits>* __sb)
      : __istream_type(__sb), __ostream_type(__sb) { }




      virtual
      ~basic_iostream() { }

    protected:
      basic_iostream()
      : __istream_type(), __ostream_type() { }


      basic_iostream(const basic_iostream&) = delete;

      basic_iostream(basic_iostream&& __rhs)
      : __istream_type(std::move(__rhs)), __ostream_type(*this)
      { }



      basic_iostream& operator=(const basic_iostream&) = delete;

      basic_iostream&
      operator=(basic_iostream&& __rhs)
      {
 swap(__rhs);
 return *this;
      }

      void
      swap(basic_iostream& __rhs)
      { __istream_type::swap(__rhs); }

    };
# 1062 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/istream" 3
  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    ws(basic_istream<_CharT, _Traits>& __is);
# 1073 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/istream" 3
  template<typename _Is, typename _Tp>
    requires __derived_from_ios_base<_Is>
      && requires (_Is& __is, _Tp&& __t) { __is >> std::forward<_Tp>(__t); }
    using __rvalue_stream_extraction_t = _Is&&;
# 1094 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/istream" 3
  template<typename _Istream, typename _Tp>
    inline __rvalue_stream_extraction_t<_Istream, _Tp>
    operator>>(_Istream&& __is, _Tp&& __x)
    {
      __is >> std::forward<_Tp>(__x);
      return std::move(__is);
    }



}

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/istream.tcc" 1 3
# 38 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/istream.tcc" 3



namespace std __attribute__ ((__visibility__ ("default")))
{


  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>::sentry::
    sentry(basic_istream<_CharT, _Traits>& __in, bool __noskip) : _M_ok(false)
    {
      ios_base::iostate __err = ios_base::goodbit;
      if (__in.good())
 {
   try
     {
       if (__in.tie())
  __in.tie()->flush();
       if (!__noskip && bool(__in.flags() & ios_base::skipws))
  {
    const __int_type __eof = traits_type::eof();
    __streambuf_type* __sb = __in.rdbuf();
    __int_type __c = __sb->sgetc();

    const __ctype_type& __ct = __check_facet(__in._M_ctype);
    while (!traits_type::eq_int_type(__c, __eof)
    && __ct.is(ctype_base::space,
        traits_type::to_char_type(__c)))
      __c = __sb->snextc();




    if (traits_type::eq_int_type(__c, __eof))
      __err |= ios_base::eofbit;
  }
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       __in._M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { __in._M_setstate(ios_base::badbit); }
 }

      if (__in.good() && __err == ios_base::goodbit)
 _M_ok = true;
      else
 {
   __err |= ios_base::failbit;
   __in.setstate(__err);
 }
    }

  template<typename _CharT, typename _Traits>
    template<typename _ValueT>
      basic_istream<_CharT, _Traits>&
      basic_istream<_CharT, _Traits>::
      _M_extract(_ValueT& __v)
      {
 sentry __cerb(*this, false);
 if (__cerb)
   {
     ios_base::iostate __err = ios_base::goodbit;
     try
       {

  const __num_get_type& __ng = __check_facet(this->_M_num_get);




  __ng.get(*this, 0, *this, __err, __v);
       }
     catch(__cxxabiv1::__forced_unwind&)
       {
  this->_M_setstate(ios_base::badbit);
  throw;
       }
     catch(...)
       { this->_M_setstate(ios_base::badbit); }
     if (__err)
       this->setstate(__err);
   }
 return *this;
      }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(short& __n)
    {


      sentry __cerb(*this, false);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {
       long __l;

       const __num_get_type& __ng = __check_facet(this->_M_num_get);




       __ng.get(*this, 0, *this, __err, __l);



       if (__l < __gnu_cxx::__numeric_traits<short>::__min)
  {
    __err |= ios_base::failbit;
    __n = __gnu_cxx::__numeric_traits<short>::__min;
  }
       else if (__l > __gnu_cxx::__numeric_traits<short>::__max)
  {
    __err |= ios_base::failbit;
    __n = __gnu_cxx::__numeric_traits<short>::__max;
  }
       else
  __n = short(__l);
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(int& __n)
    {


      sentry __cerb(*this, false);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {
       long __l;

       const __num_get_type& __ng = __check_facet(this->_M_num_get);




       __ng.get(*this, 0, *this, __err, __l);



       if (__l < __gnu_cxx::__numeric_traits<int>::__min)
  {
    __err |= ios_base::failbit;
    __n = __gnu_cxx::__numeric_traits<int>::__min;
  }
       else if (__l > __gnu_cxx::__numeric_traits<int>::__max)
  {
    __err |= ios_base::failbit;
    __n = __gnu_cxx::__numeric_traits<int>::__max;
  }
       else
  __n = int(__l);
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    operator>>(__streambuf_type* __sbout)
    {
      ios_base::iostate __err = ios_base::goodbit;
      sentry __cerb(*this, false);
      if (__cerb && __sbout)
 {
   try
     {
       bool __ineof;
       if (!__copy_streambufs_eof(this->rdbuf(), __sbout, __ineof))
  __err |= ios_base::failbit;
       if (__ineof)
  __err |= ios_base::eofbit;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::failbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::failbit); }
 }
      else if (!__sbout)
 __err |= ios_base::failbit;
      if (__err)
 this->setstate(__err);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    typename basic_istream<_CharT, _Traits>::int_type
    basic_istream<_CharT, _Traits>::
    get(void)
    {
      const int_type __eof = traits_type::eof();
      int_type __c = __eof;
      _M_gcount = 0;
      ios_base::iostate __err = ios_base::goodbit;
      sentry __cerb(*this, true);
      if (__cerb)
 {
   try
     {
       __c = this->rdbuf()->sbumpc();

       if (!traits_type::eq_int_type(__c, __eof))
  _M_gcount = 1;
       else
  __err |= ios_base::eofbit;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
 }
      if (!_M_gcount)
 __err |= ios_base::failbit;
      if (__err)
 this->setstate(__err);
      return __c;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    get(char_type& __c)
    {
      _M_gcount = 0;
      ios_base::iostate __err = ios_base::goodbit;
      sentry __cerb(*this, true);
      if (__cerb)
 {
   try
     {
       const int_type __cb = this->rdbuf()->sbumpc();

       if (!traits_type::eq_int_type(__cb, traits_type::eof()))
  {
    _M_gcount = 1;
    __c = traits_type::to_char_type(__cb);
  }
       else
  __err |= ios_base::eofbit;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
 }
      if (!_M_gcount)
 __err |= ios_base::failbit;
      if (__err)
 this->setstate(__err);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    get(char_type* __s, streamsize __n, char_type __delim)
    {
      _M_gcount = 0;
      ios_base::iostate __err = ios_base::goodbit;
      sentry __cerb(*this, true);
      if (__cerb)
 {
   try
     {
       const int_type __idelim = traits_type::to_int_type(__delim);
       const int_type __eof = traits_type::eof();
       __streambuf_type* __sb = this->rdbuf();
       int_type __c = __sb->sgetc();

       while (_M_gcount + 1 < __n
       && !traits_type::eq_int_type(__c, __eof)
       && !traits_type::eq_int_type(__c, __idelim))
  {
    *__s++ = traits_type::to_char_type(__c);
    ++_M_gcount;
    __c = __sb->snextc();
  }
       if (traits_type::eq_int_type(__c, __eof))
  __err |= ios_base::eofbit;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
 }


      if (__n > 0)
 *__s = char_type();
      if (!_M_gcount)
 __err |= ios_base::failbit;
      if (__err)
 this->setstate(__err);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    get(__streambuf_type& __sb, char_type __delim)
    {
      _M_gcount = 0;
      ios_base::iostate __err = ios_base::goodbit;
      sentry __cerb(*this, true);
      if (__cerb)
 {
   try
     {
       const int_type __idelim = traits_type::to_int_type(__delim);
       const int_type __eof = traits_type::eof();
       __streambuf_type* __this_sb = this->rdbuf();
       int_type __c = __this_sb->sgetc();
       char_type __c2 = traits_type::to_char_type(__c);
       unsigned long long __gcount = 0;

       while (!traits_type::eq_int_type(__c, __eof)
       && !traits_type::eq_int_type(__c, __idelim)
       && !traits_type::eq_int_type(__sb.sputc(__c2), __eof))
  {
    ++__gcount;
    __c = __this_sb->snextc();
    __c2 = traits_type::to_char_type(__c);
  }
       if (traits_type::eq_int_type(__c, __eof))
  __err |= ios_base::eofbit;


       if (__gcount <= __gnu_cxx::__numeric_traits<streamsize>::__max)
  _M_gcount = __gcount;
       else
  _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
 }
      if (!_M_gcount)
 __err |= ios_base::failbit;
      if (__err)
 this->setstate(__err);
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    getline(char_type* __s, streamsize __n, char_type __delim)
    {
      _M_gcount = 0;
      ios_base::iostate __err = ios_base::goodbit;
      sentry __cerb(*this, true);
      if (__cerb)
        {
          try
            {
              const int_type __idelim = traits_type::to_int_type(__delim);
              const int_type __eof = traits_type::eof();
              __streambuf_type* __sb = this->rdbuf();
              int_type __c = __sb->sgetc();

              while (_M_gcount + 1 < __n
                     && !traits_type::eq_int_type(__c, __eof)
                     && !traits_type::eq_int_type(__c, __idelim))
                {
                  *__s++ = traits_type::to_char_type(__c);
                  __c = __sb->snextc();
                  ++_M_gcount;
                }
              if (traits_type::eq_int_type(__c, __eof))
                __err |= ios_base::eofbit;
              else
                {
                  if (traits_type::eq_int_type(__c, __idelim))
                    {
                      __sb->sbumpc();
                      ++_M_gcount;
                    }
                  else
                    __err |= ios_base::failbit;
                }
            }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
          catch(...)
            { this->_M_setstate(ios_base::badbit); }
        }


      if (__n > 0)
 *__s = char_type();
      if (!_M_gcount)
        __err |= ios_base::failbit;
      if (__err)
        this->setstate(__err);
      return *this;
    }




  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    ignore(void)
    {
      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {
       const int_type __eof = traits_type::eof();
       __streambuf_type* __sb = this->rdbuf();

       if (traits_type::eq_int_type(__sb->sbumpc(), __eof))
  __err |= ios_base::eofbit;
       else
  _M_gcount = 1;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    ignore(streamsize __n)
    {
      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb && __n > 0)
        {
          ios_base::iostate __err = ios_base::goodbit;
          try
            {
              const int_type __eof = traits_type::eof();
              __streambuf_type* __sb = this->rdbuf();
              int_type __c = __sb->sgetc();
# 545 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/istream.tcc" 3
       bool __large_ignore = false;
       while (true)
  {
    while (_M_gcount < __n
    && !traits_type::eq_int_type(__c, __eof))
      {
        ++_M_gcount;
        __c = __sb->snextc();
      }
    if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
        && !traits_type::eq_int_type(__c, __eof))
      {
        _M_gcount =
   __gnu_cxx::__numeric_traits<streamsize>::__min;
        __large_ignore = true;
      }
    else
      break;
  }

       if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max)
  {
    if (__large_ignore)
      _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;

    if (traits_type::eq_int_type(__c, __eof))
      __err |= ios_base::eofbit;
  }
       else if (_M_gcount < __n)
  {
    if (traits_type::eq_int_type(__c, __eof))
      __err |= ios_base::eofbit;
  }
            }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
          catch(...)
            { this->_M_setstate(ios_base::badbit); }
          if (__err)
            this->setstate(__err);
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    ignore(streamsize __n, int_type __delim)
    {
      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb && __n > 0)
        {
          ios_base::iostate __err = ios_base::goodbit;
          try
            {
              const int_type __eof = traits_type::eof();
              __streambuf_type* __sb = this->rdbuf();
              int_type __c = __sb->sgetc();


       bool __large_ignore = false;
       while (true)
  {
    while (_M_gcount < __n
    && !traits_type::eq_int_type(__c, __eof)
    && !traits_type::eq_int_type(__c, __delim))
      {
        ++_M_gcount;
        __c = __sb->snextc();
      }
    if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max
        && !traits_type::eq_int_type(__c, __eof)
        && !traits_type::eq_int_type(__c, __delim))
      {
        _M_gcount =
   __gnu_cxx::__numeric_traits<streamsize>::__min;
        __large_ignore = true;
      }
    else
      break;
  }

       if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max)
  {
    if (__large_ignore)
      _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max;

    if (traits_type::eq_int_type(__c, __eof))
      __err |= ios_base::eofbit;
    else
      {
        if (_M_gcount != __n)
   ++_M_gcount;
        __sb->sbumpc();
      }
  }
       else if (_M_gcount < __n)
  {
    if (traits_type::eq_int_type(__c, __eof))
      __err |= ios_base::eofbit;
    else
      {
        ++_M_gcount;
        __sb->sbumpc();
      }
  }
            }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
          catch(...)
            { this->_M_setstate(ios_base::badbit); }
          if (__err)
            this->setstate(__err);
        }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    typename basic_istream<_CharT, _Traits>::int_type
    basic_istream<_CharT, _Traits>::
    peek(void)
    {
      int_type __c = traits_type::eof();
      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {
       __c = this->rdbuf()->sgetc();
       if (traits_type::eq_int_type(__c, traits_type::eof()))
  __err |= ios_base::eofbit;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return __c;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    read(char_type* __s, streamsize __n)
    {
      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {
       _M_gcount = this->rdbuf()->sgetn(__s, __n);
       if (_M_gcount != __n)
  __err |= (ios_base::eofbit | ios_base::failbit);
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    streamsize
    basic_istream<_CharT, _Traits>::
    readsome(char_type* __s, streamsize __n)
    {
      _M_gcount = 0;
      sentry __cerb(*this, true);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {

       const streamsize __num = this->rdbuf()->in_avail();
       if (__num > 0)
  _M_gcount = this->rdbuf()->sgetn(__s, std::min(__num, __n));
       else if (__num == -1)
  __err |= ios_base::eofbit;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return _M_gcount;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    putback(char_type __c)
    {


      _M_gcount = 0;

      this->clear(this->rdstate() & ~ios_base::eofbit);
      sentry __cerb(*this, true);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {
       const int_type __eof = traits_type::eof();
       __streambuf_type* __sb = this->rdbuf();
       if (!__sb
    || traits_type::eq_int_type(__sb->sputbackc(__c), __eof))
  __err |= ios_base::badbit;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    unget(void)
    {


      _M_gcount = 0;

      this->clear(this->rdstate() & ~ios_base::eofbit);
      sentry __cerb(*this, true);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {
       const int_type __eof = traits_type::eof();
       __streambuf_type* __sb = this->rdbuf();
       if (!__sb
    || traits_type::eq_int_type(__sb->sungetc(), __eof))
  __err |= ios_base::badbit;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    int
    basic_istream<_CharT, _Traits>::
    sync(void)
    {


      int __ret = -1;
      sentry __cerb(*this, true);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {
       __streambuf_type* __sb = this->rdbuf();
       if (__sb)
  {
    if (__sb->pubsync() == -1)
      __err |= ios_base::badbit;
    else
      __ret = 0;
  }
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    typename basic_istream<_CharT, _Traits>::pos_type
    basic_istream<_CharT, _Traits>::
    tellg(void)
    {


      pos_type __ret = pos_type(-1);
      sentry __cerb(*this, true);
      if (__cerb)
 {
   try
     {
       if (!this->fail())
  __ret = this->rdbuf()->pubseekoff(0, ios_base::cur,
        ios_base::in);
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
 }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    seekg(pos_type __pos)
    {



      this->clear(this->rdstate() & ~ios_base::eofbit);
      sentry __cerb(*this, true);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {
       if (!this->fail())
  {

    const pos_type __p = this->rdbuf()->pubseekpos(__pos,
         ios_base::in);


    if (__p == pos_type(off_type(-1)))
      __err |= ios_base::failbit;
  }
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    basic_istream<_CharT, _Traits>::
    seekg(off_type __off, ios_base::seekdir __dir)
    {



      this->clear(this->rdstate() & ~ios_base::eofbit);
      sentry __cerb(*this, true);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {
       if (!this->fail())
  {

    const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir,
         ios_base::in);


    if (__p == pos_type(off_type(-1)))
      __err |= ios_base::failbit;
  }
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       this->_M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { this->_M_setstate(ios_base::badbit); }
   if (__err)
     this->setstate(__err);
 }
      return *this;
    }


  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c)
    {
      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef typename __istream_type::int_type __int_type;

      typename __istream_type::sentry __cerb(__in, false);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {
       const __int_type __cb = __in.rdbuf()->sbumpc();
       if (!_Traits::eq_int_type(__cb, _Traits::eof()))
  __c = _Traits::to_char_type(__cb);
       else
  __err |= (ios_base::eofbit | ios_base::failbit);
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       __in._M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { __in._M_setstate(ios_base::badbit); }
   if (__err)
     __in.setstate(__err);
 }
      return __in;
    }

  template<typename _CharT, typename _Traits>
    void
    __istream_extract(basic_istream<_CharT, _Traits>& __in, _CharT* __s,
        streamsize __num)
    {
      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 __width = __in.width();
       if (0 < __width && __width < __num)
  __num = __width;

       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 (__extracted < __num - 1
    && _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);
    }


  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    ws(basic_istream<_CharT, _Traits>& __in)
    {
      typedef basic_istream<_CharT, _Traits> __istream_type;
      typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
      typedef typename __istream_type::int_type __int_type;
      typedef ctype<_CharT> __ctype_type;



      typename __istream_type::sentry __cerb(__in, true);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {
       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 (true)
  {
    if (_Traits::eq_int_type(__c, __eof))
      {
        __err = ios_base::eofbit;
        break;
      }
    if (!__ct.is(ctype_base::space, _Traits::to_char_type(__c)))
      break;
    __c = __sb->snextc();
  }
     }
   catch(const __cxxabiv1::__forced_unwind&)
     {
       __in._M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     {
       __in._M_setstate(ios_base::badbit);
     }
   if (__err)
     __in.setstate(__err);
 }
      return __in;
    }




  extern template class basic_istream<char>;
  extern template istream& ws(istream&);
  extern template istream& operator>>(istream&, char&);
  extern template istream& operator>>(istream&, unsigned char&);
  extern template istream& operator>>(istream&, signed char&);

  extern template istream& istream::_M_extract(unsigned short&);
  extern template istream& istream::_M_extract(unsigned int&);
  extern template istream& istream::_M_extract(long&);
  extern template istream& istream::_M_extract(unsigned long&);
  extern template istream& istream::_M_extract(bool&);

  extern template istream& istream::_M_extract(long long&);
  extern template istream& istream::_M_extract(unsigned long long&);

  extern template istream& istream::_M_extract(float&);
  extern template istream& istream::_M_extract(double&);
  extern template istream& istream::_M_extract(long double&);
  extern template istream& istream::_M_extract(void*&);

  extern template class basic_iostream<char>;


  extern template class basic_istream<wchar_t>;
  extern template wistream& ws(wistream&);
  extern template wistream& operator>>(wistream&, wchar_t&);
  extern template void __istream_extract(wistream&, wchar_t*, streamsize);

  extern template wistream& wistream::_M_extract(unsigned short&);
  extern template wistream& wistream::_M_extract(unsigned int&);
  extern template wistream& wistream::_M_extract(long&);
  extern template wistream& wistream::_M_extract(unsigned long&);
  extern template wistream& wistream::_M_extract(bool&);

  extern template wistream& wistream::_M_extract(long long&);
  extern template wistream& wistream::_M_extract(unsigned long long&);

  extern template wistream& wistream::_M_extract(float&);
  extern template wistream& wistream::_M_extract(double&);
  extern template wistream& wistream::_M_extract(long double&);
  extern template wistream& wistream::_M_extract(void*&);

  extern template class basic_iostream<wchar_t>;




}
# 1107 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/istream" 2 3
# 41 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/sstream" 2 3
# 55 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/sstream" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

namespace __cxx11 {
# 78 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/sstream" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    class basic_stringbuf : public basic_streambuf<_CharT, _Traits>
    {
      struct __xfer_bufptrs;


      using allocator_traits = std::allocator_traits<_Alloc>;
      using _Noexcept_swap
 = __or_<typename allocator_traits::propagate_on_container_swap,
  typename allocator_traits::is_always_equal>;


    public:

      typedef _CharT char_type;
      typedef _Traits traits_type;


      typedef _Alloc allocator_type;
      typedef typename traits_type::int_type int_type;
      typedef typename traits_type::pos_type pos_type;
      typedef typename traits_type::off_type off_type;

      typedef basic_streambuf<char_type, traits_type> __streambuf_type;
      typedef basic_string<char_type, _Traits, _Alloc> __string_type;
      typedef typename __string_type::size_type __size_type;

    protected:

      ios_base::openmode _M_mode;


      __string_type _M_string;

    public:
# 121 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/sstream" 3
      basic_stringbuf()
      : __streambuf_type(), _M_mode(ios_base::in | ios_base::out), _M_string()
      { }
# 132 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/sstream" 3
      explicit
      basic_stringbuf(ios_base::openmode __mode)
      : __streambuf_type(), _M_mode(__mode), _M_string()
      { }
# 145 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/sstream" 3
      explicit
      basic_stringbuf(const __string_type& __str,
        ios_base::openmode __mode = ios_base::in | ios_base::out)
      : __streambuf_type(), _M_mode(),
 _M_string(__str.data(), __str.size(), __str.get_allocator())
      { _M_stringbuf_init(__mode); }


      basic_stringbuf(const basic_stringbuf&) = delete;

      basic_stringbuf(basic_stringbuf&& __rhs)
      : basic_stringbuf(std::move(__rhs), __xfer_bufptrs(__rhs, this))
      { __rhs._M_sync(const_cast<char_type*>(__rhs._M_string.data()), 0, 0); }


      explicit
      basic_stringbuf(const allocator_type& __a)
      : basic_stringbuf(ios_base::in | std::ios_base::out, __a)
      { }

      basic_stringbuf(ios_base::openmode __mode,
        const allocator_type& __a)
      : __streambuf_type(), _M_mode(__mode), _M_string(__a)
      { }

      explicit
      basic_stringbuf(__string_type&& __s,
        ios_base::openmode __mode = ios_base::in
        | ios_base::out)
      : __streambuf_type(), _M_mode(__mode), _M_string(std::move(__s))
      { _M_stringbuf_init(__mode); }

      template<typename _SAlloc>
 basic_stringbuf(const basic_string<_CharT, _Traits, _SAlloc>& __s,
   const allocator_type& __a)
 : basic_stringbuf(__s, ios_base::in | std::ios_base::out, __a)
 { }

      template<typename _SAlloc>
 basic_stringbuf(const basic_string<_CharT, _Traits, _SAlloc>& __s,
   ios_base::openmode __mode,
   const allocator_type& __a)
 : __streambuf_type(), _M_mode(__mode),
   _M_string(__s.data(), __s.size(), __a)
 { _M_stringbuf_init(__mode); }

      template<typename _SAlloc>
 explicit
 basic_stringbuf(const basic_string<_CharT, _Traits, _SAlloc>& __s,
   ios_base::openmode __mode = ios_base::in
          | ios_base::out)
 : basic_stringbuf(__s, __mode, allocator_type{})
 { }

      basic_stringbuf(basic_stringbuf&& __rhs, const allocator_type& __a)
      : basic_stringbuf(std::move(__rhs), __a, __xfer_bufptrs(__rhs, this))
      { __rhs._M_sync(const_cast<char_type*>(__rhs._M_string.data()), 0, 0); }

      allocator_type get_allocator() const noexcept
      { return _M_string.get_allocator(); }




      basic_stringbuf&
      operator=(const basic_stringbuf&) = delete;

      basic_stringbuf&
      operator=(basic_stringbuf&& __rhs)
      {
 __xfer_bufptrs __st{__rhs, this};
 const __streambuf_type& __base = __rhs;
 __streambuf_type::operator=(__base);
 this->pubimbue(__rhs.getloc());
 _M_mode = __rhs._M_mode;
 _M_string = std::move(__rhs._M_string);
 __rhs._M_sync(const_cast<char_type*>(__rhs._M_string.data()), 0, 0);
 return *this;
      }

      void
      swap(basic_stringbuf& __rhs) noexcept(_Noexcept_swap::value)
      {
 __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);
      }
# 248 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/sstream" 3
      __string_type
      str() const &
      {
 __string_type __ret(_M_string.get_allocator());
 if (char_type* __hi = _M_high_mark())
   __ret.assign(this->pbase(), __hi);
 else
   __ret = _M_string;
 return __ret;
      }




      template<__allocator_like _SAlloc>
 basic_string<_CharT, _Traits, _SAlloc>
 str(const _SAlloc& __sa) const
 {
   auto __sv = view();
   return { __sv.data(), __sv.size(), __sa };
 }


      __string_type
      str() &&
      {
 if (char_type* __hi = _M_high_mark())
   {

     _M_string._M_set_length(_M_high_mark() - this->pbase());
   }
 auto __str = std::move(_M_string);
 _M_string.clear();
 _M_sync(_M_string.data(), 0, 0);
 return __str;
      }



      basic_string_view<char_type, traits_type>
      view() const noexcept
      {
 if (char_type* __hi = _M_high_mark())
   return { this->pbase(), __hi };
 else
   return _M_string;
      }
# 304 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/sstream" 3
      void
      str(const __string_type& __s)
      {


 _M_string.assign(__s.data(), __s.size());
 _M_stringbuf_init(_M_mode);
      }



      template<__allocator_like _SAlloc>
 requires (!is_same_v<_SAlloc, _Alloc>)
 void
 str(const basic_string<_CharT, _Traits, _SAlloc>& __s)
 {
   _M_string.assign(__s.data(), __s.size());
   _M_stringbuf_init(_M_mode);
 }


      void
      str(__string_type&& __s)
      {
 _M_string = std::move(__s);
 _M_stringbuf_init(_M_mode);
      }


    protected:

      void
      _M_stringbuf_init(ios_base::openmode __mode)
      {
 _M_mode = __mode;
 __size_type __len = 0;
 if (_M_mode & (ios_base::ate | ios_base::app))
   __len = _M_string.size();
 _M_sync(const_cast<char_type*>(_M_string.data()), 0, __len);
      }

      virtual streamsize
      showmanyc()
      {
 streamsize __ret = -1;
 if (_M_mode & ios_base::in)
   {
     _M_update_egptr();
     __ret = this->egptr() - this->gptr();
   }
 return __ret;
      }

      virtual int_type
      underflow();

      virtual int_type
      pbackfail(int_type __c = traits_type::eof());

      virtual int_type
      overflow(int_type __c = traits_type::eof());
# 377 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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()
      {
 if (char_type* __pptr = this->pptr())
   {
     char_type* __egptr = this->egptr();
     if (!__egptr || __pptr > __egptr)
       {
  if (_M_mode & ios_base::in)
    this->setg(this->eback(), this->gptr(), __pptr);
  else
    this->setg(__pptr, __pptr, __pptr);
       }
   }
      }



      void
      _M_pbump(char_type* __pbeg, char_type* __pend, off_type __off);

    private:




      __attribute__((__always_inline__))
      char_type*
      _M_high_mark() const noexcept
      {
 if (char_type* __pptr = this->pptr())
   {
     char_type* __egptr = this->egptr();
     if (!__egptr || __pptr > __egptr)
       return __pptr;
     else
       return __egptr;
   }
 return 0;
      }





      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 (!__end || __from.pptr() > __end)
  __end = __from.pptr();
     }


   if (__end)
     {


       auto& __mut_from = const_cast<basic_stringbuf&>(__from);
       __mut_from._M_string._M_length(__end - __str);
     }
 }

 ~__xfer_bufptrs()
 {
   char_type* __str = const_cast<char_type*>(_M_to->_M_string.data());
   if (_M_goff[0] != -1)
     _M_to->setg(__str+_M_goff[0], __str+_M_goff[1], __str+_M_goff[2]);
   if (_M_poff[0] != -1)
     _M_to->_M_pbump(__str+_M_poff[0], __str+_M_poff[2], _M_poff[1]);
 }

 basic_stringbuf* _M_to;
 off_type _M_goff[3];
 off_type _M_poff[3];
      };
# 513 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/sstream" 3
      basic_stringbuf(basic_stringbuf&& __rhs, __xfer_bufptrs&&)
      : __streambuf_type(static_cast<const __streambuf_type&>(__rhs)),
      _M_mode(__rhs._M_mode), _M_string(std::move(__rhs._M_string))
      { }




      basic_stringbuf(basic_stringbuf&& __rhs, const allocator_type& __a,
        __xfer_bufptrs&&)
      : __streambuf_type(static_cast<const __streambuf_type&>(__rhs)),
      _M_mode(__rhs._M_mode), _M_string(std::move(__rhs._M_string), __a)
      { }


    };
# 546 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/sstream" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    class basic_istringstream : public basic_istream<_CharT, _Traits>
    {
    public:

      typedef _CharT char_type;
      typedef _Traits traits_type;


      typedef _Alloc allocator_type;
      typedef typename traits_type::int_type int_type;
      typedef typename traits_type::pos_type pos_type;
      typedef typename traits_type::off_type off_type;


      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
      typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
      typedef basic_istream<char_type, traits_type> __istream_type;

    private:
      __stringbuf_type _M_stringbuf;

    public:
# 580 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/sstream" 3
      basic_istringstream()
      : __istream_type(), _M_stringbuf(ios_base::in)
      { this->init(&_M_stringbuf); }
# 596 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/sstream" 3
      explicit
      basic_istringstream(ios_base::openmode __mode)
      : __istream_type(), _M_stringbuf(__mode | ios_base::in)
      { this->init(&_M_stringbuf); }
# 614 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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(ios_base::openmode __mode, const allocator_type& __a)
      : __istream_type(), _M_stringbuf(__mode | ios_base::in, __a)
      { this->init(std::__addressof(_M_stringbuf)); }

      explicit
      basic_istringstream(__string_type&& __str,
     ios_base::openmode __mode = ios_base::in)
      : __istream_type(), _M_stringbuf(std::move(__str), __mode | ios_base::in)
      { this->init(std::__addressof(_M_stringbuf)); }

      template<typename _SAlloc>
 basic_istringstream(const basic_string<_CharT, _Traits, _SAlloc>& __str,
       const allocator_type& __a)
 : basic_istringstream(__str, ios_base::in, __a)
 { }

      template<typename _SAlloc>
 basic_istringstream(const basic_string<_CharT, _Traits, _SAlloc>& __str,
       ios_base::openmode __mode,
       const allocator_type& __a)
 : __istream_type(), _M_stringbuf(__str, __mode | ios_base::in, __a)
 { this->init(std::__addressof(_M_stringbuf)); }

      template<typename _SAlloc>
 explicit
 basic_istringstream(const basic_string<_CharT, _Traits, _SAlloc>& __str,
       ios_base::openmode __mode = ios_base::in)
 : basic_istringstream(__str, __mode, allocator_type())
 { }




      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);
      }
# 697 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/sstream" 3
      __stringbuf_type*
      rdbuf() const
      { return const_cast<__stringbuf_type*>(&_M_stringbuf); }





      __string_type
      str() const &
      { return _M_stringbuf.str(); }




      template<__allocator_like _SAlloc>
 basic_string<_CharT, _Traits, _SAlloc>
 str(const _SAlloc& __sa) const
 { return _M_stringbuf.str(__sa); }


      __string_type
      str() &&
      { return std::move(_M_stringbuf).str(); }



      basic_string_view<char_type, traits_type>
      view() const noexcept
      { return _M_stringbuf.view(); }
# 735 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/sstream" 3
      void
      str(const __string_type& __s)
      { _M_stringbuf.str(__s); }



      template<__allocator_like _SAlloc>
 requires (!is_same_v<_SAlloc, _Alloc>)
 void
 str(const basic_string<_CharT, _Traits, _SAlloc>& __s)
 { _M_stringbuf.str(__s); }


      void
      str(__string_type&& __s)
      { _M_stringbuf.str(std::move(__s)); }

    };
# 770 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/sstream" 3
  template <typename _CharT, typename _Traits, typename _Alloc>
    class basic_ostringstream : public basic_ostream<_CharT, _Traits>
    {
    public:

      typedef _CharT char_type;
      typedef _Traits traits_type;


      typedef _Alloc allocator_type;
      typedef typename traits_type::int_type int_type;
      typedef typename traits_type::pos_type pos_type;
      typedef typename traits_type::off_type off_type;


      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
      typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
      typedef basic_ostream<char_type, traits_type> __ostream_type;

    private:
      __stringbuf_type _M_stringbuf;

    public:
# 804 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/sstream" 3
      basic_ostringstream()
      : __ostream_type(), _M_stringbuf(ios_base::out)
      { this->init(&_M_stringbuf); }
# 820 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/sstream" 3
      explicit
      basic_ostringstream(ios_base::openmode __mode)
      : __ostream_type(), _M_stringbuf(__mode | ios_base::out)
      { this->init(&_M_stringbuf); }
# 838 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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(ios_base::openmode __mode, const allocator_type& __a)
      : __ostream_type(), _M_stringbuf(__mode | ios_base::out, __a)
      { this->init(std::__addressof(_M_stringbuf)); }

      explicit
      basic_ostringstream(__string_type&& __str,
     ios_base::openmode __mode = ios_base::out)
      : __ostream_type(), _M_stringbuf(std::move(__str), __mode | ios_base::out)
      { this->init(std::__addressof(_M_stringbuf)); }

      template<typename _SAlloc>
 basic_ostringstream(const basic_string<_CharT, _Traits, _SAlloc>& __str,
       const allocator_type& __a)
 : basic_ostringstream(__str, ios_base::out, __a)
 { }

      template<typename _SAlloc>
 basic_ostringstream(const basic_string<_CharT, _Traits, _SAlloc>& __str,
       ios_base::openmode __mode,
       const allocator_type& __a)
 : __ostream_type(), _M_stringbuf(__str, __mode | ios_base::out, __a)
 { this->init(std::__addressof(_M_stringbuf)); }

      template<typename _SAlloc>
 explicit
 basic_ostringstream(const basic_string<_CharT, _Traits, _SAlloc>& __str,
       ios_base::openmode __mode = ios_base::out)
 : basic_ostringstream(__str, __mode, allocator_type())
 { }




      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);
      }
# 921 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/sstream" 3
      __stringbuf_type*
      rdbuf() const
      { return const_cast<__stringbuf_type*>(&_M_stringbuf); }





      __string_type
      str() const &
      { return _M_stringbuf.str(); }




      template<__allocator_like _SAlloc>
 basic_string<_CharT, _Traits, _SAlloc>
 str(const _SAlloc& __sa) const
 { return _M_stringbuf.str(__sa); }


      __string_type
      str() &&
      { return std::move(_M_stringbuf).str(); }



      basic_string_view<char_type, traits_type>
      view() const noexcept
      { return _M_stringbuf.view(); }
# 959 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/sstream" 3
      void
      str(const __string_type& __s)
      { _M_stringbuf.str(__s); }



      template<__allocator_like _SAlloc>
 requires (!is_same_v<_SAlloc, _Alloc>)
 void
 str(const basic_string<_CharT, _Traits, _SAlloc>& __s)
 { _M_stringbuf.str(__s); }


      void
      str(__string_type&& __s)
      { _M_stringbuf.str(std::move(__s)); }

    };
# 994 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/sstream" 3
  template <typename _CharT, typename _Traits, typename _Alloc>
    class basic_stringstream : public basic_iostream<_CharT, _Traits>
    {
    public:

      typedef _CharT char_type;
      typedef _Traits traits_type;


      typedef _Alloc allocator_type;
      typedef typename traits_type::int_type int_type;
      typedef typename traits_type::pos_type pos_type;
      typedef typename traits_type::off_type off_type;


      typedef basic_string<_CharT, _Traits, _Alloc> __string_type;
      typedef basic_stringbuf<_CharT, _Traits, _Alloc> __stringbuf_type;
      typedef basic_iostream<char_type, traits_type> __iostream_type;

    private:
      __stringbuf_type _M_stringbuf;

    public:
# 1028 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/sstream" 3
      basic_stringstream()
      : __iostream_type(), _M_stringbuf(ios_base::out | ios_base::in)
      { this->init(&_M_stringbuf); }
# 1042 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/sstream" 3
      explicit
      basic_stringstream(ios_base::openmode __m)
      : __iostream_type(), _M_stringbuf(__m)
      { this->init(&_M_stringbuf); }
# 1058 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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(ios_base::openmode __mode, const allocator_type& __a)
      : __iostream_type(), _M_stringbuf(__mode, __a)
      { this->init(&_M_stringbuf); }

      explicit
      basic_stringstream(__string_type&& __str,
    ios_base::openmode __mode = ios_base::in
           | ios_base::out)
      : __iostream_type(), _M_stringbuf(std::move(__str), __mode)
      { this->init(std::__addressof(_M_stringbuf)); }

      template<typename _SAlloc>
 basic_stringstream(const basic_string<_CharT, _Traits, _SAlloc>& __str,
      const allocator_type& __a)
 : basic_stringstream(__str, ios_base::in | ios_base::out, __a)
 { }

      template<typename _SAlloc>
 basic_stringstream(const basic_string<_CharT, _Traits, _SAlloc>& __str,
      ios_base::openmode __mode,
      const allocator_type& __a)
 : __iostream_type(), _M_stringbuf(__str, __mode, __a)
 { this->init(std::__addressof(_M_stringbuf)); }

      template<typename _SAlloc>
 explicit
 basic_stringstream(const basic_string<_CharT, _Traits, _SAlloc>& __str,
      ios_base::openmode __mode = ios_base::in
             | ios_base::out)
 : basic_stringstream(__str, __mode, allocator_type())
 { }




      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);
      }
# 1143 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/sstream" 3
      __stringbuf_type*
      rdbuf() const
      { return const_cast<__stringbuf_type*>(&_M_stringbuf); }





      __string_type
      str() const &
      { return _M_stringbuf.str(); }




      template<__allocator_like _SAlloc>
 basic_string<_CharT, _Traits, _SAlloc>
 str(const _SAlloc& __sa) const
 { return _M_stringbuf.str(__sa); }


      __string_type
      str() &&
      { return std::move(_M_stringbuf).str(); }



      basic_string_view<char_type, traits_type>
      view() const noexcept
      { return _M_stringbuf.view(); }
# 1181 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/sstream" 3
      void
      str(const __string_type& __s)
      { _M_stringbuf.str(__s); }



      template<__allocator_like _SAlloc>
 requires (!is_same_v<_SAlloc, _Alloc>)
 void
 str(const basic_string<_CharT, _Traits, _SAlloc>& __s)
 { _M_stringbuf.str(__s); }


      void
      str(__string_type&& __s)
      { _M_stringbuf.str(std::move(__s)); }

    };



  template <class _CharT, class _Traits, class _Allocator>
    inline void
    swap(basic_stringbuf<_CharT, _Traits, _Allocator>& __x,
  basic_stringbuf<_CharT, _Traits, _Allocator>& __y)
    noexcept(noexcept(__x.swap(__y)))
    { __x.swap(__y); }


  template <class _CharT, class _Traits, class _Allocator>
    inline void
    swap(basic_istringstream<_CharT, _Traits, _Allocator>& __x,
  basic_istringstream<_CharT, _Traits, _Allocator>& __y)
    { __x.swap(__y); }


  template <class _CharT, class _Traits, class _Allocator>
    inline void
    swap(basic_ostringstream<_CharT, _Traits, _Allocator>& __x,
  basic_ostringstream<_CharT, _Traits, _Allocator>& __y)
    { __x.swap(__y); }


  template <class _CharT, class _Traits, class _Allocator>
    inline void
    swap(basic_stringstream<_CharT, _Traits, _Allocator>& __x,
  basic_stringstream<_CharT, _Traits, _Allocator>& __y)
    { __x.swap(__y); }


}

}




# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/sstream.tcc" 1 3
# 38 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/sstream.tcc" 3

namespace std __attribute__ ((__visibility__ ("default")))
{


  template <class _CharT, class _Traits, class _Alloc>
    typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
    basic_stringbuf<_CharT, _Traits, _Alloc>::
    pbackfail(int_type __c)
    {
      int_type __ret = traits_type::eof();
      if (this->eback() < this->gptr())
 {


   const bool __testeof = traits_type::eq_int_type(__c, __ret);
   if (!__testeof)
     {
       const bool __testeq = traits_type::eq(traits_type::
          to_char_type(__c),
          this->gptr()[-1]);
       const bool __testout = this->_M_mode & ios_base::out;
       if (__testeq || __testout)
  {
    this->gbump(-1);
    if (!__testeq)
      *this->gptr() = traits_type::to_char_type(__c);
    __ret = __c;
  }
     }
   else
     {
       this->gbump(-1);
       __ret = traits_type::not_eof(__c);
     }
 }
      return __ret;
    }

  template <class _CharT, class _Traits, class _Alloc>
    typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
    basic_stringbuf<_CharT, _Traits, _Alloc>::
    overflow(int_type __c)
    {
      const bool __testout = this->_M_mode & ios_base::out;
      if (__builtin_expect(!__testout, false))
 return traits_type::eof();

      const bool __testeof = traits_type::eq_int_type(__c, traits_type::eof());
      if (__builtin_expect(__testeof, false))
 return traits_type::not_eof(__c);

      const __size_type __capacity = _M_string.capacity();


      if (size_t(this->epptr() - this->pbase()) < __capacity)
 {

   char_type* __base = const_cast<char_type*>(_M_string.data());
   _M_pbump(__base, __base + __capacity, this->pptr() - this->pbase());
   if (_M_mode & ios_base::in)
     {
       const __size_type __nget = this->gptr() - this->eback();
       const __size_type __eget = this->egptr() - this->eback();
       this->setg(__base, __base + __nget, __base + __eget + 1);
     }
   *this->pptr() = traits_type::to_char_type(__c);
   this->pbump(1);
   return __c;
 }


      const __size_type __max_size = _M_string.max_size();
      const bool __testput = this->pptr() < this->epptr();
      if (__builtin_expect(!__testput && __capacity == __max_size, false))
 return traits_type::eof();



      const char_type __conv = traits_type::to_char_type(__c);
      if (!__testput)
 {
# 129 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/sstream.tcc" 3
   const __size_type __opt_len = std::max(__size_type(2 * __capacity),
       __size_type(512));
   const __size_type __len = std::min(__opt_len, __max_size);
   __string_type __tmp(_M_string.get_allocator());
   __tmp.reserve(__len);
   if (this->pbase())
     __tmp.assign(this->pbase(), this->epptr() - this->pbase());
   __tmp.push_back(__conv);
   _M_string.swap(__tmp);
   _M_sync(const_cast<char_type*>(_M_string.data()),
    this->gptr() - this->eback(), this->pptr() - this->pbase());
 }
      else
 *this->pptr() = __conv;
      this->pbump(1);
      return __c;
    }

  template <class _CharT, class _Traits, class _Alloc>
    typename basic_stringbuf<_CharT, _Traits, _Alloc>::int_type
    basic_stringbuf<_CharT, _Traits, _Alloc>::
    underflow()
    {
      int_type __ret = traits_type::eof();
      const bool __testin = this->_M_mode & ios_base::in;
      if (__testin)
 {

   _M_update_egptr();

   if (this->gptr() < this->egptr())
     __ret = traits_type::to_int_type(*this->gptr());
 }
      return __ret;
    }

  template <class _CharT, class _Traits, class _Alloc>
    typename basic_stringbuf<_CharT, _Traits, _Alloc>::pos_type
    basic_stringbuf<_CharT, _Traits, _Alloc>::
    seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __mode)
    {
      pos_type __ret = pos_type(off_type(-1));
      bool __testin = (ios_base::in & this->_M_mode & __mode) != 0;
      bool __testout = (ios_base::out & this->_M_mode & __mode) != 0;
      const bool __testboth = __testin && __testout && __way != ios_base::cur;
      __testin &= !(__mode & ios_base::out);
      __testout &= !(__mode & ios_base::in);



      const char_type* __beg = __testin ? this->eback() : this->pbase();
      if ((__beg || !__off) && (__testin || __testout || __testboth))
 {
   _M_update_egptr();

   off_type __newoffi = __off;
   off_type __newoffo = __newoffi;
   if (__way == ios_base::cur)
     {
       __newoffi += this->gptr() - __beg;
       __newoffo += this->pptr() - __beg;
     }
   else if (__way == ios_base::end)
     __newoffo = __newoffi += this->egptr() - __beg;

   if ((__testin || __testboth)
       && __newoffi >= 0
       && this->egptr() - __beg >= __newoffi)
     {
       this->setg(this->eback(), this->eback() + __newoffi,
    this->egptr());
       __ret = pos_type(__newoffi);
     }
   if ((__testout || __testboth)
       && __newoffo >= 0
       && this->egptr() - __beg >= __newoffo)
     {
       _M_pbump(this->pbase(), this->epptr(), __newoffo);
       __ret = pos_type(__newoffo);
     }
 }
      return __ret;
    }

  template <class _CharT, class _Traits, class _Alloc>
    typename basic_stringbuf<_CharT, _Traits, _Alloc>::pos_type
    basic_stringbuf<_CharT, _Traits, _Alloc>::
    seekpos(pos_type __sp, ios_base::openmode __mode)
    {
      pos_type __ret = pos_type(off_type(-1));
      const bool __testin = (ios_base::in & this->_M_mode & __mode) != 0;
      const bool __testout = (ios_base::out & this->_M_mode & __mode) != 0;

      const char_type* __beg = __testin ? this->eback() : this->pbase();
      if ((__beg || !off_type(__sp)) && (__testin || __testout))
 {
   _M_update_egptr();

   const off_type __pos(__sp);
   const bool __testpos = (0 <= __pos
      && __pos <= this->egptr() - __beg);
   if (__testpos)
     {
       if (__testin)
  this->setg(this->eback(), this->eback() + __pos,
      this->egptr());
       if (__testout)
  _M_pbump(this->pbase(), this->epptr(), __pos);
       __ret = __sp;
     }
 }
      return __ret;
    }

  template <class _CharT, class _Traits, class _Alloc>
    void
    basic_stringbuf<_CharT, _Traits, _Alloc>::
    _M_sync(char_type* __base, __size_type __i, __size_type __o)
    {
      const bool __testin = _M_mode & ios_base::in;
      const bool __testout = _M_mode & ios_base::out;
      char_type* __endg = __base + _M_string.size();
      char_type* __endp = __base + _M_string.capacity();

      if (__base != _M_string.data())
 {

   __endg += __i;
   __i = 0;
   __endp = __endg;
 }

      if (__testin)
 this->setg(__base, __base + __i, __endg);
      if (__testout)
 {
   _M_pbump(__base, __endp, __o);



   if (!__testin)
     this->setg(__endg, __endg, __endg);
 }
    }

  template <class _CharT, class _Traits, class _Alloc>
    void
    basic_stringbuf<_CharT, _Traits, _Alloc>::
    _M_pbump(char_type* __pbeg, char_type* __pend, off_type __off)
    {
      this->setp(__pbeg, __pend);
      while (__off > __gnu_cxx::__numeric_traits<int>::__max)
 {
   this->pbump(__gnu_cxx::__numeric_traits<int>::__max);
   __off -= __gnu_cxx::__numeric_traits<int>::__max;
 }
      this->pbump(__off);
    }




  extern template class basic_stringbuf<char>;
  extern template class basic_istringstream<char>;
  extern template class basic_ostringstream<char>;
  extern template class basic_stringstream<char>;


  extern template class basic_stringbuf<wchar_t>;
  extern template class basic_istringstream<wchar_t>;
  extern template class basic_ostringstream<wchar_t>;
  extern template class basic_stringstream<wchar_t>;




}
# 1239 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/sstream" 2 3
# 46 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/chrono" 2 3
# 55 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/chrono" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 56 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/chrono" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{
# 74 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/chrono" 3
  namespace chrono
  {



    struct local_t { };
    template<typename _Duration>
      using local_time = time_point<local_t, _Duration>;
    using local_seconds = local_time<seconds>;
    using local_days = local_time<days>;

    class utc_clock;
    class tai_clock;
    class gps_clock;

    template<typename _Duration>
      using utc_time = time_point<utc_clock, _Duration>;
    using utc_seconds = utc_time<seconds>;

    template<typename _Duration>
      using tai_time = time_point<tai_clock, _Duration>;
    using tai_seconds = tai_time<seconds>;

    template<typename _Duration>
      using gps_time = time_point<gps_clock, _Duration>;
    using gps_seconds = gps_time<seconds>;

    template<> struct is_clock<utc_clock> : true_type { };
    template<> struct is_clock<tai_clock> : true_type { };
    template<> struct is_clock<gps_clock> : true_type { };

    template<> inline constexpr bool is_clock_v<utc_clock> = true;
    template<> inline constexpr bool is_clock_v<tai_clock> = true;
    template<> inline constexpr bool is_clock_v<gps_clock> = true;

    struct leap_second_info
    {
      bool is_leap_second;
      seconds elapsed;
    };

    template<typename _Duration>
      leap_second_info
      get_leap_second_info(const utc_time<_Duration>& __ut);







    class utc_clock
    {
    public:
      using rep = system_clock::rep;
      using period = system_clock::period;
      using duration = chrono::duration<rep, period>;
      using time_point = chrono::time_point<utc_clock>;
      static constexpr bool is_steady = false;

      [[nodiscard]]
      static time_point
      now()
      { return from_sys(system_clock::now()); }

      template<typename _Duration>
 [[nodiscard]]
 static sys_time<common_type_t<_Duration, seconds>>
 to_sys(const utc_time<_Duration>& __t)
 {
   using _CDur = common_type_t<_Duration, seconds>;
   const auto __li = chrono::get_leap_second_info(__t);
   sys_time<_CDur> __s{__t.time_since_epoch() - __li.elapsed};
   if (__li.is_leap_second)
     __s = chrono::floor<seconds>(__s) + seconds{1} - _CDur{1};
   return __s;
 }

      template<typename _Duration>
 [[nodiscard]]
 static utc_time<common_type_t<_Duration, seconds>>
 from_sys(const sys_time<_Duration>& __t);
    };







    class tai_clock
    {
    public:
      using rep = system_clock::rep;
      using period = system_clock::period;
      using duration = chrono::duration<rep, period>;
      using time_point = chrono::time_point<tai_clock>;
      static constexpr bool is_steady = false;


      [[nodiscard]]
      static time_point
      now()
      { return from_utc(utc_clock::now()); }

      template<typename _Duration>
 [[nodiscard]]
 static utc_time<common_type_t<_Duration, seconds>>
 to_utc(const tai_time<_Duration>& __t)
 {
   using _CDur = common_type_t<_Duration, seconds>;
   return utc_time<_CDur>{__t.time_since_epoch()} - 378691210s;
 }

      template<typename _Duration>
 [[nodiscard]]
 static tai_time<common_type_t<_Duration, seconds>>
 from_utc(const utc_time<_Duration>& __t)
 {
   using _CDur = common_type_t<_Duration, seconds>;
   return tai_time<_CDur>{__t.time_since_epoch()} + 378691210s;
 }
    };







    class gps_clock
    {
    public:
      using rep = system_clock::rep;
      using period = system_clock::period;
      using duration = chrono::duration<rep, period>;
      using time_point = chrono::time_point<gps_clock>;
      static constexpr bool is_steady = false;


      [[nodiscard]]
      static time_point
      now()
      { return from_utc(utc_clock::now()); }

      template<typename _Duration>
 [[nodiscard]]
 static utc_time<common_type_t<_Duration, seconds>>
 to_utc(const gps_time<_Duration>& __t)
 {
   using _CDur = common_type_t<_Duration, seconds>;
   return utc_time<_CDur>{__t.time_since_epoch()} + 315964809s;
 }

      template<typename _Duration>
 [[nodiscard]]
 static gps_time<common_type_t<_Duration, seconds>>
 from_utc(const utc_time<_Duration>& __t)
 {
   using _CDur = common_type_t<_Duration, seconds>;
   return gps_time<_CDur>{__t.time_since_epoch()} - 315964809s;
 }
    };


    template<typename _DestClock, typename _SourceClock>
      struct clock_time_conversion
      { };



    template<typename _Clock>
      struct clock_time_conversion<_Clock, _Clock>
      {
 template<typename _Duration>
   time_point<_Clock, _Duration>
   operator()(const time_point<_Clock, _Duration>& __t) const
   { return __t; }
      };

    template<>
      struct clock_time_conversion<system_clock, system_clock>
      {
 template<typename _Duration>
   sys_time<_Duration>
   operator()(const sys_time<_Duration>& __t) const
   { return __t; }
      };

    template<>
      struct clock_time_conversion<utc_clock, utc_clock>
      {
 template<typename _Duration>
   utc_time<_Duration>
   operator()(const utc_time<_Duration>& __t) const
   { return __t; }
      };



    template<>
      struct clock_time_conversion<utc_clock, system_clock>
      {
 template<typename _Duration>
   utc_time<common_type_t<_Duration, seconds>>
   operator()(const sys_time<_Duration>& __t) const
   { return utc_clock::from_sys(__t); }
      };

    template<>
      struct clock_time_conversion<system_clock, utc_clock>
      {
 template<typename _Duration>
   sys_time<common_type_t<_Duration, seconds>>
   operator()(const utc_time<_Duration>& __t) const
   { return utc_clock::to_sys(__t); }
      };

    template<typename _Tp, typename _Clock>
      inline constexpr bool __is_time_point_for_v = false;

    template<typename _Clock, typename _Duration>
      inline constexpr bool
       __is_time_point_for_v<time_point<_Clock, _Duration>, _Clock> = true;



    template<typename _SourceClock>
      struct clock_time_conversion<system_clock, _SourceClock>
      {
 template<typename _Duration, typename _Src = _SourceClock>
   auto
   operator()(const time_point<_SourceClock, _Duration>& __t) const
   -> decltype(_Src::to_sys(__t))
   {
     using _Ret = decltype(_SourceClock::to_sys(__t));
     static_assert(__is_time_point_for_v<_Ret, system_clock>);
     return _SourceClock::to_sys(__t);
   }
      };

    template<typename _DestClock>
      struct clock_time_conversion<_DestClock, system_clock>
      {
 template<typename _Duration, typename _Dest = _DestClock>
   auto
   operator()(const sys_time<_Duration>& __t) const
   -> decltype(_Dest::from_sys(__t))
   {
     using _Ret = decltype(_DestClock::from_sys(__t));
     static_assert(__is_time_point_for_v<_Ret, _DestClock>);
     return _DestClock::from_sys(__t);
   }
      };



    template<typename _SourceClock>
      struct clock_time_conversion<utc_clock, _SourceClock>
      {
 template<typename _Duration, typename _Src = _SourceClock>
   auto
   operator()(const time_point<_SourceClock, _Duration>& __t) const
   -> decltype(_Src::to_utc(__t))
   {
     using _Ret = decltype(_SourceClock::to_utc(__t));
     static_assert(__is_time_point_for_v<_Ret, utc_clock>);
     return _SourceClock::to_utc(__t);
   }
      };

    template<typename _DestClock>
      struct clock_time_conversion<_DestClock, utc_clock>
      {
 template<typename _Duration, typename _Dest = _DestClock>
   auto
   operator()(const utc_time<_Duration>& __t) const
   -> decltype(_Dest::from_utc(__t))
   {
     using _Ret = decltype(_DestClock::from_utc(__t));
     static_assert(__is_time_point_for_v<_Ret, _DestClock>);
     return _DestClock::from_utc(__t);
   }
      };


    namespace __detail
    {
      template<typename _DestClock, typename _SourceClock, typename _Duration>
       concept __clock_convs
   = requires (const time_point<_SourceClock, _Duration>& __t) {
     clock_time_conversion<_DestClock, _SourceClock>{}(__t);
   };

      template<typename _DestClock, typename _SourceClock, typename _Duration>
       concept __clock_convs_sys
   = requires (const time_point<_SourceClock, _Duration>& __t) {
     clock_time_conversion<_DestClock, system_clock>{}(
       clock_time_conversion<system_clock, _SourceClock>{}(__t));
   };

      template<typename _DestClock, typename _SourceClock, typename _Duration>
       concept __clock_convs_utc
   = requires (const time_point<_SourceClock, _Duration>& __t) {
     clock_time_conversion<_DestClock, utc_clock>{}(
       clock_time_conversion<utc_clock, _SourceClock>{}(__t));
   };

      template<typename _DestClock, typename _SourceClock, typename _Duration>
 concept __clock_convs_sys_utc
   = requires (const time_point<_SourceClock, _Duration>& __t) {
     clock_time_conversion<_DestClock, utc_clock>{}(
       clock_time_conversion<utc_clock, system_clock>{}(
  clock_time_conversion<system_clock, _SourceClock>{}(__t)));
   };

      template<typename _DestClock, typename _SourceClock, typename _Duration>
       concept __clock_convs_utc_sys
   = requires (const time_point<_SourceClock, _Duration>& __t) {
     clock_time_conversion<_DestClock, system_clock>{}(
       clock_time_conversion<system_clock, utc_clock>{}(
  clock_time_conversion<utc_clock, _SourceClock>{}(__t)));
   };

    }



    template<typename _DestClock, typename _SourceClock, typename _Duration>
      [[nodiscard]]
      inline auto
      clock_cast(const time_point<_SourceClock, _Duration>& __t)
      requires __detail::__clock_convs<_DestClock, _SourceClock, _Duration>
 || __detail::__clock_convs_sys<_DestClock, _SourceClock, _Duration>
 || __detail::__clock_convs_utc<_DestClock, _SourceClock, _Duration>
 || __detail::__clock_convs_sys_utc<_DestClock, _SourceClock, _Duration>
 || __detail::__clock_convs_utc_sys<_DestClock, _SourceClock, _Duration>
      {
       constexpr bool __direct
  = __detail::__clock_convs<_DestClock, _SourceClock, _Duration>;
       if constexpr (__direct)
  {
    return clock_time_conversion<_DestClock, _SourceClock>{}(__t);
  }
       else
  {
    constexpr bool __convert_via_sys_clock
      = __detail::__clock_convs_sys<_DestClock, _SourceClock, _Duration>;
    constexpr bool __convert_via_utc_clock
      = __detail::__clock_convs_utc<_DestClock, _SourceClock, _Duration>;
    if constexpr (__convert_via_sys_clock)
      {
        static_assert(!__convert_via_utc_clock,
   "clock_cast requires a unique best conversion, but "
   "conversion is possible via system_clock and also via"
   "utc_clock");
        return clock_time_conversion<_DestClock, system_clock>{}(
   clock_time_conversion<system_clock, _SourceClock>{}(__t));
      }
    else if constexpr (__convert_via_utc_clock)
      {
        return clock_time_conversion<_DestClock, utc_clock>{}(
   clock_time_conversion<utc_clock, _SourceClock>{}(__t));
      }
    else
      {
        constexpr bool __convert_via_sys_and_utc_clocks
   = __detail::__clock_convs_sys_utc<_DestClock,
         _SourceClock,
         _Duration>;

        if constexpr (__convert_via_sys_and_utc_clocks)
   {
     constexpr bool __convert_via_utc_and_sys_clocks
       = __detail::__clock_convs_utc_sys<_DestClock,
             _SourceClock,
             _Duration>;
     static_assert(!__convert_via_utc_and_sys_clocks,
       "clock_cast requires a unique best conversion, but "
       "conversion is possible via system_clock followed by "
       "utc_clock, and also via utc_clock followed by "
       "system_clock");
     return clock_time_conversion<_DestClock, utc_clock>{}(
       clock_time_conversion<utc_clock, system_clock>{}(
         clock_time_conversion<system_clock, _SourceClock>{}(__t)));
   }
        else
   {
     return clock_time_conversion<_DestClock, system_clock>{}(
       clock_time_conversion<system_clock, utc_clock>{}(
         clock_time_conversion<utc_clock, _SourceClock>{}(__t)));
   }
      }
  }
      }




    class day;
    class month;
    class year;
    class weekday;
    class weekday_indexed;
    class weekday_last;
    class month_day;
    class month_day_last;
    class month_weekday;
    class month_weekday_last;
    class year_month;
    class year_month_day;
    class year_month_day_last;
    class year_month_weekday;
    class year_month_weekday_last;

    struct last_spec
    {
      explicit last_spec() = default;

      friend constexpr month_day_last
      operator/(int __m, last_spec) noexcept;

      friend constexpr month_day_last
      operator/(last_spec, int __m) noexcept;
    };

    inline constexpr last_spec last{};

    namespace __detail
    {

      template <unsigned __d, typename _Tp>
      consteval auto
      __modulo_offset()
      {
 using _Up = make_unsigned_t<_Tp>;
 auto constexpr __a = _Up(-1) - _Up(255 + __d - 2);
 auto constexpr __b = _Up(__d * (__a / __d) - 1);

 return _Up(-1) - __b;
      }




      template <unsigned __d, typename _Tp>
      constexpr unsigned
      __add_modulo(unsigned __x, _Tp __y)
      {
 using _Up = make_unsigned_t<_Tp>;
# 533 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/chrono" 3
 auto const __offset = __y >= 0 ? _Up(0) : __modulo_offset<__d, _Tp>();
 return (__x + _Up(__y) - __offset) % __d;
      }


      template <unsigned __d, typename _Tp>
      constexpr unsigned
      __sub_modulo(unsigned __x, _Tp __y)
      {
 using _Up = make_unsigned_t<_Tp>;
 auto const __offset = __y <= 0 ? _Up(0) : __modulo_offset<__d, _Tp>();
 return (__x - _Up(__y) - __offset) % __d;
      }

      inline constexpr unsigned __days_per_month[12]
 = { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
    }



    class day
    {
    private:
      unsigned char _M_d;

    public:
      day() = default;

      explicit constexpr
      day(unsigned __d) noexcept
      : _M_d(__d)
      { }

      constexpr day&
      operator++() noexcept
      {
 ++_M_d;
 return *this;
      }

      constexpr day
      operator++(int) noexcept
      {
 auto __ret = *this;
 ++(*this);
 return __ret;
      }

      constexpr day&
      operator--() noexcept
      {
 --_M_d;
 return *this;
      }

      constexpr day
      operator--(int) noexcept
      {
 auto __ret = *this;
 --(*this);
 return __ret;
      }

      constexpr day&
      operator+=(const days& __d) noexcept
      {
 *this = *this + __d;
 return *this;
      }

      constexpr day&
      operator-=(const days& __d) noexcept
      {
 *this = *this - __d;
 return *this;
      }

      constexpr explicit
      operator unsigned() const noexcept
      { return _M_d; }

      constexpr bool
      ok() const noexcept
      { return 1 <= _M_d && _M_d <= 31; }

      friend constexpr bool
      operator==(const day& __x, const day& __y) noexcept
      { return unsigned{__x} == unsigned{__y}; }

      friend constexpr strong_ordering
      operator<=>(const day& __x, const day& __y) noexcept
      { return unsigned{__x} <=> unsigned{__y}; }

      friend constexpr day
      operator+(const day& __x, const days& __y) noexcept
      { return day(unsigned{__x} + __y.count()); }

      friend constexpr day
      operator+(const days& __x, const day& __y) noexcept
      { return __y + __x; }

      friend constexpr day
      operator-(const day& __x, const days& __y) noexcept
      { return __x + -__y; }

      friend constexpr days
      operator-(const day& __x, const day& __y) noexcept
      { return days{int(unsigned{__x}) - int(unsigned{__y})}; }

      friend constexpr month_day
      operator/(const month& __m, const day& __d) noexcept;

      friend constexpr month_day
      operator/(int __m, const day& __d) noexcept;

      friend constexpr month_day
      operator/(const day& __d, const month& __m) noexcept;

      friend constexpr month_day
      operator/(const day& __d, int __m) noexcept;

      friend constexpr year_month_day
      operator/(const year_month& __ym, const day& __d) noexcept;
    };



    class month
    {
    private:
      unsigned char _M_m;

    public:
      month() = default;

      explicit constexpr
      month(unsigned __m) noexcept
      : _M_m(__m)
      { }

      constexpr month&
      operator++() noexcept
      {
 *this += months{1};
 return *this;
      }

      constexpr month
      operator++(int) noexcept
      {
 auto __ret = *this;
 ++(*this);
 return __ret;
      }

      constexpr month&
      operator--() noexcept
      {
 *this -= months{1};
 return *this;
      }

      constexpr month
      operator--(int) noexcept
      {
 auto __ret = *this;
 --(*this);
 return __ret;
      }

      constexpr month&
      operator+=(const months& __m) noexcept
      {
 *this = *this + __m;
 return *this;
      }

      constexpr month&
      operator-=(const months& __m) noexcept
      {
 *this = *this - __m;
 return *this;
      }

      explicit constexpr
      operator unsigned() const noexcept
      { return _M_m; }

      constexpr bool
      ok() const noexcept
      { return 1 <= _M_m && _M_m <= 12; }

      friend constexpr bool
      operator==(const month& __x, const month& __y) noexcept
      { return unsigned{__x} == unsigned{__y}; }

      friend constexpr strong_ordering
      operator<=>(const month& __x, const month& __y) noexcept
      { return unsigned{__x} <=> unsigned{__y}; }

      friend constexpr month
      operator+(const month& __x, const months& __y) noexcept
      {


 return month{1 + __detail::__add_modulo<12>(
   unsigned{__x} + 11, __y.count())};
      }

      friend constexpr month
      operator+(const months& __x, const month& __y) noexcept
      { return __y + __x; }

      friend constexpr month
      operator-(const month& __x, const months& __y) noexcept
      {


 return month{1 + __detail::__sub_modulo<12>(
   unsigned{__x} + 11, __y.count())};
      }

      friend constexpr months
      operator-(const month& __x, const month& __y) noexcept
      {
 const auto __dm = int(unsigned(__x)) - int(unsigned(__y));
 return months{__dm < 0 ? 12 + __dm : __dm};
      }

      friend constexpr year_month
      operator/(const year& __y, const month& __m) noexcept;

      friend constexpr month_day
      operator/(const month& __m, int __d) noexcept;

      friend constexpr month_day_last
      operator/(const month& __m, last_spec) noexcept;

      friend constexpr month_day_last
      operator/(last_spec, const month& __m) noexcept;

      friend constexpr month_weekday
      operator/(const month& __m, const weekday_indexed& __wdi) noexcept;

      friend constexpr month_weekday
      operator/(const weekday_indexed& __wdi, const month& __m) noexcept;

      friend constexpr month_weekday_last
      operator/(const month& __m, const weekday_last& __wdl) noexcept;

      friend constexpr month_weekday_last
      operator/(const weekday_last& __wdl, const month& __m) noexcept;
    };

    inline constexpr month January{1};
    inline constexpr month February{2};
    inline constexpr month March{3};
    inline constexpr month April{4};
    inline constexpr month May{5};
    inline constexpr month June{6};
    inline constexpr month July{7};
    inline constexpr month August{8};
    inline constexpr month September{9};
    inline constexpr month October{10};
    inline constexpr month November{11};
    inline constexpr month December{12};



    class year
    {
    private:
      short _M_y;

    public:
      year() = default;

      explicit constexpr
      year(int __y) noexcept
      : _M_y{static_cast<short>(__y)}
      { }

      static constexpr year
      min() noexcept
      { return year{-32767}; }

      static constexpr year
      max() noexcept
      { return year{32767}; }

      constexpr year&
      operator++() noexcept
      {
 ++_M_y;
 return *this;
      }

      constexpr year
      operator++(int) noexcept
      {
 auto __ret = *this;
 ++(*this);
 return __ret;
      }

      constexpr year&
      operator--() noexcept
      {
 --_M_y;
 return *this;
      }

      constexpr year
      operator--(int) noexcept
      {
 auto __ret = *this;
 --(*this);
 return __ret;
      }

      constexpr year&
      operator+=(const years& __y) noexcept
      {
 *this = *this + __y;
 return *this;
      }

      constexpr year&
      operator-=(const years& __y) noexcept
      {
 *this = *this - __y;
 return *this;
      }

      constexpr year
      operator+() const noexcept
      { return *this; }

      constexpr year
      operator-() const noexcept
      { return year{-_M_y}; }

      constexpr bool
      is_leap() const noexcept
      {
# 900 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/chrono" 3
 return (_M_y & (_M_y % 25 == 0 ? 15 : 3)) == 0;
      }

      explicit constexpr
      operator int() const noexcept
      { return _M_y; }

      constexpr bool
      ok() const noexcept
      { return min()._M_y <= _M_y && _M_y <= max()._M_y; }

      friend constexpr bool
      operator==(const year& __x, const year& __y) noexcept
      { return int{__x} == int{__y}; }

      friend constexpr strong_ordering
      operator<=>(const year& __x, const year& __y) noexcept
      { return int{__x} <=> int{__y}; }

      friend constexpr year
      operator+(const year& __x, const years& __y) noexcept
      { return year{int{__x} + static_cast<int>(__y.count())}; }

      friend constexpr year
      operator+(const years& __x, const year& __y) noexcept
      { return __y + __x; }

      friend constexpr year
      operator-(const year& __x, const years& __y) noexcept
      { return __x + -__y; }

      friend constexpr years
      operator-(const year& __x, const year& __y) noexcept
      { return years{int{__x} - int{__y}}; }

      friend constexpr year_month
      operator/(const year& __y, int __m) noexcept;

      friend constexpr year_month_day
      operator/(const year& __y, const month_day& __md) noexcept;

      friend constexpr year_month_day
      operator/(const month_day& __md, const year& __y) noexcept;

      friend constexpr year_month_day_last
      operator/(const year& __y, const month_day_last& __mdl) noexcept;

      friend constexpr year_month_day_last
      operator/(const month_day_last& __mdl, const year& __y) noexcept;

      friend constexpr year_month_weekday
      operator/(const year& __y, const month_weekday& __mwd) noexcept;

      friend constexpr year_month_weekday
      operator/(const month_weekday& __mwd, const year& __y) noexcept;

      friend constexpr year_month_weekday_last
      operator/(const year& __y, const month_weekday_last& __mwdl) noexcept;

      friend constexpr year_month_weekday_last
      operator/(const month_weekday_last& __mwdl, const year& __y) noexcept;
    };



    class weekday
    {
    private:
      unsigned char _M_wd;

      static constexpr weekday
      _S_from_days(const days& __d)
      {
 return weekday{__detail::__add_modulo<7>(4, __d.count())};
      }

    public:
      weekday() = default;

      explicit constexpr
      weekday(unsigned __wd) noexcept
      : _M_wd(__wd == 7 ? 0 : __wd)
      { }

      constexpr
      weekday(const sys_days& __dp) noexcept
      : weekday{_S_from_days(__dp.time_since_epoch())}
      { }

      explicit constexpr
      weekday(const local_days& __dp) noexcept
      : weekday{sys_days{__dp.time_since_epoch()}}
      { }

      constexpr weekday&
      operator++() noexcept
      {
 *this += days{1};
 return *this;
      }

      constexpr weekday
      operator++(int) noexcept
      {
 auto __ret = *this;
 ++(*this);
 return __ret;
      }

      constexpr weekday&
      operator--() noexcept
      {
 *this -= days{1};
 return *this;
      }

      constexpr weekday
      operator--(int) noexcept
      {
 auto __ret = *this;
 --(*this);
 return __ret;
      }

      constexpr weekday&
      operator+=(const days& __d) noexcept
      {
 *this = *this + __d;
 return *this;
      }

      constexpr weekday&
      operator-=(const days& __d) noexcept
      {
 *this = *this - __d;
 return *this;
      }

      constexpr unsigned
      c_encoding() const noexcept
      { return _M_wd; }

      constexpr unsigned
      iso_encoding() const noexcept
      { return _M_wd == 0u ? 7u : _M_wd; }

      constexpr bool
      ok() const noexcept
      { return _M_wd <= 6; }

      constexpr weekday_indexed
      operator[](unsigned __index) const noexcept;

      constexpr weekday_last
      operator[](last_spec) const noexcept;

      friend constexpr bool
      operator==(const weekday& __x, const weekday& __y) noexcept
      { return __x._M_wd == __y._M_wd; }

      friend constexpr weekday
      operator+(const weekday& __x, const days& __y) noexcept
      {
 return weekday{__detail::__add_modulo<7>(__x._M_wd, __y.count())};
      }

      friend constexpr weekday
      operator+(const days& __x, const weekday& __y) noexcept
      { return __y + __x; }

      friend constexpr weekday
      operator-(const weekday& __x, const days& __y) noexcept
      {
 return weekday{__detail::__sub_modulo<7>(__x._M_wd, __y.count())};
      }

      friend constexpr days
      operator-(const weekday& __x, const weekday& __y) noexcept
      {
 const auto __n = __x.c_encoding() - __y.c_encoding();
 return static_cast<int>(__n) >= 0 ? days{__n} : days{__n + 7};
      }
    };

    inline constexpr weekday Sunday{0};
    inline constexpr weekday Monday{1};
    inline constexpr weekday Tuesday{2};
    inline constexpr weekday Wednesday{3};
    inline constexpr weekday Thursday{4};
    inline constexpr weekday Friday{5};
    inline constexpr weekday Saturday{6};



    class weekday_indexed
    {
    private:
      chrono::weekday _M_wd;
      unsigned char _M_index;

    public:
      weekday_indexed() = default;

      constexpr
      weekday_indexed(const chrono::weekday& __wd, unsigned __index) noexcept
      : _M_wd(__wd), _M_index(__index)
      { }

      constexpr chrono::weekday
      weekday() const noexcept
      { return _M_wd; }

      constexpr unsigned
      index() const noexcept
      { return _M_index; };

      constexpr bool
      ok() const noexcept
      { return _M_wd.ok() && 1 <= _M_index && _M_index <= 5; }

      friend constexpr bool
      operator==(const weekday_indexed& __x, const weekday_indexed& __y) noexcept
      { return __x.weekday() == __y.weekday() && __x.index() == __y.index(); }

      friend constexpr month_weekday
      operator/(const month& __m, const weekday_indexed& __wdi) noexcept;

      friend constexpr month_weekday
      operator/(int __m, const weekday_indexed& __wdi) noexcept;

      friend constexpr month_weekday
      operator/(const weekday_indexed& __wdi, const month& __m) noexcept;

      friend constexpr month_weekday
      operator/(const weekday_indexed& __wdi, int __m) noexcept;

      friend constexpr year_month_weekday
      operator/(const year_month& __ym, const weekday_indexed& __wdi) noexcept;
    };

    constexpr weekday_indexed
    weekday::operator[](unsigned __index) const noexcept
    { return {*this, __index}; }



    class weekday_last
    {
    private:
      chrono::weekday _M_wd;

    public:
      explicit constexpr
      weekday_last(const chrono::weekday& __wd) noexcept
      : _M_wd{__wd}
      { }

      constexpr chrono::weekday
      weekday() const noexcept
      { return _M_wd; }

      constexpr bool
      ok() const noexcept
      { return _M_wd.ok(); }

      friend constexpr bool
      operator==(const weekday_last& __x, const weekday_last& __y) noexcept
      { return __x.weekday() == __y.weekday(); }

      friend constexpr month_weekday_last
      operator/(int __m, const weekday_last& __wdl) noexcept;

      friend constexpr month_weekday_last
      operator/(const weekday_last& __wdl, int __m) noexcept;

      friend constexpr year_month_weekday_last
      operator/(const year_month& __ym, const weekday_last& __wdl) noexcept;
    };

    constexpr weekday_last
    weekday::operator[](last_spec) const noexcept
    { return weekday_last{*this}; }



    class month_day
    {
    private:
      chrono::month _M_m;
      chrono::day _M_d;

    public:
      month_day() = default;

      constexpr
      month_day(const chrono::month& __m, const chrono::day& __d) noexcept
      : _M_m{__m}, _M_d{__d}
      { }

      constexpr chrono::month
      month() const noexcept
      { return _M_m; }

      constexpr chrono::day
      day() const noexcept
      { return _M_d; }

      constexpr bool
      ok() const noexcept
      {
 return _M_m.ok()
   && 1u <= unsigned(_M_d)
   && unsigned(_M_d) <= __detail::__days_per_month[unsigned(_M_m) - 1];
      }

      friend constexpr bool
      operator==(const month_day& __x, const month_day& __y) noexcept
      { return __x.month() == __y.month() && __x.day() == __y.day(); }

      friend constexpr strong_ordering
      operator<=>(const month_day& __x, const month_day& __y) noexcept
 = default;

      friend constexpr month_day
      operator/(const chrono::month& __m, const chrono::day& __d) noexcept
      { return {__m, __d}; }

      friend constexpr month_day
      operator/(const chrono::month& __m, int __d) noexcept
      { return {__m, chrono::day(unsigned(__d))}; }

      friend constexpr month_day
      operator/(int __m, const chrono::day& __d) noexcept
      { return {chrono::month(unsigned(__m)), __d}; }

      friend constexpr month_day
      operator/(const chrono::day& __d, const chrono::month& __m) noexcept
      { return {__m, __d}; }

      friend constexpr month_day
      operator/(const chrono::day& __d, int __m) noexcept
      { return {chrono::month(unsigned(__m)), __d}; }

      friend constexpr year_month_day
      operator/(int __y, const month_day& __md) noexcept;

      friend constexpr year_month_day
      operator/(const month_day& __md, int __y) noexcept;
    };



    class month_day_last
    {
    private:
      chrono::month _M_m;

    public:
      explicit constexpr
      month_day_last(const chrono::month& __m) noexcept
      : _M_m{__m}
      { }

      constexpr chrono::month
      month() const noexcept
      { return _M_m; }

      constexpr bool
      ok() const noexcept
      { return _M_m.ok(); }

      friend constexpr bool
      operator==(const month_day_last& __x, const month_day_last& __y) noexcept
      { return __x.month() == __y.month(); }

      friend constexpr strong_ordering
      operator<=>(const month_day_last& __x, const month_day_last& __y) noexcept
 = default;

      friend constexpr month_day_last
      operator/(const chrono::month& __m, last_spec) noexcept
      { return month_day_last{__m}; }

      friend constexpr month_day_last
      operator/(int __m, last_spec) noexcept
      { return chrono::month(unsigned(__m)) / last; }

      friend constexpr month_day_last
      operator/(last_spec, const chrono::month& __m) noexcept
      { return __m / last; }

      friend constexpr month_day_last
      operator/(last_spec, int __m) noexcept
      { return __m / last; }

      friend constexpr year_month_day_last
      operator/(int __y, const month_day_last& __mdl) noexcept;

      friend constexpr year_month_day_last
      operator/(const month_day_last& __mdl, int __y) noexcept;
    };



    class month_weekday
    {
    private:
      chrono::month _M_m;
      chrono::weekday_indexed _M_wdi;

    public:
      constexpr
      month_weekday(const chrono::month& __m,
      const chrono::weekday_indexed& __wdi) noexcept
      : _M_m{__m}, _M_wdi{__wdi}
      { }

      constexpr chrono::month
      month() const noexcept
      { return _M_m; }

      constexpr chrono::weekday_indexed
      weekday_indexed() const noexcept
      { return _M_wdi; }

      constexpr bool
      ok() const noexcept
      { return _M_m.ok() && _M_wdi.ok(); }

      friend constexpr bool
      operator==(const month_weekday& __x, const month_weekday& __y) noexcept
      {
 return __x.month() == __y.month()
   && __x.weekday_indexed() == __y.weekday_indexed();
      }

      friend constexpr month_weekday
      operator/(const chrono::month& __m,
  const chrono::weekday_indexed& __wdi) noexcept
      { return {__m, __wdi}; }

      friend constexpr month_weekday
      operator/(int __m, const chrono::weekday_indexed& __wdi) noexcept
      { return chrono::month(unsigned(__m)) / __wdi; }

      friend constexpr month_weekday
      operator/(const chrono::weekday_indexed& __wdi,
  const chrono::month& __m) noexcept
      { return __m / __wdi; }

      friend constexpr month_weekday
      operator/(const chrono::weekday_indexed& __wdi, int __m) noexcept
      { return __m / __wdi; }

      friend constexpr year_month_weekday
      operator/(int __y, const month_weekday& __mwd) noexcept;

      friend constexpr year_month_weekday
      operator/(const month_weekday& __mwd, int __y) noexcept;
    };



    class month_weekday_last
    {
    private:
      chrono::month _M_m;
      chrono::weekday_last _M_wdl;

    public:
      constexpr
      month_weekday_last(const chrono::month& __m,
    const chrono::weekday_last& __wdl) noexcept
      :_M_m{__m}, _M_wdl{__wdl}
      { }

      constexpr chrono::month
      month() const noexcept
      { return _M_m; }

      constexpr chrono::weekday_last
      weekday_last() const noexcept
      { return _M_wdl; }

      constexpr bool
      ok() const noexcept
      { return _M_m.ok() && _M_wdl.ok(); }

      friend constexpr bool
      operator==(const month_weekday_last& __x,
   const month_weekday_last& __y) noexcept
      {
 return __x.month() == __y.month()
   && __x.weekday_last() == __y.weekday_last();
      }

      friend constexpr month_weekday_last
      operator/(const chrono::month& __m,
  const chrono::weekday_last& __wdl) noexcept
      { return {__m, __wdl}; }

      friend constexpr month_weekday_last
      operator/(int __m, const chrono::weekday_last& __wdl) noexcept
      { return chrono::month(unsigned(__m)) / __wdl; }

      friend constexpr month_weekday_last
      operator/(const chrono::weekday_last& __wdl,
  const chrono::month& __m) noexcept
      { return __m / __wdl; }

      friend constexpr month_weekday_last
      operator/(const chrono::weekday_last& __wdl, int __m) noexcept
      { return chrono::month(unsigned(__m)) / __wdl; }

      friend constexpr year_month_weekday_last
      operator/(int __y, const month_weekday_last& __mwdl) noexcept;

      friend constexpr year_month_weekday_last
      operator/(const month_weekday_last& __mwdl, int __y) noexcept;
    };



    namespace __detail
    {
# 1437 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/chrono" 3
      using __months_years_conversion_disambiguator = void;
    }

    class year_month
    {
    private:
      chrono::year _M_y;
      chrono::month _M_m;

    public:
      year_month() = default;

      constexpr
      year_month(const chrono::year& __y, const chrono::month& __m) noexcept
      : _M_y{__y}, _M_m{__m}
      { }

      constexpr chrono::year
      year() const noexcept
      { return _M_y; }

      constexpr chrono::month
      month() const noexcept
      { return _M_m; }

      template<typename = __detail::__months_years_conversion_disambiguator>
 constexpr year_month&
 operator+=(const months& __dm) noexcept
 {
   *this = *this + __dm;
   return *this;
 }

      template<typename = __detail::__months_years_conversion_disambiguator>
 constexpr year_month&
 operator-=(const months& __dm) noexcept
 {
   *this = *this - __dm;
   return *this;
 }

      constexpr year_month&
      operator+=(const years& __dy) noexcept
      {
 *this = *this + __dy;
 return *this;
      }

      constexpr year_month&
      operator-=(const years& __dy) noexcept
      {
 *this = *this - __dy;
 return *this;
      }

      constexpr bool
      ok() const noexcept
      { return _M_y.ok() && _M_m.ok(); }

      friend constexpr bool
      operator==(const year_month& __x, const year_month& __y) noexcept
      { return __x.year() == __y.year() && __x.month() == __y.month(); }

      friend constexpr strong_ordering
      operator<=>(const year_month& __x, const year_month& __y) noexcept
 = default;

      template<typename = __detail::__months_years_conversion_disambiguator>
 friend constexpr year_month
 operator+(const year_month& __ym, const months& __dm) noexcept
 {

   auto __m = __ym.month() + __dm;
   auto __i = int(unsigned(__ym.month())) - 1 + __dm.count();
   auto __y = (__i < 0
        ? __ym.year() + years{(__i - 11) / 12}
        : __ym.year() + years{__i / 12});
   return __y / __m;
 }

      template<typename = __detail::__months_years_conversion_disambiguator>
 friend constexpr year_month
 operator+(const months& __dm, const year_month& __ym) noexcept
 { return __ym + __dm; }

      template<typename = __detail::__months_years_conversion_disambiguator>
 friend constexpr year_month
 operator-(const year_month& __ym, const months& __dm) noexcept
 { return __ym + -__dm; }

      friend constexpr months
      operator-(const year_month& __x, const year_month& __y) noexcept
      {
 return (__x.year() - __y.year()
  + months{static_cast<int>(unsigned{__x.month()})
    - static_cast<int>(unsigned{__y.month()})});
      }

      friend constexpr year_month
      operator+(const year_month& __ym, const years& __dy) noexcept
      { return (__ym.year() + __dy) / __ym.month(); }

      friend constexpr year_month
      operator+(const years& __dy, const year_month& __ym) noexcept
      { return __ym + __dy; }

      friend constexpr year_month
      operator-(const year_month& __ym, const years& __dy) noexcept
      { return __ym + -__dy; }

      friend constexpr year_month
      operator/(const chrono::year& __y, const chrono::month& __m) noexcept
      { return {__y, __m}; }

      friend constexpr year_month
      operator/(const chrono::year& __y, int __m) noexcept
      { return {__y, chrono::month(unsigned(__m))}; }

      friend constexpr year_month_day
      operator/(const year_month& __ym, int __d) noexcept;

      friend constexpr year_month_day_last
      operator/(const year_month& __ym, last_spec) noexcept;
    };



    class year_month_day
    {
    private:
      chrono::year _M_y;
      chrono::month _M_m;
      chrono::day _M_d;

      static constexpr year_month_day _S_from_days(const days& __dp) noexcept;

      constexpr days _M_days_since_epoch() const noexcept;

    public:
      year_month_day() = default;

      constexpr
      year_month_day(const chrono::year& __y, const chrono::month& __m,
       const chrono::day& __d) noexcept
      : _M_y{__y}, _M_m{__m}, _M_d{__d}
      { }

      constexpr
      year_month_day(const year_month_day_last& __ymdl) noexcept;

      constexpr
      year_month_day(const sys_days& __dp) noexcept
      : year_month_day(_S_from_days(__dp.time_since_epoch()))
      { }

      explicit constexpr
      year_month_day(const local_days& __dp) noexcept
      : year_month_day(sys_days{__dp.time_since_epoch()})
      { }

      template<typename = __detail::__months_years_conversion_disambiguator>
 constexpr year_month_day&
 operator+=(const months& __m) noexcept
 {
   *this = *this + __m;
   return *this;
 }

      template<typename = __detail::__months_years_conversion_disambiguator>
 constexpr year_month_day&
 operator-=(const months& __m) noexcept
 {
   *this = *this - __m;
   return *this;
 }

      constexpr year_month_day&
      operator+=(const years& __y) noexcept
      {
 *this = *this + __y;
 return *this;
      }

      constexpr year_month_day&
      operator-=(const years& __y) noexcept
      {
 *this = *this - __y;
 return *this;
      }

      constexpr chrono::year
      year() const noexcept
      { return _M_y; }

      constexpr chrono::month
      month() const noexcept
      { return _M_m; }

      constexpr chrono::day
      day() const noexcept
      { return _M_d; }

      constexpr
      operator sys_days() const noexcept
      { return sys_days{_M_days_since_epoch()}; }

      explicit constexpr
      operator local_days() const noexcept
      { return local_days{sys_days{*this}.time_since_epoch()}; }

      constexpr bool ok() const noexcept;

      friend constexpr bool
      operator==(const year_month_day& __x, const year_month_day& __y) noexcept
      {
 return __x.year() == __y.year()
   && __x.month() == __y.month()
   && __x.day() == __y.day();
      }

      friend constexpr strong_ordering
      operator<=>(const year_month_day& __x, const year_month_day& __y) noexcept
 = default;

      template<typename = __detail::__months_years_conversion_disambiguator>
 friend constexpr year_month_day
 operator+(const year_month_day& __ymd, const months& __dm) noexcept
 { return (__ymd.year() / __ymd.month() + __dm) / __ymd.day(); }

      template<typename = __detail::__months_years_conversion_disambiguator>
 friend constexpr year_month_day
 operator+(const months& __dm, const year_month_day& __ymd) noexcept
 { return __ymd + __dm; }

      friend constexpr year_month_day
      operator+(const year_month_day& __ymd, const years& __dy) noexcept
      { return (__ymd.year() + __dy) / __ymd.month() / __ymd.day(); }

      friend constexpr year_month_day
      operator+(const years& __dy, const year_month_day& __ymd) noexcept
      { return __ymd + __dy; }

      template<typename = __detail::__months_years_conversion_disambiguator>
 friend constexpr year_month_day
 operator-(const year_month_day& __ymd, const months& __dm) noexcept
 { return __ymd + -__dm; }

      friend constexpr year_month_day
      operator-(const year_month_day& __ymd, const years& __dy) noexcept
      { return __ymd + -__dy; }

      friend constexpr year_month_day
      operator/(const year_month& __ym, const chrono::day& __d) noexcept
      { return {__ym.year(), __ym.month(), __d}; }

      friend constexpr year_month_day
      operator/(const year_month& __ym, int __d) noexcept
      { return __ym / chrono::day{unsigned(__d)}; }

      friend constexpr year_month_day
      operator/(const chrono::year& __y, const month_day& __md) noexcept
      { return __y / __md.month() / __md.day(); }

      friend constexpr year_month_day
      operator/(int __y, const month_day& __md) noexcept
      { return chrono::year{__y} / __md; }

      friend constexpr year_month_day
      operator/(const month_day& __md, const chrono::year& __y) noexcept
      { return __y / __md; }

      friend constexpr year_month_day
      operator/(const month_day& __md, int __y) noexcept
      { return chrono::year(__y) / __md; }
    };





    constexpr year_month_day
    year_month_day::_S_from_days(const days& __dp) noexcept
    {
      constexpr auto __z2 = static_cast<uint32_t>(-1468000);
      constexpr auto __r2_e3 = static_cast<uint32_t>(536895458);

      const auto __r0 = static_cast<uint32_t>(__dp.count()) + __r2_e3;

      const auto __n1 = 4 * __r0 + 3;
      const auto __q1 = __n1 / 146097;
      const auto __r1 = __n1 % 146097 / 4;

      constexpr auto __p32 = static_cast<uint64_t>(1) << 32;
      const auto __n2 = 4 * __r1 + 3;
      const auto __u2 = static_cast<uint64_t>(2939745) * __n2;
      const auto __q2 = static_cast<uint32_t>(__u2 / __p32);
      const auto __r2 = static_cast<uint32_t>(__u2 % __p32) / 2939745 / 4;

      constexpr auto __p16 = static_cast<uint32_t>(1) << 16;
      const auto __n3 = 2141 * __r2 + 197913;
      const auto __q3 = __n3 / __p16;
      const auto __r3 = __n3 % __p16 / 2141;

      const auto __y0 = 100 * __q1 + __q2;
      const auto __m0 = __q3;
      const auto __d0 = __r3;

      const auto __j = __r2 >= 306;
      const auto __y1 = __y0 + __j;
      const auto __m1 = __j ? __m0 - 12 : __m0;
      const auto __d1 = __d0 + 1;

      return year_month_day{chrono::year{static_cast<int>(__y1 + __z2)},
       chrono::month{__m1}, chrono::day{__d1}};
    }





    constexpr days
    year_month_day::_M_days_since_epoch() const noexcept
    {
      auto constexpr __z2 = static_cast<uint32_t>(-1468000);
      auto constexpr __r2_e3 = static_cast<uint32_t>(536895458);

      const auto __y1 = static_cast<uint32_t>(static_cast<int>(_M_y)) - __z2;
      const auto __m1 = static_cast<uint32_t>(static_cast<unsigned>(_M_m));
      const auto __d1 = static_cast<uint32_t>(static_cast<unsigned>(_M_d));

      const auto __j = static_cast<uint32_t>(__m1 < 3);
      const auto __y0 = __y1 - __j;
      const auto __m0 = __j ? __m1 + 12 : __m1;
      const auto __d0 = __d1 - 1;

      const auto __q1 = __y0 / 100;
      const auto __yc = 1461 * __y0 / 4 - __q1 + __q1 / 4;
      const auto __mc = (979 *__m0 - 2919) / 32;
      const auto __dc = __d0;

      return days{static_cast<int32_t>(__yc + __mc + __dc - __r2_e3)};
    }



    class year_month_day_last
    {
    private:
      chrono::year _M_y;
      chrono::month_day_last _M_mdl;

    public:
      constexpr
      year_month_day_last(const chrono::year& __y,
     const chrono::month_day_last& __mdl) noexcept
      : _M_y{__y}, _M_mdl{__mdl}
      { }

      template<typename = __detail::__months_years_conversion_disambiguator>
 constexpr year_month_day_last&
 operator+=(const months& __m) noexcept
 {
   *this = *this + __m;
   return *this;
 }

      template<typename = __detail::__months_years_conversion_disambiguator>
 constexpr year_month_day_last&
 operator-=(const months& __m) noexcept
 {
   *this = *this - __m;
   return *this;
 }

      constexpr year_month_day_last&
      operator+=(const years& __y) noexcept
      {
 *this = *this + __y;
 return *this;
      }

      constexpr year_month_day_last&
      operator-=(const years& __y) noexcept
      {
 *this = *this - __y;
 return *this;
      }

      constexpr chrono::year
      year() const noexcept
      { return _M_y; }

      constexpr chrono::month
      month() const noexcept
      { return _M_mdl.month(); }

      constexpr chrono::month_day_last
      month_day_last() const noexcept
      { return _M_mdl; }


      constexpr chrono::day
      day() const noexcept
      {
 const auto __m = static_cast<unsigned>(month());
# 1861 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/chrono" 3
 return chrono::day{__m != 2 ? (__m ^ (__m >> 3)) | 30
   : _M_y.is_leap() ? 29 : 28};
      }

      constexpr
      operator sys_days() const noexcept
      { return sys_days{year() / month() / day()}; }

      explicit constexpr
      operator local_days() const noexcept
      { return local_days{sys_days{*this}.time_since_epoch()}; }

      constexpr bool
      ok() const noexcept
      { return _M_y.ok() && _M_mdl.ok(); }

      friend constexpr bool
      operator==(const year_month_day_last& __x,
   const year_month_day_last& __y) noexcept
      {
 return __x.year() == __y.year()
   && __x.month_day_last() == __y.month_day_last();
      }

      friend constexpr strong_ordering
      operator<=>(const year_month_day_last& __x,
    const year_month_day_last& __y) noexcept
 = default;

      template<typename = __detail::__months_years_conversion_disambiguator>
 friend constexpr year_month_day_last
 operator+(const year_month_day_last& __ymdl,
    const months& __dm) noexcept
 { return (__ymdl.year() / __ymdl.month() + __dm) / last; }

      template<typename = __detail::__months_years_conversion_disambiguator>
 friend constexpr year_month_day_last
 operator+(const months& __dm,
    const year_month_day_last& __ymdl) noexcept
 { return __ymdl + __dm; }

      template<typename = __detail::__months_years_conversion_disambiguator>
 friend constexpr year_month_day_last
 operator-(const year_month_day_last& __ymdl,
    const months& __dm) noexcept
 { return __ymdl + -__dm; }

      friend constexpr year_month_day_last
      operator+(const year_month_day_last& __ymdl,
  const years& __dy) noexcept
      { return {__ymdl.year() + __dy, __ymdl.month_day_last()}; }

      friend constexpr year_month_day_last
      operator+(const years& __dy,
  const year_month_day_last& __ymdl) noexcept
      { return __ymdl + __dy; }

      friend constexpr year_month_day_last
      operator-(const year_month_day_last& __ymdl,
  const years& __dy) noexcept
      { return __ymdl + -__dy; }

      friend constexpr year_month_day_last
      operator/(const year_month& __ym, last_spec) noexcept
      { return {__ym.year(), chrono::month_day_last{__ym.month()}}; }

      friend constexpr year_month_day_last
      operator/(const chrono::year& __y,
  const chrono::month_day_last& __mdl) noexcept
      { return {__y, __mdl}; }

      friend constexpr year_month_day_last
      operator/(int __y, const chrono::month_day_last& __mdl) noexcept
      { return chrono::year(__y) / __mdl; }

      friend constexpr year_month_day_last
      operator/(const chrono::month_day_last& __mdl,
  const chrono::year& __y) noexcept
      { return __y / __mdl; }

      friend constexpr year_month_day_last
      operator/(const chrono::month_day_last& __mdl, int __y) noexcept
      { return chrono::year(__y) / __mdl; }
    };


    constexpr
    year_month_day::year_month_day(const year_month_day_last& __ymdl) noexcept
    : _M_y{__ymdl.year()}, _M_m{__ymdl.month()}, _M_d{__ymdl.day()}
    { }

    constexpr bool
    year_month_day::ok() const noexcept
    {
      if (!_M_y.ok() || !_M_m.ok())
 return false;
      return chrono::day{1} <= _M_d && _M_d <= (_M_y / _M_m / last).day();
    }



    class year_month_weekday
    {
    private:
      chrono::year _M_y;
      chrono::month _M_m;
      chrono::weekday_indexed _M_wdi;

      static constexpr year_month_weekday
      _S_from_sys_days(const sys_days& __dp)
      {
 year_month_day __ymd{__dp};
 chrono::weekday __wd{__dp};
 auto __index = __wd[(unsigned{__ymd.day()} - 1) / 7 + 1];
 return {__ymd.year(), __ymd.month(), __index};
      }

    public:
      year_month_weekday() = default;

      constexpr
      year_month_weekday(const chrono::year& __y, const chrono::month& __m,
    const chrono::weekday_indexed& __wdi) noexcept
      : _M_y{__y}, _M_m{__m}, _M_wdi{__wdi}
      { }

      constexpr
      year_month_weekday(const sys_days& __dp) noexcept
      : year_month_weekday{_S_from_sys_days(__dp)}
      { }

      explicit constexpr
      year_month_weekday(const local_days& __dp) noexcept
      : year_month_weekday{sys_days{__dp.time_since_epoch()}}
      { }

      template<typename = __detail::__months_years_conversion_disambiguator>
 constexpr year_month_weekday&
 operator+=(const months& __m) noexcept
 {
   *this = *this + __m;
   return *this;
 }

      template<typename = __detail::__months_years_conversion_disambiguator>
 constexpr year_month_weekday&
 operator-=(const months& __m) noexcept
 {
   *this = *this - __m;
   return *this;
 }

      constexpr year_month_weekday&
      operator+=(const years& __y) noexcept
      {
 *this = *this + __y;
 return *this;
      }

      constexpr year_month_weekday&
      operator-=(const years& __y) noexcept
      {
 *this = *this - __y;
 return *this;
      }

      constexpr chrono::year
      year() const noexcept
      { return _M_y; }

      constexpr chrono::month
      month() const noexcept
      { return _M_m; }

      constexpr chrono::weekday
      weekday() const noexcept
      { return _M_wdi.weekday(); }

      constexpr unsigned
      index() const noexcept
      { return _M_wdi.index(); }

      constexpr chrono::weekday_indexed
      weekday_indexed() const noexcept
      { return _M_wdi; }

      constexpr
      operator sys_days() const noexcept
      {
 auto __d = sys_days{year() / month() / 1};
 return __d + (weekday() - chrono::weekday(__d)
        + days{(static_cast<int>(index())-1)*7});
      }

      explicit constexpr
      operator local_days() const noexcept
      { return local_days{sys_days{*this}.time_since_epoch()}; }

      constexpr bool
      ok() const noexcept
      {
 if (!_M_y.ok() || !_M_m.ok() || !_M_wdi.ok())
   return false;
 if (_M_wdi.index() <= 4)
   return true;
 days __d = (_M_wdi.weekday()
      - chrono::weekday{sys_days{_M_y / _M_m / 1}}
      + days((_M_wdi.index()-1)*7 + 1));
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__d.count() >= 1), false)) std::__glibcxx_assert_fail(); } while (false);
 return (unsigned)__d.count() <= (unsigned)(_M_y / _M_m / last).day();
      }

      friend constexpr bool
      operator==(const year_month_weekday& __x,
   const year_month_weekday& __y) noexcept
      {
 return __x.year() == __y.year()
   && __x.month() == __y.month()
   && __x.weekday_indexed() == __y.weekday_indexed();
      }

      template<typename = __detail::__months_years_conversion_disambiguator>
 friend constexpr year_month_weekday
 operator+(const year_month_weekday& __ymwd, const months& __dm) noexcept
 {
   return ((__ymwd.year() / __ymwd.month() + __dm)
    / __ymwd.weekday_indexed());
 }

      template<typename = __detail::__months_years_conversion_disambiguator>
 friend constexpr year_month_weekday
 operator+(const months& __dm, const year_month_weekday& __ymwd) noexcept
 { return __ymwd + __dm; }

      friend constexpr year_month_weekday
      operator+(const year_month_weekday& __ymwd, const years& __dy) noexcept
      { return {__ymwd.year() + __dy, __ymwd.month(), __ymwd.weekday_indexed()}; }

      friend constexpr year_month_weekday
      operator+(const years& __dy, const year_month_weekday& __ymwd) noexcept
      { return __ymwd + __dy; }

      template<typename = __detail::__months_years_conversion_disambiguator>
 friend constexpr year_month_weekday
 operator-(const year_month_weekday& __ymwd, const months& __dm) noexcept
 { return __ymwd + -__dm; }

      friend constexpr year_month_weekday
      operator-(const year_month_weekday& __ymwd, const years& __dy) noexcept
      { return __ymwd + -__dy; }

      friend constexpr year_month_weekday
      operator/(const year_month& __ym,
  const chrono::weekday_indexed& __wdi) noexcept
      { return {__ym.year(), __ym.month(), __wdi}; }

      friend constexpr year_month_weekday
      operator/(const chrono::year& __y, const month_weekday& __mwd) noexcept
      { return {__y, __mwd.month(), __mwd.weekday_indexed()}; }

      friend constexpr year_month_weekday
      operator/(int __y, const month_weekday& __mwd) noexcept
      { return chrono::year(__y) / __mwd; }

      friend constexpr year_month_weekday
      operator/(const month_weekday& __mwd, const chrono::year& __y) noexcept
      { return __y / __mwd; }

      friend constexpr year_month_weekday
      operator/(const month_weekday& __mwd, int __y) noexcept
      { return chrono::year(__y) / __mwd; }
    };



    class year_month_weekday_last
    {
    private:
      chrono::year _M_y;
      chrono::month _M_m;
      chrono::weekday_last _M_wdl;

    public:
      constexpr
      year_month_weekday_last(const chrono::year& __y, const chrono::month& __m,
         const chrono::weekday_last& __wdl) noexcept
      : _M_y{__y}, _M_m{__m}, _M_wdl{__wdl}
      { }

      template<typename = __detail::__months_years_conversion_disambiguator>
 constexpr year_month_weekday_last&
 operator+=(const months& __m) noexcept
 {
   *this = *this + __m;
   return *this;
 }

      template<typename = __detail::__months_years_conversion_disambiguator>
 constexpr year_month_weekday_last&
 operator-=(const months& __m) noexcept
 {
   *this = *this - __m;
   return *this;
 }

      constexpr year_month_weekday_last&
      operator+=(const years& __y) noexcept
      {
 *this = *this + __y;
 return *this;
      }

      constexpr year_month_weekday_last&
      operator-=(const years& __y) noexcept
      {
 *this = *this - __y;
 return *this;
      }

      constexpr chrono::year
      year() const noexcept
      { return _M_y; }

      constexpr chrono::month
      month() const noexcept
      { return _M_m; }

      constexpr chrono::weekday
      weekday() const noexcept
      { return _M_wdl.weekday(); }

      constexpr chrono::weekday_last
      weekday_last() const noexcept
      { return _M_wdl; }

      constexpr
      operator sys_days() const noexcept
      {
 const auto __d = sys_days{_M_y / _M_m / last};
 return sys_days{(__d - (chrono::weekday{__d}
    - _M_wdl.weekday())).time_since_epoch()};
      }

      explicit constexpr
      operator local_days() const noexcept
      { return local_days{sys_days{*this}.time_since_epoch()}; }

      constexpr bool
      ok() const noexcept
      { return _M_y.ok() && _M_m.ok() && _M_wdl.ok(); }

      friend constexpr bool
      operator==(const year_month_weekday_last& __x,
   const year_month_weekday_last& __y) noexcept
      {
 return __x.year() == __y.year()
   && __x.month() == __y.month()
   && __x.weekday_last() == __y.weekday_last();
      }

      template<typename = __detail::__months_years_conversion_disambiguator>
 friend constexpr year_month_weekday_last
 operator+(const year_month_weekday_last& __ymwdl,
    const months& __dm) noexcept
 {
   return ((__ymwdl.year() / __ymwdl.month() + __dm)
    / __ymwdl.weekday_last());
 }

      template<typename = __detail::__months_years_conversion_disambiguator>
 friend constexpr year_month_weekday_last
 operator+(const months& __dm,
    const year_month_weekday_last& __ymwdl) noexcept
 { return __ymwdl + __dm; }

      friend constexpr year_month_weekday_last
      operator+(const year_month_weekday_last& __ymwdl,
  const years& __dy) noexcept
      { return {__ymwdl.year() + __dy, __ymwdl.month(), __ymwdl.weekday_last()}; }

      friend constexpr year_month_weekday_last
      operator+(const years& __dy,
  const year_month_weekday_last& __ymwdl) noexcept
      { return __ymwdl + __dy; }

      template<typename = __detail::__months_years_conversion_disambiguator>
 friend constexpr year_month_weekday_last
 operator-(const year_month_weekday_last& __ymwdl,
    const months& __dm) noexcept
 { return __ymwdl + -__dm; }

      friend constexpr year_month_weekday_last
      operator-(const year_month_weekday_last& __ymwdl,
  const years& __dy) noexcept
      { return __ymwdl + -__dy; }

      friend constexpr year_month_weekday_last
      operator/(const year_month& __ym,
  const chrono::weekday_last& __wdl) noexcept
      { return {__ym.year(), __ym.month(), __wdl}; }

      friend constexpr year_month_weekday_last
      operator/(const chrono::year& __y,
  const chrono::month_weekday_last& __mwdl) noexcept
      { return {__y, __mwdl.month(), __mwdl.weekday_last()}; }

      friend constexpr year_month_weekday_last
      operator/(int __y, const chrono::month_weekday_last& __mwdl) noexcept
      { return chrono::year(__y) / __mwdl; }

      friend constexpr year_month_weekday_last
      operator/(const chrono::month_weekday_last& __mwdl,
  const chrono::year& __y) noexcept
      { return __y / __mwdl; }

      friend constexpr year_month_weekday_last
      operator/(const chrono::month_weekday_last& __mwdl, int __y) noexcept
      { return chrono::year(__y) / __mwdl; }
    };




    namespace __detail
    {
      consteval long long
      __pow10(unsigned __n)
      {
 long long __r = 1;
 while (__n-- > 0)
   __r *= 10;
 return __r;
      }

      template<typename _Duration> struct __utc_leap_second;
    }
# 2306 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/chrono" 3
    template<typename _Duration>
      class hh_mm_ss
      {
 static_assert( __is_duration<_Duration>::value );

      private:
 static consteval int
 _S_fractional_width()
 {
   auto __den = _Duration::period::den;
   const int __multiplicity_2 = std::__countr_zero((uintmax_t)__den);
   __den >>= __multiplicity_2;
   int __multiplicity_5 = 0;
   while ((__den % 5) == 0)
     {
       ++__multiplicity_5;
       __den /= 5;
     }
   if (__den != 1)
     return 6;

   int __width = (__multiplicity_2 > __multiplicity_5
    ? __multiplicity_2 : __multiplicity_5);
   if (__width > 18)
     __width = 18;
   return __width;
 }

 constexpr
 hh_mm_ss(_Duration __d, bool __is_neg)
 : _M_h (duration_cast<chrono::hours>(__d)),
   _M_m (duration_cast<chrono::minutes>(__d - hours())),
   _M_s (duration_cast<chrono::seconds>(__d - hours() - minutes())),
   _M_is_neg(__is_neg)
 {
   auto __ss = __d - hours() - minutes() - seconds();
   if constexpr (treat_as_floating_point_v<typename precision::rep>)
     _M_ss._M_r = __ss.count();
   else if constexpr (precision::period::den != 1)
     _M_ss._M_r = duration_cast<precision>(__ss).count();
 }

 static constexpr _Duration
 _S_abs(_Duration __d)
 {
   if constexpr (numeric_limits<typename _Duration::rep>::is_signed)
     return chrono::abs(__d);
   else
     return __d;
 }

      public:
 static constexpr unsigned fractional_width = {_S_fractional_width()};

 using precision
   = duration<common_type_t<typename _Duration::rep,
       chrono::seconds::rep>,
       ratio<1, __detail::__pow10(fractional_width)>>;

 constexpr hh_mm_ss() noexcept = default;

 constexpr explicit
 hh_mm_ss(_Duration __d)
 : hh_mm_ss(_S_abs(__d), __d < _Duration::zero())
 { }

 constexpr bool
 is_negative() const noexcept
 {
   if constexpr (!_S_is_unsigned)
     return _M_is_neg;
   else
     return false;
 }

 constexpr chrono::hours
 hours() const noexcept
 { return _M_h; }

 constexpr chrono::minutes
 minutes() const noexcept
 { return _M_m; }

 constexpr chrono::seconds
 seconds() const noexcept
 { return _M_s; }

 constexpr precision
 subseconds() const noexcept
 { return static_cast<precision>(_M_ss); }

 constexpr explicit
 operator precision() const noexcept
 { return to_duration(); }

 constexpr precision
 to_duration() const noexcept
 {
   if constexpr (!_S_is_unsigned)
     if (_M_is_neg)
       return -(_M_h + _M_m + _M_s + subseconds());
   return _M_h + _M_m + _M_s + subseconds();
 }

      private:
 static constexpr bool _S_is_unsigned
   = __and_v<is_integral<typename _Duration::rep>,
      is_unsigned<typename _Duration::rep>>;

 template<typename _Ratio>
   using __byte_duration = duration<unsigned char, _Ratio>;


 template<typename _Dur>
   struct __subseconds
   {
     typename _Dur::rep _M_r{};

     constexpr explicit
     operator _Dur() const noexcept
     { return _Dur(_M_r); }
   };


 template<typename _Rep>
   requires (!treat_as_floating_point_v<_Rep>)
   struct __subseconds<duration<_Rep, ratio<1>>>
   {
     constexpr explicit
     operator duration<_Rep, ratio<1>>() const noexcept
     { return {}; }
   };

 template<typename _Rep, typename _Period>
   requires (!treat_as_floating_point_v<_Rep>)
     && ratio_less_v<_Period, ratio<1, 1>>
     && ratio_greater_equal_v<_Period, ratio<1, 250>>
   struct __subseconds<duration<_Rep, _Period>>
   {
     unsigned char _M_r{};

     constexpr explicit
     operator duration<_Rep, _Period>() const noexcept
     { return duration<_Rep, _Period>(_M_r); }
   };

 template<typename _Rep, typename _Period>
   requires (!treat_as_floating_point_v<_Rep>)
     && ratio_less_v<_Period, ratio<1, 250>>
     && ratio_greater_equal_v<_Period, ratio<1, 4000000000>>
   struct __subseconds<duration<_Rep, _Period>>
   {
     uint_least32_t _M_r{};

     constexpr explicit
     operator duration<_Rep, _Period>() const noexcept
     { return duration<_Rep, _Period>(_M_r); }
   };

 chrono::hours _M_h{};
 __byte_duration<ratio<60>> _M_m{};
 __byte_duration<ratio<1>> _M_s{};
 bool _M_is_neg{};
 __subseconds<precision> _M_ss{};

 template<typename> friend struct __detail::__utc_leap_second;
      };


    namespace __detail
    {

      template<typename _Duration>
 struct __utc_leap_second
 {
   explicit
   __utc_leap_second(const sys_time<_Duration>& __s)
   : _M_date(chrono::floor<days>(__s)), _M_time(__s - _M_date)
   {
     ++_M_time._M_s;
   }

   sys_days _M_date;
   hh_mm_ss<common_type_t<_Duration, days>> _M_time;
 };
    }




    constexpr bool
    is_am(const hours& __h) noexcept
    { return 0h <= __h && __h <= 11h; }

    constexpr bool
    is_pm(const hours& __h) noexcept
    { return 12h <= __h && __h <= 23h; }

    constexpr hours
    make12(const hours& __h) noexcept
    {
      if (__h == 0h)
 return 12h;
      else if (__h > 12h)
 return __h - 12h;
      return __h;
    }

    constexpr hours
    make24(const hours& __h, bool __is_pm) noexcept
    {
      if (!__is_pm)
 {
   if (__h == 12h)
     return 0h;
   else
     return __h;
 }
      else
 {
   if (__h == 12h)
     return __h;
   else
     return __h + 12h;
 }
    }




    struct tzdb;

    struct sys_info
    {
      sys_seconds begin;
      sys_seconds end;
      seconds offset;
      minutes save;
      string abbrev;
    };

    struct local_info
    {
      static constexpr int unique = 0;
      static constexpr int nonexistent = 1;
      static constexpr int ambiguous = 2;

      int result;
      sys_info first;
      sys_info second;
    };

    class nonexistent_local_time : public runtime_error
    {
    public:
      template<typename _Duration>
 nonexistent_local_time(const local_time<_Duration>& __tp,
          const local_info& __i)
 : runtime_error(_S_make_what_str(__tp, __i))
 { do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__i.result == local_info::nonexistent), false)) std::__glibcxx_assert_fail(); } while (false); }

    private:
      template<typename _Duration>
 static string
 _S_make_what_str(const local_time<_Duration>& __tp,
    const local_info& __i)
 {
   std::ostringstream __os;
   __os << __tp << " is in a gap between\n"
        << local_seconds(__i.first.end.time_since_epoch())
        + __i.first.offset << ' ' << __i.first.abbrev << " and\n"
        << local_seconds(__i.second.begin.time_since_epoch())
        + __i.second.offset << ' ' << __i.second.abbrev
        << " which are both equivalent to\n"
        << __i.first.end << " UTC";
   return std::move(__os).str();
 }
    };

    class ambiguous_local_time : public runtime_error
    {
    public:
      template<typename _Duration>
 ambiguous_local_time(const local_time<_Duration>& __tp,
        const local_info& __i)
 : runtime_error(_S_make_what_str(__tp, __i))
 { do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__i.result == local_info::ambiguous), false)) std::__glibcxx_assert_fail(); } while (false); }

    private:
      template<typename _Duration>
 static string
 _S_make_what_str(const local_time<_Duration>& __tp,
    const local_info& __i)
 {
   std::ostringstream __os;
   __os << __tp << " is ambiguous.  It could be\n"
        << __tp << ' ' << __i.first.abbrev << " == "
        << __tp - __i.first.offset << " UTC or\n"
        << __tp << ' ' << __i.second.abbrev << " == "
        << __tp - __i.second.offset << " UTC";
   return std::move(__os).str();
 }
    };

    template<typename _Duration>
      [[noreturn]] void
      __throw_bad_local_time(const local_time<_Duration>& __tp,
        const local_info& __i)
      {

 if (__i.result == local_info::nonexistent)
   throw nonexistent_local_time(__tp, __i);
 throw ambiguous_local_time(__tp, __i);



      }

    enum class choose { earliest, latest };

    class time_zone
    {
    public:
      time_zone(time_zone&&) = default;
      time_zone& operator=(time_zone&&) = default;

      ~time_zone();

      [[nodiscard]]
      string_view name() const noexcept { return _M_name; }

      template<typename _Duration>
 sys_info
 get_info(const sys_time<_Duration>& __st) const
 { return _M_get_sys_info(chrono::floor<seconds>(__st)); }

      template<typename _Duration>
 local_info
 get_info(const local_time<_Duration>& __tp) const
 { return _M_get_local_info(chrono::floor<seconds>(__tp)); }

      template<typename _Duration>
 sys_time<common_type_t<_Duration, seconds>>
 to_sys(const local_time<_Duration>& __tp) const
 {
   local_info __info = get_info(__tp);

   if (__info.result != local_info::unique)
     __throw_bad_local_time(__tp, __info);

   return sys_time<_Duration>(__tp.time_since_epoch())
     - __info.first.offset;
 }

      template<typename _Duration>
 sys_time<common_type_t<_Duration, seconds>>
 to_sys(const local_time<_Duration>& __tp, choose __z) const
 {
   local_info __info = get_info(__tp);

   if (__info.result == local_info::nonexistent)
     return __info.first.end;

   sys_time<_Duration> __st(__tp.time_since_epoch());

   if (__info.result == local_info::ambiguous && __z == choose::latest)
     return __st - __info.second.offset;


   return __st - __info.first.offset;
 }

      template<typename _Duration>
 local_time<common_type_t<_Duration, seconds>>
 to_local(const sys_time<_Duration>& __tp) const
 {
   auto __d = (__tp + get_info(__tp).offset).time_since_epoch();
   return local_time<common_type_t<_Duration, seconds>>(__d);
 }

      [[nodiscard]] friend bool
      operator==(const time_zone& __x, const time_zone& __y) noexcept
      { return __x._M_name == __y._M_name; }

      [[nodiscard]] friend strong_ordering
      operator<=>(const time_zone& __x, const time_zone& __y) noexcept
      { return __x._M_name <=> __y._M_name; }

    private:
      sys_info _M_get_sys_info(sys_seconds) const;
      local_info _M_get_local_info(local_seconds) const;

      friend const tzdb& reload_tzdb();
      friend struct tzdb;
      friend class tzdb_list;

      struct _Impl;

      explicit time_zone(unique_ptr<_Impl> __p);
      string _M_name;
      unique_ptr<_Impl> _M_impl;
    };

    const time_zone* locate_zone(string_view __tz_name);
    const time_zone* current_zone();
# 2726 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/chrono" 3
    class tzdb_list
    {
      struct _Node;

    public:
      tzdb_list(const tzdb_list&) = delete;
      tzdb_list& operator=(const tzdb_list&) = delete;
# 2741 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/chrono" 3
      class const_iterator
      {
      public:
 using value_type = tzdb;
 using reference = const tzdb&;
 using pointer = const tzdb*;
 using difference_type = ptrdiff_t;
 using iterator_category = forward_iterator_tag;

 constexpr const_iterator() = default;
 const_iterator(const const_iterator&) = default;
 const_iterator(const_iterator&&) = default;
 const_iterator& operator=(const const_iterator&) = default;
 const_iterator& operator=(const_iterator&&) = default;

 reference operator*() const noexcept;
 pointer operator->() const noexcept { return &**this; }
 const_iterator& operator++();
 const_iterator operator++(int);

 bool operator==(const const_iterator&) const noexcept = default;

      private:
 explicit const_iterator(const shared_ptr<_Node>&) noexcept;

 friend class tzdb_list;

 shared_ptr<_Node> _M_node;
 void* _M_reserved = nullptr;
      };
# 2779 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/chrono" 3
      const tzdb& front() const noexcept;
# 2795 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/chrono" 3
      const_iterator erase_after(const_iterator __p);

      const_iterator begin() const noexcept;
      const_iterator end() const noexcept { return {}; }
      const_iterator cbegin() const noexcept { return begin(); }
      const_iterator cend() const noexcept { return end(); }

    private:
      constexpr explicit tzdb_list(nullptr_t);

      friend tzdb_list& get_tzdb_list();
      friend const tzdb& get_tzdb();
      friend const tzdb& reload_tzdb();
      friend struct tzdb;
      friend class leap_second;
      friend struct time_zone::_Impl;
      friend class time_zone_link;
    };

    class time_zone_link
    {
    public:
      time_zone_link(time_zone_link&&) = default;
      time_zone_link& operator=(time_zone_link&&) = default;

      string_view name() const noexcept { return _M_name; }
      string_view target() const noexcept { return _M_target; }

      friend bool
      operator==(const time_zone_link& __x, const time_zone_link& __y) noexcept
      { return __x.name() == __y.name(); }

      friend strong_ordering
      operator<=>(const time_zone_link& __x, const time_zone_link& __y) noexcept
      { return __x.name() <=> __y.name(); }

    private:
      friend const tzdb& reload_tzdb();
      friend struct tzdb_list::_Node;

      explicit time_zone_link(nullptr_t) { }

      string _M_name;
      string _M_target;
    };

    class leap_second
    {
    public:
      leap_second(const leap_second&) = default;
      leap_second& operator=(const leap_second&) = default;

      [[nodiscard]]
      constexpr sys_seconds
      date() const noexcept
      {
 if (_M_s >= _M_s.zero()) [[likely]]
   return sys_seconds(_M_s);
 return sys_seconds(-_M_s);
      }

      [[nodiscard]]
      constexpr seconds
      value() const noexcept
      {
 if (_M_s >= _M_s.zero()) [[likely]]
   return seconds(1);
 return seconds(-1);
      }



      [[nodiscard]] friend constexpr bool
      operator==(const leap_second&, const leap_second&) noexcept = default;

      [[nodiscard]] friend constexpr strong_ordering
      operator<=>(const leap_second& __x, const leap_second& __y) noexcept
      { return __x.date() <=> __y.date(); }

      template<typename _Duration>
 [[nodiscard]] friend constexpr bool
 operator==(const leap_second& __x,
     const sys_time<_Duration>& __y) noexcept
 { return __x.date() == __y; }

      template<typename _Duration>
 [[nodiscard]] friend constexpr bool
 operator<(const leap_second& __x,
    const sys_time<_Duration>& __y) noexcept
 { return __x.date() < __y; }

      template<typename _Duration>
 [[nodiscard]] friend constexpr bool
 operator<(const sys_time<_Duration>& __x,
    const leap_second& __y) noexcept
 { return __x < __y.date(); }

      template<typename _Duration>
 [[nodiscard]] friend constexpr bool
 operator>(const leap_second& __x,
    const sys_time<_Duration>& __y) noexcept
 { return __y < __x.date(); }

      template<typename _Duration>
 [[nodiscard]] friend constexpr bool
 operator>(const sys_time<_Duration>& __x,
    const leap_second& __y) noexcept
 { return __y.date() < __x; }

      template<typename _Duration>
 [[nodiscard]] friend constexpr bool
 operator<=(const leap_second& __x,
     const sys_time<_Duration>& __y) noexcept
 { return !(__y < __x.date()); }

      template<typename _Duration>
 [[nodiscard]] friend constexpr bool
 operator<=(const sys_time<_Duration>& __x,
     const leap_second& __y) noexcept
 { return !(__y.date() < __x); }

      template<typename _Duration>
 [[nodiscard]] friend constexpr bool
 operator>=(const leap_second& __x,
     const sys_time<_Duration>& __y) noexcept
 { return !(__x.date() < __y); }

      template<typename _Duration>
 [[nodiscard]] friend constexpr bool
 operator>=(const sys_time<_Duration>& __x,
     const leap_second& __y) noexcept
 { return !(__x < __y.date()); }

      template<three_way_comparable_with<seconds> _Duration>
 [[nodiscard]] friend constexpr auto
 operator<=>(const leap_second& __x,
      const sys_time<_Duration>& __y) noexcept
 { return __x.date() <=> __y; }

    private:
      explicit leap_second(seconds::rep __s) : _M_s(__s) { }

      friend struct tzdb_list::_Node;

      friend const tzdb& reload_tzdb();

      template<typename _Duration>
 friend leap_second_info
 get_leap_second_info(const utc_time<_Duration>&);

      seconds _M_s;
    };

    template<class _Tp> struct zoned_traits { };

    template<>
      struct zoned_traits<const time_zone*>
      {
 static const time_zone*
 default_zone()
 { return std::chrono::locate_zone("UTC"); }

 static const time_zone*
 locate_zone(string_view __name)
 { return std::chrono::locate_zone(__name); }
      };

    struct tzdb
    {
      string version;
      std::vector<time_zone> zones;
      std::vector<time_zone_link> links;
      std::vector<leap_second> leap_seconds;

      const time_zone*
      locate_zone(string_view __tz_name) const;

      const time_zone*
      current_zone() const;

    private:
      friend const tzdb& reload_tzdb();
      friend class time_zone;
      friend struct tzdb_list::_Node;
    };

    tzdb_list& get_tzdb_list();
    const tzdb& get_tzdb();

    const tzdb& reload_tzdb();
    string remote_version();

    template<typename _Duration, typename _TimeZonePtr = const time_zone*>
      class zoned_time
      {
 static_assert(__is_duration_v<_Duration>);

 using _Traits = zoned_traits<_TimeZonePtr>;



 using string_view = type_identity_t<std::string_view>;

      public:
 using duration = common_type_t<_Duration, seconds>;

 zoned_time() requires requires { _Traits::default_zone(); }
 { }

 zoned_time(const zoned_time&) = default;
 zoned_time& operator=(const zoned_time&) = default;

 zoned_time(const sys_time<_Duration>& __st)
   requires requires { _Traits::default_zone(); }
 : _M_tp(__st)
 { }

 explicit
 zoned_time(_TimeZonePtr __z) : _M_zone(std::move(__z)) { }

 explicit
 zoned_time(string_view __name)
   requires requires {
     _TimeZonePtr{_Traits::locate_zone(std::string_view{})};
   }
 : _M_zone(_Traits::locate_zone(__name))
 { }

 template<typename _Duration2>
   zoned_time(const zoned_time<_Duration2, _TimeZonePtr>& __zt)
   requires is_convertible_v<sys_time<_Duration2>, sys_time<_Duration>>
   : _M_zone(__zt._M_zone), _M_tp(__zt._M_tp)
   { }

 zoned_time(_TimeZonePtr __z, const sys_time<_Duration>& __st)
 : _M_zone(std::move(__z)), _M_tp(__st)
 { }

 zoned_time(string_view __name, const sys_time<_Duration>& __st)
 : zoned_time(_Traits::locate_zone(__name), __st)
 { }

 zoned_time(_TimeZonePtr __z, const local_time<_Duration>& __tp)
 requires requires {
   { __z->to_sys(__tp) } -> convertible_to<sys_time<_Duration>>;
 }
 : _M_zone(std::move(__z)), _M_tp(_M_zone->to_sys(__tp))
 { }

 zoned_time(string_view __name, const local_time<_Duration>& __tp)
 requires requires (_TimeZonePtr __z) {
   { _Traits::locate_zone(__name) } -> convertible_to<_TimeZonePtr>;
   { __z->to_sys(__tp) } -> convertible_to<sys_time<_Duration>>;
 }
 : zoned_time(_Traits::locate_zone(__name), __tp)
 { }

 zoned_time(_TimeZonePtr __z, const local_time<_Duration>& __tp,
     choose __c)
 requires requires {
   { __z->to_sys(__tp, __c) } -> convertible_to<sys_time<_Duration>>;
 }
 : _M_zone(std::move(__z)), _M_tp(_M_zone->to_sys(__tp, __c))
 { }

 zoned_time(string_view __name, const local_time<_Duration>& __tp,
     choose __c)
 requires requires (_TimeZonePtr __z) {
   { _Traits::locate_zone(__name) } -> convertible_to<_TimeZonePtr>;
   { __z->to_sys(__tp, __c) } -> convertible_to<sys_time<_Duration>>;
 }
 : _M_zone(_Traits::locate_zone(__name)),
   _M_tp(_M_zone->to_sys(__tp, __c))
 { }

 template<typename _Duration2, typename _TimeZonePtr2>
   zoned_time(_TimeZonePtr __z,
       const zoned_time<_Duration2, _TimeZonePtr2>& __zt)
   requires is_convertible_v<sys_time<_Duration2>, sys_time<_Duration>>
   : _M_zone(__z), _M_tp(__zt._M_tp)
   { }

 template<typename _Duration2, typename _TimeZonePtr2>
   zoned_time(_TimeZonePtr __z,
       const zoned_time<_Duration2, _TimeZonePtr2>& __zt,
       choose)
   requires is_convertible_v<sys_time<_Duration2>, sys_time<_Duration>>
   : _M_zone(__z), _M_tp(__zt._M_tp)
   { }

 template<typename _Duration2, typename _TimeZonePtr2>
   zoned_time(string_view __name,
       const zoned_time<_Duration2, _TimeZonePtr2>& __zt)
   requires is_convertible_v<sys_time<_Duration2>, sys_time<_Duration>>
   && requires {
     { _Traits::locate_zone(__name) } -> convertible_to<_TimeZonePtr>;
   }
   : _M_zone(_Traits::locate_zone(__name)), _M_tp(__zt._M_tp)
   { }

 template<typename _Duration2, typename _TimeZonePtr2>
   zoned_time(string_view __name,
       const zoned_time<_Duration2, _TimeZonePtr2>& __zt,
       choose)
   requires is_convertible_v<sys_time<_Duration2>, sys_time<_Duration>>
   && requires {
     { _Traits::locate_zone(__name) } -> convertible_to<_TimeZonePtr>;
   }
   : _M_zone(_Traits::locate_zone(__name)), _M_tp(__zt._M_tp)
   { }

 zoned_time&
 operator=(const sys_time<_Duration>& __st)
 {
   _M_tp = __st;
   return *this;
 }

 zoned_time&
 operator=(const local_time<_Duration>& __lt)
 {
   _M_tp = _M_zone->to_sys(__lt);
   return *this;
 }

 [[nodiscard]]
 operator sys_time<duration>() const { return _M_tp; }

 [[nodiscard]]
 explicit operator local_time<duration>() const
 { return get_local_time(); }

 [[nodiscard]]
 _TimeZonePtr
 get_time_zone() const
 { return _M_zone; }

 [[nodiscard]]
 local_time<duration>
 get_local_time() const
 { return _M_zone->to_local(_M_tp); }

 [[nodiscard]]
 sys_time<duration>
 get_sys_time() const
 { return _M_tp; }

 [[nodiscard]]
 sys_info
 get_info() const
 { return _M_zone->get_info(_M_tp); }

 [[nodiscard]] friend bool
 operator==(const zoned_time&, const zoned_time&) = default;

      private:
 _TimeZonePtr _M_zone{ _Traits::default_zone() };
 sys_time<duration> _M_tp{};

 template<typename _Duration2, typename _TimeZonePtr2>
   friend class zoned_time;
      };

    zoned_time() -> zoned_time<seconds>;

    template<typename _Duration>
    zoned_time(sys_time<_Duration>)
      -> zoned_time<common_type_t<_Duration, seconds>>;


  template<typename _TimeZonePtrOrName>
    using __time_zone_representation
      = __conditional_t<is_convertible_v<_TimeZonePtrOrName, string_view>,
   const time_zone*,
   remove_cvref_t<_TimeZonePtrOrName>>;


  template<typename _TimeZonePtrOrName>
    zoned_time(_TimeZonePtrOrName&&)
      -> zoned_time<seconds, __time_zone_representation<_TimeZonePtrOrName>>;

  template<typename _TimeZonePtrOrName, typename _Duration>
    zoned_time(_TimeZonePtrOrName&&, sys_time<_Duration>)
      -> zoned_time<common_type_t<_Duration, seconds>,
                    __time_zone_representation<_TimeZonePtrOrName>>;

  template<typename _TimeZonePtrOrName, typename _Duration>
    zoned_time(_TimeZonePtrOrName&&, local_time<_Duration>,
               choose = choose::earliest)
      -> zoned_time<common_type_t<_Duration, seconds>,
                    __time_zone_representation<_TimeZonePtrOrName>>;

  template<typename _Duration, typename _TimeZonePtrOrName,
    typename _TimeZonePtr2>
    zoned_time(_TimeZonePtrOrName&&, zoned_time<_Duration, _TimeZonePtr2>,
               choose = choose::earliest)
      -> zoned_time<common_type_t<_Duration, seconds>,
                    __time_zone_representation<_TimeZonePtrOrName>>;

  template<typename _Dur1, typename _TZPtr1, typename _Dur2, typename _TZPtr2>
    [[nodiscard]]
    inline bool
    operator==(const zoned_time<_Dur1, _TZPtr1>& __x,
        const zoned_time<_Dur2, _TZPtr2>& __y)
    {
      return __x.get_time_zone() == __y.get_time_zone()
        && __x.get_sys_time() == __y.get_sys_time();
    }

    using zoned_seconds = zoned_time<seconds>;


namespace __detail
{
    inline leap_second_info
    __get_leap_second_info(sys_seconds __ss, bool __is_utc)
    {
      if (__ss < sys_seconds{}) [[unlikely]]
 return {};

      const seconds::rep __leaps[] {
   78796800,
   94694400,
  126230400,
  157766400,
  189302400,
  220924800,
  252460800,
  283996800,
  315532800,
  362793600,
  394329600,
  425865600,
  489024000,
  567993600,
  631152000,
  662688000,
  709948800,
  741484800,
  773020800,
  820454400,
  867715200,
  915148800,
 1136073600,
 1230768000,
 1341100800,
 1435708800,
 1483228800,
      };


      const sys_seconds __expires(1735344000s);


      if (__ss > __expires)
 {

   size_t __n = std::size(__leaps);

   auto __db = get_tzdb_list().begin();
   auto __first = __db->leap_seconds.begin() + __n;
   auto __last = __db->leap_seconds.end();
   auto __pos = std::upper_bound(__first, __last, __ss);
   seconds __elapsed(__n);
   for (auto __i = __first; __i != __pos; ++__i)
     __elapsed += __i->value();

   if (__is_utc)
     {

       __ss -= __elapsed;

       if (__pos != __first && __ss < __pos[-1])
  {
    if ((__ss + 1s) >= __pos[-1])
      return {true, __elapsed};
    __elapsed -= __pos[-1].value();
  }
     }
   return {false, __elapsed};
 }
      else

 {
   seconds::rep __s = __ss.time_since_epoch().count();
   const seconds::rep* __first = std::begin(__leaps);
   const seconds::rep* __last = std::end(__leaps);


   if (__s > (__last[-1] + (__last - __first) + 1))
     return { false, seconds(__last - __first) };

   auto __pos = std::upper_bound(__first, __last, __s);
   seconds __elapsed{__pos - __first};
   if (__is_utc)
     {

       __s -= __elapsed.count();

       if (__pos != __first && __s < __pos[-1])
  {
    if ((__s + 1) >= __pos[-1])
      return {true, __elapsed};
    --__elapsed;
  }
     }
   return {false, __elapsed};
 }
    }
}

    template<typename _Duration>
      [[nodiscard]]
      inline leap_second_info
      get_leap_second_info(const utc_time<_Duration>& __ut)
      {
 auto __s = chrono::duration_cast<seconds>(__ut.time_since_epoch());
 return __detail::__get_leap_second_info(sys_seconds(__s), true);
      }

    template<typename _Duration>
      [[nodiscard]]
      inline utc_time<common_type_t<_Duration, seconds>>
      utc_clock::from_sys(const sys_time<_Duration>& __t)
      {
 using _CDur = common_type_t<_Duration, seconds>;
 auto __s = chrono::time_point_cast<seconds>(__t);
 const auto __li = __detail::__get_leap_second_info(__s, false);
 return utc_time<_CDur>{__t.time_since_epoch()} + __li.elapsed;
      }



  }


  inline namespace literals
  {
  inline namespace chrono_literals
  {


#pragma GCC diagnostic push



    constexpr chrono::day
    operator""d(unsigned long long __d) noexcept
    { return chrono::day{static_cast<unsigned>(__d)}; }



    constexpr chrono::year
    operator""y(unsigned long long __y) noexcept
    { return chrono::year{static_cast<int>(__y)}; }
#pragma GCC diagnostic pop

  }
  }



}


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/chrono_io.h" 1 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/chrono_io.h" 3




# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/iomanip" 1 3
# 37 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/iomanip" 3








# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 46 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/iomanip" 2 3




# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/quoted_string.h" 1 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/quoted_string.h" 3






namespace std __attribute__ ((__visibility__ ("default")))
{


  namespace __detail {



    template<typename _String, typename _CharT>
      struct _Quoted_string
      {
 static_assert(is_reference<_String>::value
     || is_pointer<_String>::value,
        "String type must be pointer or reference");

 _Quoted_string(_String __str, _CharT __del, _CharT __esc)
 : _M_string(__str), _M_delim{__del}, _M_escape{__esc}
 { }

 _Quoted_string&
 operator=(_Quoted_string&) = delete;

 _String _M_string;
 _CharT _M_delim;
 _CharT _M_escape;
      };


    template<typename _CharT, typename _Traits>
      struct _Quoted_string<basic_string_view<_CharT, _Traits>, _CharT>
      {
 _Quoted_string(basic_string_view<_CharT, _Traits> __str,
         _CharT __del, _CharT __esc)
 : _M_string(__str), _M_delim{__del}, _M_escape{__esc}
 { }

 _Quoted_string&
 operator=(_Quoted_string&) = delete;

 basic_string_view<_CharT, _Traits> _M_string;
 _CharT _M_delim;
 _CharT _M_escape;
      };







    template<typename _CharT, typename _Traits>
      std::basic_ostream<_CharT, _Traits>&
      operator<<(std::basic_ostream<_CharT, _Traits>& __os,
   const _Quoted_string<const _CharT*, _CharT>& __str)
      {


 std::basic_ostringstream<_CharT, _Traits> __ostr;
 __ostr << __str._M_delim;
 for (const _CharT* __c = __str._M_string; *__c; ++__c)
   {
     if (*__c == __str._M_delim || *__c == __str._M_escape)
       __ostr << __str._M_escape;
     __ostr << *__c;
   }
 __ostr << __str._M_delim;

 return __os << __ostr.str();
      }






    template<typename _CharT, typename _Traits, typename _String>
      std::basic_ostream<_CharT, _Traits>&
      operator<<(std::basic_ostream<_CharT, _Traits>& __os,
   const _Quoted_string<_String, _CharT>& __str)
      {


 std::basic_ostringstream<_CharT, _Traits> __ostr;
 __ostr << __str._M_delim;
 for (auto __c : __str._M_string)
   {
     if (__c == __str._M_delim || __c == __str._M_escape)
       __ostr << __str._M_escape;
     __ostr << __c;
   }
 __ostr << __str._M_delim;

 return __os << __ostr.str();
      }







    template<typename _CharT, typename _Traits, typename _Alloc>
      std::basic_istream<_CharT, _Traits>&
      operator>>(std::basic_istream<_CharT, _Traits>& __is,
   const _Quoted_string<basic_string<_CharT, _Traits, _Alloc>&,
          _CharT>& __str)
      {
 _CharT __c;
 __is >> __c;
 if (!__is.good())
   return __is;
 if (__c != __str._M_delim)
   {
     __is.unget();
     __is >> __str._M_string;
     return __is;
   }
 __str._M_string.clear();
 std::ios_base::fmtflags __flags
   = __is.flags(__is.flags() & ~std::ios_base::skipws);
 do
   {
     __is >> __c;
     if (!__is.good())
       break;
     if (__c == __str._M_escape)
       {
  __is >> __c;
  if (!__is.good())
    break;
       }
     else if (__c == __str._M_delim)
       break;
     __str._M_string += __c;
   }
 while (true);
 __is.setf(__flags);

 return __is;
      }
  }


}
# 51 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/iomanip" 2 3



namespace std __attribute__ ((__visibility__ ("default")))
{





  struct _Resetiosflags { ios_base::fmtflags _M_mask; };
# 70 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/iomanip" 3
  inline _Resetiosflags
  resetiosflags(ios_base::fmtflags __mask)
  { return { __mask }; }

  template<typename _CharT, typename _Traits>
    inline basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __is, _Resetiosflags __f)
    {
      __is.setf(ios_base::fmtflags(0), __f._M_mask);
      return __is;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, _Resetiosflags __f)
    {
      __os.setf(ios_base::fmtflags(0), __f._M_mask);
      return __os;
    }


  struct _Setiosflags { ios_base::fmtflags _M_mask; };
# 100 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/iomanip" 3
  inline _Setiosflags
  setiosflags(ios_base::fmtflags __mask)
  { return { __mask }; }

  template<typename _CharT, typename _Traits>
    inline basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __is, _Setiosflags __f)
    {
      __is.setf(__f._M_mask);
      return __is;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, _Setiosflags __f)
    {
      __os.setf(__f._M_mask);
      return __os;
    }


  struct _Setbase { int _M_base; };
# 131 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/iomanip" 3
  inline _Setbase
  setbase(int __base)
  { return { __base }; }

  template<typename _CharT, typename _Traits>
    inline basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __is, _Setbase __f)
    {
      __is.setf(__f._M_base == 8 ? ios_base::oct :
  __f._M_base == 10 ? ios_base::dec :
  __f._M_base == 16 ? ios_base::hex :
  ios_base::fmtflags(0), ios_base::basefield);
      return __is;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, _Setbase __f)
    {
      __os.setf(__f._M_base == 8 ? ios_base::oct :
  __f._M_base == 10 ? ios_base::dec :
  __f._M_base == 16 ? ios_base::hex :
  ios_base::fmtflags(0), ios_base::basefield);
      return __os;
    }


  template<typename _CharT>
    struct _Setfill { _CharT _M_c; };
# 168 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/iomanip" 3
  template<typename _CharT>
    inline _Setfill<_CharT>
    setfill(_CharT __c)
    { return { __c }; }

  template<typename _CharT, typename _Traits>
    __attribute__((__deprecated__("'std::setfill' should only be used with "
      "output streams")))
    inline basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __is, _Setfill<_CharT> __f)
    {
      __is.fill(__f._M_c);
      return __is;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, _Setfill<_CharT> __f)
    {
      __os.fill(__f._M_c);
      return __os;
    }


  struct _Setprecision { int _M_n; };
# 201 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/iomanip" 3
  inline _Setprecision
  setprecision(int __n)
  { return { __n }; }

  template<typename _CharT, typename _Traits>
    inline basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __is, _Setprecision __f)
    {
      __is.precision(__f._M_n);
      return __is;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, _Setprecision __f)
    {
      __os.precision(__f._M_n);
      return __os;
    }


  struct _Setw { int _M_n; };
# 231 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/iomanip" 3
  inline _Setw
  setw(int __n)
  { return { __n }; }

  template<typename _CharT, typename _Traits>
    inline basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __is, _Setw __f)
    {
      __is.width(__f._M_n);
      return __is;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, _Setw __f)
    {
      __os.width(__f._M_n);
      return __os;
    }



  template<typename _MoneyT>
    struct _Get_money { _MoneyT& _M_mon; bool _M_intl; };
# 264 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/iomanip" 3
  template<typename _MoneyT>
    inline _Get_money<_MoneyT>
    get_money(_MoneyT& __mon, bool __intl = false)
    { return { __mon, __intl }; }

  template<typename _CharT, typename _Traits, typename _MoneyT>
    basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __is, _Get_money<_MoneyT> __f)
    {
      typename basic_istream<_CharT, _Traits>::sentry __cerb(__is, false);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {
       typedef istreambuf_iterator<_CharT, _Traits> _Iter;
       typedef money_get<_CharT, _Iter> _MoneyGet;

       const _MoneyGet& __mg = use_facet<_MoneyGet>(__is.getloc());
       __mg.get(_Iter(__is.rdbuf()), _Iter(), __f._M_intl,
         __is, __err, __f._M_mon);
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       __is._M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { __is._M_setstate(ios_base::badbit); }
   if (__err)
     __is.setstate(__err);
 }
      return __is;
    }


  template<typename _MoneyT>
    struct _Put_money { const _MoneyT& _M_mon; bool _M_intl; };
# 311 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/iomanip" 3
  template<typename _MoneyT>
    inline _Put_money<_MoneyT>
    put_money(const _MoneyT& __mon, bool __intl = false)
    { return { __mon, __intl }; }

  template<typename _CharT, typename _Traits, typename _MoneyT>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, _Put_money<_MoneyT> __f)
    {
      typename basic_ostream<_CharT, _Traits>::sentry __cerb(__os);
      if (__cerb)
 {
   ios_base::iostate __err = ios_base::goodbit;
   try
     {
       typedef ostreambuf_iterator<_CharT, _Traits> _Iter;
       typedef money_put<_CharT, _Iter> _MoneyPut;

       const _MoneyPut& __mp = use_facet<_MoneyPut>(__os.getloc());
       if (__mp.put(_Iter(__os.rdbuf()), __f._M_intl, __os,
      __os.fill(), __f._M_mon).failed())
  __err |= ios_base::badbit;
     }
   catch(__cxxabiv1::__forced_unwind&)
     {
       __os._M_setstate(ios_base::badbit);
       throw;
     }
   catch(...)
     { __os._M_setstate(ios_base::badbit); }
   if (__err)
     __os.setstate(__err);
 }
      return __os;
    }

  template<typename _CharT>
    struct _Put_time
    {
      const std::tm* _M_tmb;
      const _CharT* _M_fmt;
    };
# 363 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/iomanip" 3
  template<typename _CharT>
    inline _Put_time<_CharT>
    put_time(const std::tm* __tmb, const _CharT* __fmt)
    { return { __tmb, __fmt }; }

  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, _Put_time<_CharT> __f)
    {
      typename basic_ostream<_CharT, _Traits>::sentry __cerb(__os);
      if (__cerb)
        {
          ios_base::iostate __err = ios_base::goodbit;
          try
            {
              typedef ostreambuf_iterator<_CharT, _Traits> _Iter;
              typedef time_put<_CharT, _Iter> _TimePut;

              const _CharT* const __fmt_end = __f._M_fmt +
                _Traits::length(__f._M_fmt);

              const _TimePut& __mp = use_facet<_TimePut>(__os.getloc());
              if (__mp.put(_Iter(__os.rdbuf()), __os, __os.fill(),
                           __f._M_tmb, __f._M_fmt, __fmt_end).failed())
                __err |= ios_base::badbit;
            }
          catch(__cxxabiv1::__forced_unwind&)
            {
              __os._M_setstate(ios_base::badbit);
              throw;
            }
          catch(...)
            { __os._M_setstate(ios_base::badbit); }
          if (__err)
            __os.setstate(__err);
        }
      return __os;
    }

  template<typename _CharT>
    struct _Get_time
    {
      std::tm* _M_tmb;
      const _CharT* _M_fmt;
    };
# 418 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/iomanip" 3
  template<typename _CharT>
    inline _Get_time<_CharT>
    get_time(std::tm* __tmb, const _CharT* __fmt)
    { return { __tmb, __fmt }; }

  template<typename _CharT, typename _Traits>
    basic_istream<_CharT, _Traits>&
    operator>>(basic_istream<_CharT, _Traits>& __is, _Get_time<_CharT> __f)
    {
      typename basic_istream<_CharT, _Traits>::sentry __cerb(__is, false);
      if (__cerb)
        {
          ios_base::iostate __err = ios_base::goodbit;
          try
            {
              typedef istreambuf_iterator<_CharT, _Traits> _Iter;
              typedef time_get<_CharT, _Iter> _TimeGet;

              const _CharT* const __fmt_end = __f._M_fmt +
                _Traits::length(__f._M_fmt);

              const _TimeGet& __mg = use_facet<_TimeGet>(__is.getloc());
              __mg.get(_Iter(__is.rdbuf()), _Iter(), __is,
                       __err, __f._M_tmb, __f._M_fmt, __fmt_end);
            }
          catch(__cxxabiv1::__forced_unwind&)
            {
              __is._M_setstate(ios_base::badbit);
              throw;
            }
          catch(...)
            { __is._M_setstate(ios_base::badbit); }
          if (__err)
            __is.setstate(__err);
        }
      return __is;
    }
# 465 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/iomanip" 3
  template<typename _CharT>
    inline auto
    quoted(const _CharT* __string,
    _CharT __delim = _CharT('"'), _CharT __escape = _CharT('\\'))
    {
      return __detail::_Quoted_string<const _CharT*, _CharT>(__string, __delim,
            __escape);
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    inline auto
    quoted(const basic_string<_CharT, _Traits, _Alloc>& __string,
    _CharT __delim = _CharT('"'), _CharT __escape = _CharT('\\'))
    {
      return __detail::_Quoted_string<
 const basic_string<_CharT, _Traits, _Alloc>&, _CharT>(
     __string, __delim, __escape);
    }

  template<typename _CharT, typename _Traits, typename _Alloc>
    inline auto
    quoted(basic_string<_CharT, _Traits, _Alloc>& __string,
    _CharT __delim = _CharT('"'), _CharT __escape = _CharT('\\'))
    {
      return __detail::_Quoted_string<
 basic_string<_CharT, _Traits, _Alloc>&, _CharT>(
     __string, __delim, __escape);
    }




  template<typename _CharT, typename _Traits>
    inline auto
    quoted(basic_string_view<_CharT, _Traits> __sv,
    _CharT __delim = _CharT('"'), _CharT __escape = _CharT('\\'))
    {
      return __detail::_Quoted_string<
 basic_string_view<_CharT, _Traits>, _CharT>(__sv, __delim, __escape);
    }
# 514 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/iomanip" 3
  extern template ostream& operator<<(ostream&, _Setfill<char>);
  extern template ostream& operator<<(ostream&, _Setiosflags);
  extern template ostream& operator<<(ostream&, _Resetiosflags);
  extern template ostream& operator<<(ostream&, _Setbase);
  extern template ostream& operator<<(ostream&, _Setprecision);
  extern template ostream& operator<<(ostream&, _Setw);
  extern template istream& operator>>(istream&, _Setfill<char>);
  extern template istream& operator>>(istream&, _Setiosflags);
  extern template istream& operator>>(istream&, _Resetiosflags);
  extern template istream& operator>>(istream&, _Setbase);
  extern template istream& operator>>(istream&, _Setprecision);
  extern template istream& operator>>(istream&, _Setw);


  extern template wostream& operator<<(wostream&, _Setfill<wchar_t>);
  extern template wostream& operator<<(wostream&, _Setiosflags);
  extern template wostream& operator<<(wostream&, _Resetiosflags);
  extern template wostream& operator<<(wostream&, _Setbase);
  extern template wostream& operator<<(wostream&, _Setprecision);
  extern template wostream& operator<<(wostream&, _Setw);
  extern template wistream& operator>>(wistream&, _Setfill<wchar_t>);
  extern template wistream& operator>>(wistream&, _Setiosflags);
  extern template wistream& operator>>(wistream&, _Resetiosflags);
  extern template wistream& operator>>(wistream&, _Setbase);
  extern template wistream& operator>>(wistream&, _Setprecision);
  extern template wistream& operator>>(wistream&, _Setw);




}
# 39 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/chrono_io.h" 2 3





namespace std __attribute__ ((__visibility__ ("default")))
{


namespace chrono
{




namespace __detail
{





  template<typename _CharT>
    consteval auto
    _Widen(const char* __narrow, const wchar_t* __wide)
    {
      if constexpr (is_same_v<_CharT, wchar_t>)
 return __wide;
      else
 return __narrow;
    }



  template<typename _Period, typename _CharT>
    constexpr basic_string_view<_CharT>
    __units_suffix() noexcept
    {
# 85 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/chrono_io.h" 3
      if constexpr (is_same_v<_Period, atto>) return ::std::chrono::__detail::_Widen<_CharT>("as", L"as"); else
      if constexpr (is_same_v<_Period, femto>) return ::std::chrono::__detail::_Widen<_CharT>("fs", L"fs"); else
      if constexpr (is_same_v<_Period, pico>) return ::std::chrono::__detail::_Widen<_CharT>("ps", L"ps"); else
      if constexpr (is_same_v<_Period, nano>) return ::std::chrono::__detail::_Widen<_CharT>("ns", L"ns"); else
      if constexpr (is_same_v<_Period, milli>) return ::std::chrono::__detail::_Widen<_CharT>("ms", L"ms"); else





      if constexpr (is_same_v<_Period, micro>) return ::std::chrono::__detail::_Widen<_CharT>("us", L"us"); else

      if constexpr (is_same_v<_Period, centi>) return ::std::chrono::__detail::_Widen<_CharT>("cs", L"cs"); else
      if constexpr (is_same_v<_Period, deci>) return ::std::chrono::__detail::_Widen<_CharT>("ds", L"ds"); else
      if constexpr (is_same_v<_Period, ratio<1> >) return ::std::chrono::__detail::_Widen<_CharT>("s", L"s"); else
      if constexpr (is_same_v<_Period, deca>) return ::std::chrono::__detail::_Widen<_CharT>("das", L"das"); else
      if constexpr (is_same_v<_Period, hecto>) return ::std::chrono::__detail::_Widen<_CharT>("hs", L"hs"); else
      if constexpr (is_same_v<_Period, kilo>) return ::std::chrono::__detail::_Widen<_CharT>("ks", L"ks"); else
      if constexpr (is_same_v<_Period, mega>) return ::std::chrono::__detail::_Widen<_CharT>("Ms", L"Ms"); else
      if constexpr (is_same_v<_Period, giga>) return ::std::chrono::__detail::_Widen<_CharT>("Gs", L"Gs"); else
      if constexpr (is_same_v<_Period, tera>) return ::std::chrono::__detail::_Widen<_CharT>("Ts", L"Ts"); else
      if constexpr (is_same_v<_Period, tera>) return ::std::chrono::__detail::_Widen<_CharT>("Ts", L"Ts"); else
      if constexpr (is_same_v<_Period, peta>) return ::std::chrono::__detail::_Widen<_CharT>("Ps", L"Ps"); else
      if constexpr (is_same_v<_Period, exa>) return ::std::chrono::__detail::_Widen<_CharT>("Es", L"Es"); else
      if constexpr (is_same_v<_Period, ratio<60> >) return ::std::chrono::__detail::_Widen<_CharT>("min", L"min"); else
      if constexpr (is_same_v<_Period, ratio<3600> >) return ::std::chrono::__detail::_Widen<_CharT>("h", L"h"); else
      if constexpr (is_same_v<_Period, ratio<86400> >) return ::std::chrono::__detail::_Widen<_CharT>("d", L"d"); else

 return {};
    }

  template<typename _Period, typename _CharT, typename _Out>
    inline _Out
    __fmt_units_suffix(_Out __out) noexcept
    {
      if (auto __s = __detail::__units_suffix<_Period, _CharT>(); __s.size())
 return __format::__write(std::move(__out), __s);
      else if constexpr (_Period::den == 1)
 return std::format_to(std::move(__out), ::std::chrono::__detail::_Widen<_CharT>("[{}]s", L"[{}]s"),
         (uintmax_t)_Period::num);
      else
 return std::format_to(std::move(__out), ::std::chrono::__detail::_Widen<_CharT>("[{}/{}]s", L"[{}/{}]s"),
         (uintmax_t)_Period::num,
         (uintmax_t)_Period::den);
    }
}






  template<typename _CharT, typename _Traits,
    typename _Rep, typename _Period>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(std::basic_ostream<_CharT, _Traits>& __os,
        const duration<_Rep, _Period>& __d)
    {
      using _Out = ostreambuf_iterator<_CharT, _Traits>;
      using period = typename _Period::type;
      std::basic_ostringstream<_CharT, _Traits> __s;
      __s.flags(__os.flags());
      __s.imbue(__os.getloc());
      __s.precision(__os.precision());
      __s << __d.count();
      __detail::__fmt_units_suffix<period, _CharT>(_Out(__s));
      __os << std::move(__s).str();
      return __os;
    }


namespace __detail
{

  template<typename _Duration>
    struct __local_time_fmt
    {
      local_time<_Duration> _M_time;
      const string* _M_abbrev;
      const seconds* _M_offset_sec;
    };

  struct __local_fmt_t;
}
# 180 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/chrono_io.h" 3
  template<typename _Duration>
    inline __detail::__local_time_fmt<_Duration>
    local_time_format(local_time<_Duration> __time,
        const string* __abbrev = nullptr,
        const seconds* __offset_sec = nullptr)
    { return {__time, __abbrev, __offset_sec}; }


}


namespace __format
{
  [[noreturn,__gnu__::__always_inline__]]
  inline void
  __no_timezone_available()
  { __throw_format_error("format error: no timezone available for %Z or %z"); }

  [[noreturn,__gnu__::__always_inline__]]
  inline void
  __not_valid_for_duration()
  { __throw_format_error("format error: chrono-format-spec not valid for "
    "chrono::duration"); }

  [[noreturn,__gnu__::__always_inline__]]
  inline void
  __invalid_chrono_spec()
  { __throw_format_error("format error: chrono-format-spec not valid for "
    "argument type"); }

  template<typename _CharT>
    struct _ChronoSpec : _Spec<_CharT>
    {
      basic_string_view<_CharT> _M_chrono_specs;
    };




  enum _ChronoParts {
    _Year = 1, _Month = 2, _Day = 4, _Weekday = 8, _TimeOfDay = 16,
    _TimeZone = 32,
    _Date = _Year | _Month | _Day | _Weekday,
    _DateTime = _Date | _TimeOfDay,
    _ZonedDateTime = _DateTime | _TimeZone,
    _Duration = 128
  };

  constexpr _ChronoParts
  operator|(_ChronoParts __x, _ChronoParts __y) noexcept
  { return static_cast<_ChronoParts>((int)__x | (int)__y); }

  constexpr _ChronoParts&
  operator|=(_ChronoParts& __x, _ChronoParts __y) noexcept
  { return __x = __x | __y; }


  template<typename _CharT>
    struct __formatter_chrono
    {
      using __string_view = basic_string_view<_CharT>;
      using __string = basic_string<_CharT>;

      template<typename _ParseContext>
 constexpr typename _ParseContext::iterator
 _M_parse(_ParseContext& __pc, _ChronoParts __parts)
 {
   auto __first = __pc.begin();
   auto __last = __pc.end();

   _ChronoSpec<_CharT> __spec{};

   auto __finalize = [this, &__spec] {
     _M_spec = __spec;
   };

   auto __finished = [&] {
     if (__first == __last || *__first == '}')
       {
  __finalize();
  return true;
       }
     return false;
   };

   if (__finished())
     return __first;

   __first = __spec._M_parse_fill_and_align(__first, __last);
   if (__finished())
     return __first;

   __first = __spec._M_parse_width(__first, __last, __pc);
   if (__finished())
     return __first;

   if (__parts & _ChronoParts::_Duration)
     {
       __first = __spec._M_parse_precision(__first, __last, __pc);
       if (__finished())
  return __first;
     }

   __first = __spec._M_parse_locale(__first, __last);
   if (__finished())
     return __first;



   {
     __string_view __str(__first, __last - __first);
     auto __end = __str.find('}');
     if (__end != __str.npos)
       {
  __str.remove_suffix(__str.length() - __end);
  __last = __first + __end;
       }
     if (__str.find('{') != __str.npos)
       __throw_format_error("chrono format error: '{' in chrono-specs");
   }





   const auto __chrono_specs = __first++;
   if (*__chrono_specs != '%')
     __throw_format_error("chrono format error: no '%' at start of "
         "chrono-specs");

   _CharT __mod{};
   bool __conv = true;
   int __needed = 0;

   while (__first != __last)
     {
       enum _Mods { _Mod_none, _Mod_E, _Mod_O, _Mod_E_O };
       _Mods __allowed_mods = _Mod_none;

       _CharT __c = *__first++;
       switch (__c)
  {
  case 'a':
  case 'A':
    __needed = _Weekday;
    break;
  case 'b':
  case 'h':
  case 'B':
    __needed = _Month;
    break;
  case 'c':
    __needed = _DateTime;
    __allowed_mods = _Mod_E;
    break;
  case 'C':
    __needed = _Year;
    __allowed_mods = _Mod_E;
    break;
  case 'd':
  case 'e':
    __needed = _Day;
    __allowed_mods = _Mod_O;
    break;
  case 'D':
  case 'F':
    __needed = _Date;
    break;
  case 'g':
  case 'G':
    __needed = _Date;
    break;
  case 'H':
  case 'I':
    __needed = _TimeOfDay;
    __allowed_mods = _Mod_O;
    break;
  case 'j':
    if (!(__parts & _Duration))
      __needed = _Date;
    break;
  case 'm':
    __needed = _Month;
    __allowed_mods = _Mod_O;
    break;
  case 'M':
    __needed = _TimeOfDay;
    __allowed_mods = _Mod_O;
    break;
  case 'p':
  case 'r':
  case 'R':
  case 'T':
    __needed = _TimeOfDay;
    break;
  case 'q':
  case 'Q':
    __needed = _Duration;
    break;
  case 'S':
    __needed = _TimeOfDay;
    __allowed_mods = _Mod_O;
    break;
  case 'u':
  case 'w':
    __needed = _Weekday;
    __allowed_mods = _Mod_O;
    break;
  case 'U':
  case 'V':
  case 'W':
    __needed = _Date;
    __allowed_mods = _Mod_O;
    break;
  case 'x':
    __needed = _Date;
    __allowed_mods = _Mod_E;
    break;
  case 'X':
    __needed = _TimeOfDay;
    __allowed_mods = _Mod_E;
    break;
  case 'y':
    __needed = _Year;
    __allowed_mods = _Mod_E_O;
    break;
  case 'Y':
    __needed = _Year;
    __allowed_mods = _Mod_E;
    break;
  case 'z':
    __needed = _TimeZone;
    __allowed_mods = _Mod_E_O;
    break;
  case 'Z':
    __needed = _TimeZone;
    break;
  case 'n':
  case 't':
  case '%':
    break;
  case 'O':
  case 'E':
    if (__mod) [[unlikely]]
      {
        __allowed_mods = _Mod_none;
        break;
      }
    __mod = __c;
    continue;
  default:
    __throw_format_error("chrono format error: invalid "
           " specifier in chrono-specs");
  }

       if ((__mod == 'E' && !(__allowed_mods & _Mod_E))
      || (__mod == 'O' && !(__allowed_mods & _Mod_O)))
  __throw_format_error("chrono format error: invalid "
         " modifier in chrono-specs");
       __mod = _CharT();

       if ((__parts & __needed) != __needed)
  __throw_format_error("chrono format error: format argument "
         "does not contain the information "
         "required by the chrono-specs");


       size_t __pos = __string_view(__first, __last - __first).find('%');
       if (__pos == 0)
  ++__first;
       else
  {
    if (__pos == __string_view::npos)
      {
        __first = __last;
        __conv = false;
      }
    else
      __first += __pos + 1;
  }
     }


   if (__conv || __mod != _CharT())
     __throw_format_error("chrono format error: unescaped '%' in "
     "chrono-specs");

   _M_spec = __spec;
   _M_spec._M_chrono_specs
   = __string_view(__chrono_specs, __first - __chrono_specs);

   return __first;
 }






      template<typename _Tp, typename _FormatContext>
 typename _FormatContext::iterator
 _M_format(const _Tp& __t, _FormatContext& __fc,
    bool __is_neg = false) const
 {
   auto __first = _M_spec._M_chrono_specs.begin();
   const auto __last = _M_spec._M_chrono_specs.end();
   if (__first == __last)
     return _M_format_to_ostream(__t, __fc, __is_neg);

   _Sink_iter<_CharT> __out;
   __format::_Str_sink<_CharT> __sink;
   bool __write_direct = false;
   if constexpr (is_same_v<typename _FormatContext::iterator,
      _Sink_iter<_CharT>>)
     {
       if (_M_spec._M_width_kind == __format::_WP_none)
  {
    __out = __fc.out();
    __write_direct = true;
  }
       else
  __out = __sink.out();
     }
   else
     __out = __sink.out();



   if constexpr (__is_specialization_of<_Tp, chrono::hh_mm_ss>)
     __is_neg = __t.is_negative();

   auto __print_sign = [&__is_neg, &__out] {
     if constexpr (chrono::__is_duration_v<_Tp>
       || __is_specialization_of<_Tp, chrono::hh_mm_ss>)
       if (__is_neg)
  {
    *__out++ = _S_plus_minus[1];
    __is_neg = false;
  }
     return std::move(__out);
   };


   constexpr const _CharT* __literals = ::std::chrono::__detail::_Widen<_CharT>("\n\t%", L"\n\t%");

   ++__first;

   _CharT __mod{};
   do
     {
       _CharT __c = *__first++;
       switch (__c)
  {
  case 'a':
  case 'A':
    __out = _M_a_A(__t, std::move(__out), __fc, __c == 'A');
    break;
  case 'b':
  case 'h':
  case 'B':
    __out = _M_b_B(__t, std::move(__out), __fc, __c == 'B');
    break;
  case 'c':
    __out = _M_c(__t, std::move(__out), __fc, __mod == 'E');
    break;
  case 'C':
  case 'y':
  case 'Y':
    __out = _M_C_y_Y(__t, std::move(__out), __fc, __c, __mod);
    break;
  case 'd':
  case 'e':
    __out = _M_d_e(__t, std::move(__out), __fc, __c, __mod == 'O');
    break;
  case 'D':
    __out = _M_D(__t, std::move(__out), __fc);
    break;
  case 'F':
    __out = _M_F(__t, std::move(__out), __fc);
    break;
  case 'g':
  case 'G':
    __out = _M_g_G(__t, std::move(__out), __fc, __c == 'G');
    break;
  case 'H':
  case 'I':
    __out = _M_H_I(__t, __print_sign(), __fc, __c, __mod == 'O');
    break;
  case 'j':
    __out = _M_j(__t, __print_sign(), __fc);
    break;
  case 'm':
    __out = _M_m(__t, std::move(__out), __fc, __mod == 'O');
    break;
  case 'M':
    __out = _M_M(__t, __print_sign(), __fc, __mod == 'O');
    break;
  case 'p':
    __out = _M_p(__t, std::move(__out), __fc);
    break;
  case 'q':
    __out = _M_q(__t, std::move(__out), __fc);
    break;
  case 'Q':

    if constexpr (chrono::__is_duration_v<_Tp>)
      __out = std::format_to(__print_sign(), _S_empty_spec,
        __t.count());
    else
      __throw_format_error("chrono format error: argument is "
      "not a duration");
    break;
  case 'r':
    __out = _M_r(__t, __print_sign(), __fc);
    break;
  case 'R':
  case 'T':
    __out = _M_R_T(__t, __print_sign(), __fc, __c == 'T');
    break;
  case 'S':
    __out = _M_S(__t, __print_sign(), __fc, __mod == 'O');
    break;
  case 'u':
  case 'w':
    __out = _M_u_w(__t, std::move(__out), __fc, __c, __mod == 'O');
    break;
  case 'U':
  case 'V':
  case 'W':
    __out = _M_U_V_W(__t, std::move(__out), __fc, __c,
       __mod == 'O');
    break;
  case 'x':
    __out = _M_x(__t, std::move(__out), __fc, __mod == 'E');
    break;
  case 'X':
    __out = _M_X(__t, __print_sign(), __fc, __mod == 'E');
    break;
  case 'z':
    __out = _M_z(__t, std::move(__out), __fc, (bool)__mod);
    break;
  case 'Z':
    __out = _M_Z(__t, std::move(__out), __fc);
    break;
  case 'n':
    *__out++ = __literals[0];
    break;
  case 't':
    *__out++ = __literals[1];
    break;
  case '%':
    *__out++ = __literals[2];
    break;
  case 'O':
  case 'E':
    __mod = __c;
    continue;
  case '}':
    __first = __last;
    break;
  }
       __mod = _CharT();

       __string_view __str(__first, __last - __first);
       size_t __pos = __str.find('%');
       if (__pos == 0)
  ++__first;
       else
  {
    if (__pos == __str.npos)
      __first = __last;
    else
      {
        __str.remove_suffix(__str.length() - __pos);
        __first += __pos + 1;
      }
    __out = __format::__write(std::move(__out), __str);
  }
     }
   while (__first != __last);

   if constexpr (is_same_v<typename _FormatContext::iterator,
      _Sink_iter<_CharT>>)
     if (__write_direct)
       return __out;

   auto __str = std::move(__sink).get();
   return __format::__write_padded_as_spec(__str, __str.size(),
        __fc, _M_spec);
 }

      _ChronoSpec<_CharT> _M_spec;

    private:

      template<typename _FormatContext>
 std::locale
 _M_locale(_FormatContext& __fc) const
 {
   if (!_M_spec._M_localized)
     return std::locale::classic();
   else
     return __fc.locale();
 }






      template<typename _Tp, typename _FormatContext>
 typename _FormatContext::iterator
 _M_format_to_ostream(const _Tp& __t, _FormatContext& __fc,
        bool __is_neg) const
 {
   using ::std::chrono::__detail::__utc_leap_second;
   using ::std::chrono::__detail::__local_time_fmt;

   if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
     return _M_format_to_ostream(__t._M_time, __fc, false);
   else
     {
       basic_ostringstream<_CharT> __os;
       __os.imbue(_M_locale(__fc));

       if constexpr (__is_specialization_of<_Tp, __utc_leap_second>)
  __os << __t._M_date << ' ' << __t._M_time;
       else if constexpr (chrono::__is_time_point_v<_Tp>)
  {





    if constexpr (is_convertible_v<_Tp, chrono::sys_days>)
      __os << _S_date(__t);
    else
      {
        auto __days = chrono::floor<chrono::days>(__t);
        __os << chrono::year_month_day(__days) << ' '
    << chrono::hh_mm_ss(__t - __days);
      }
  }
       else
  {
    if constexpr (chrono::__is_duration_v<_Tp>)
      if (__is_neg) [[unlikely]]
        __os << _S_plus_minus[1];
    __os << __t;
  }

       auto __str = std::move(__os).str();
       return __format::__write_padded_as_spec(__str, __str.size(),
            __fc, _M_spec);
     }
 }

      static constexpr const _CharT* _S_chars
 = ::std::chrono::__detail::_Widen<_CharT>("0123456789+-:/ {}", L"0123456789+-:/ {}");
      static constexpr const _CharT* _S_plus_minus = _S_chars + 10;
      static constexpr _CharT _S_colon = _S_chars[12];
      static constexpr _CharT _S_slash = _S_chars[13];
      static constexpr _CharT _S_space = _S_chars[14];
      static constexpr const _CharT* _S_empty_spec = _S_chars + 15;

      template<typename _Tp, typename _FormatContext>
 typename _FormatContext::iterator
 _M_a_A(const _Tp& __t, typename _FormatContext::iterator __out,
        _FormatContext& __ctx, bool __full) const
 {


   chrono::weekday __wd = _S_weekday(__t);
   if (!__wd.ok())
     __throw_format_error("format error: invalid weekday");

   locale __loc = _M_locale(__ctx);
   const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
   const _CharT* __days[7];
   if (__full)
     __tp._M_days(__days);
   else
     __tp._M_days_abbreviated(__days);
   __string_view __str(__days[__wd.c_encoding()]);
   return __format::__write(std::move(__out), __str);
 }

      template<typename _Tp, typename _FormatContext>
 typename _FormatContext::iterator
 _M_b_B(const _Tp& __t, typename _FormatContext::iterator __out,
        _FormatContext& __ctx, bool __full) const
 {


   chrono::month __m = _S_month(__t);
   if (!__m.ok())
     __throw_format_error("format error: invalid month");
   locale __loc = _M_locale(__ctx);
   const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
   const _CharT* __months[12];
   if (__full)
     __tp._M_months(__months);
   else
     __tp._M_months_abbreviated(__months);
   __string_view __str(__months[(unsigned)__m - 1]);
   return __format::__write(std::move(__out), __str);
 }

      template<typename _Tp, typename _FormatContext>
 typename _FormatContext::iterator
 _M_c(const _Tp& __tt, typename _FormatContext::iterator __out,
      _FormatContext& __ctx, bool __mod = false) const
 {



   auto __t = _S_floor_seconds(__tt);
   locale __loc = _M_locale(__ctx);
   const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
   const _CharT* __formats[2];
   __tp._M_date_time_formats(__formats);
   const _CharT* __rep = __formats[__mod];
   if (!*__rep)
     __rep = ::std::chrono::__detail::_Widen<_CharT>("%a %b %e %H:%M:%S %Y", L"%a %b %e %H:%M:%S %Y");
   basic_string<_CharT> __fmt(_S_empty_spec);
   __fmt.insert(1u, 1u, _S_colon);
   __fmt.insert(2u, __rep);
   return std::vformat_to(std::move(__out), __loc, __fmt,
     std::make_format_args<_FormatContext>(__t));
 }

      template<typename _Tp, typename _FormatContext>
 typename _FormatContext::iterator
 _M_C_y_Y(const _Tp& __t, typename _FormatContext::iterator __out,
        _FormatContext& __ctx, _CharT __conv, _CharT __mod = 0) const
 {
# 824 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/chrono_io.h" 3
   chrono::year __y = _S_year(__t);

   if (__mod) [[unlikely]]
     {
       struct tm __tm{};
       __tm.tm_year = (int)__y - 1900;
       return _M_locale_fmt(std::move(__out), _M_locale(__ctx), __tm,
       __conv, __mod);
     }

   basic_string<_CharT> __s;
   int __yi = (int)__y;
   const bool __is_neg = __yi < 0;
   __yi = __builtin_abs(__yi);

   if (__conv == 'Y' || __conv == 'C')
     {
       int __ci = __yi / 100;
       if (__is_neg) [[unlikely]]
  {
    __s.assign(1, _S_plus_minus[1]);

    if (__conv == 'C' && (__ci * 100) != __yi)
      ++__ci;
  }
       if (__ci >= 100) [[unlikely]]
  {
    __s += std::format(_S_empty_spec, __ci / 100);
    __ci %= 100;
  }
       __s += _S_two_digits(__ci);
     }

   if (__conv == 'Y' || __conv == 'y')
     __s += _S_two_digits(__yi % 100);

   return __format::__write(std::move(__out), __string_view(__s));
 }

      template<typename _Tp, typename _FormatContext>
 typename _FormatContext::iterator
 _M_D(const _Tp& __t, typename _FormatContext::iterator __out,
      _FormatContext&) const
 {
   auto __ymd = _S_date(__t);
   basic_string<_CharT> __s;



   __s = _S_two_digits((unsigned)__ymd.month());
   __s += _S_slash;
   __s += _S_two_digits((unsigned)__ymd.day());
   __s += _S_slash;
   __s += _S_two_digits(__builtin_abs((int)__ymd.year()) % 100);
   return __format::__write(std::move(__out), __string_view(__s));
 }

      template<typename _Tp, typename _FormatContext>
 typename _FormatContext::iterator
 _M_d_e(const _Tp& __t, typename _FormatContext::iterator __out,
        _FormatContext& __ctx, _CharT __conv, bool __mod = false) const
 {





   chrono::day __d = _S_day(__t);
   unsigned __i = (unsigned)__d;

   if (__mod) [[unlikely]]
     {
       struct tm __tm{};
       __tm.tm_mday = __i;
       return _M_locale_fmt(std::move(__out), _M_locale(__ctx), __tm,
       (char)__conv, 'O');
     }

   auto __sv = _S_two_digits(__i);
   _CharT __buf[2];
   if (__conv == _CharT('e') && __i < 10)
     {
       __buf[0] = _S_space;
       __buf[1] = __sv[1];
       __sv = {__buf, 2};
     }
   return __format::__write(std::move(__out), __sv);
 }

      template<typename _Tp, typename _FormatContext>
 typename _FormatContext::iterator
 _M_F(const _Tp& __t, typename _FormatContext::iterator __out,
      _FormatContext&) const
 {
   auto __ymd = _S_date(__t);
   auto __s = std::format(::std::chrono::__detail::_Widen<_CharT>("{:04d}-  -  ", L"{:04d}-  -  "),
     (int)__ymd.year());
   auto __sv = _S_two_digits((unsigned)__ymd.month());
   __s[__s.size() - 5] = __sv[0];
   __s[__s.size() - 4] = __sv[1];
   __sv = _S_two_digits((unsigned)__ymd.day());
   __s[__s.size() - 2] = __sv[0];
   __s[__s.size() - 1] = __sv[1];
   __sv = __s;
   return __format::__write(std::move(__out), __sv);
 }

      template<typename _Tp, typename _FormatContext>
 typename _FormatContext::iterator
 _M_g_G(const _Tp& __t, typename _FormatContext::iterator __out,
      _FormatContext& __ctx, bool __full) const
 {


   using namespace chrono;
   auto __d = _S_days(__t);

   __d -= (weekday(__d) - Monday) - days(3);

   year __y = year_month_day(__d).year();
   return _M_C_y_Y(__y, std::move(__out), __ctx, "yY"[__full]);
 }

      template<typename _Tp, typename _FormatContext>
 typename _FormatContext::iterator
 _M_H_I(const _Tp& __t, typename _FormatContext::iterator __out,
        _FormatContext& __ctx, _CharT __conv, bool __mod = false) const
 {





   const auto __hms = _S_hms(__t);
   int __i = __hms.hours().count();

   if (__mod) [[unlikely]]
     {
       struct tm __tm{};
       __tm.tm_hour = __i;
       return _M_locale_fmt(std::move(__out), _M_locale(__ctx), __tm,
       (char)__conv, 'O');
     }

   if (__conv == _CharT('I'))
     {
       if (__i == 0)
  __i = 12;
       else if (__i > 12)
  __i -= 12;
     }
   return __format::__write(std::move(__out), _S_two_digits(__i));
 }

      template<typename _Tp, typename _FormatContext>
 typename _FormatContext::iterator
 _M_j(const _Tp& __t, typename _FormatContext::iterator __out,
      _FormatContext&) const
 {
   if constexpr (chrono::__is_duration_v<_Tp>)
     {

       unsigned __d = chrono::duration_cast<chrono::days>(__t).count();
       return std::format_to(std::move(__out), _S_empty_spec, __d);
     }
   else
     {

       using namespace chrono;
       auto __day = _S_days(__t);
       auto __ymd = _S_date(__t);
       days __d;


       if constexpr (is_same_v<typename decltype(__day)::clock, local_t>)
  __d = __day - local_days(__ymd.year()/January/0);
       else
  __d = __day - sys_days(__ymd.year()/January/0);
       return std::format_to(std::move(__out), ::std::chrono::__detail::_Widen<_CharT>("{:03d}", L"{:03d}"),
        __d.count());
     }
 }

      template<typename _Tp, typename _FormatContext>
 typename _FormatContext::iterator
 _M_m(const _Tp& __t, typename _FormatContext::iterator __out,
      _FormatContext& __ctx, bool __mod) const
 {



   auto __m = _S_month(__t);
   auto __i = (unsigned)__m;

   if (__mod) [[unlikely]]
     {
       struct tm __tm{};
       __tm.tm_mon = __i - 1;
       return _M_locale_fmt(std::move(__out), _M_locale(__ctx), __tm,
       'm', 'O');
     }

   return __format::__write(std::move(__out), _S_two_digits(__i));
 }

      template<typename _Tp, typename _FormatContext>
 typename _FormatContext::iterator
 _M_M(const _Tp& __t, typename _FormatContext::iterator __out,
      _FormatContext& __ctx, bool __mod) const
 {



   auto __m = _S_hms(__t).minutes();
   auto __i = __m.count();

   if (__mod) [[unlikely]]
     {
       struct tm __tm{};
       __tm.tm_min = __i;
       return _M_locale_fmt(std::move(__out), _M_locale(__ctx), __tm,
       'M', 'O');
     }

   return __format::__write(std::move(__out), _S_two_digits(__i));
 }

      template<typename _Tp, typename _FormatContext>
 typename _FormatContext::iterator
 _M_p(const _Tp& __t, typename _FormatContext::iterator __out,
      _FormatContext& __ctx) const
 {

   auto __hms = _S_hms(__t);
   locale __loc = _M_locale(__ctx);
   const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
   const _CharT* __ampm[2];
   __tp._M_am_pm(__ampm);
   return std::format_to(std::move(__out), _S_empty_spec,
    __ampm[__hms.hours().count() >= 12]);
 }

      template<typename _Tp, typename _FormatContext>
 typename _FormatContext::iterator
 _M_q(const _Tp&, typename _FormatContext::iterator __out,
      _FormatContext&) const
 {

   if constexpr (!chrono::__is_duration_v<_Tp>)
     __throw_format_error("format error: argument is not a duration");
   else
     {
       namespace __d = chrono::__detail;
       using period = typename _Tp::period;
       return __d::__fmt_units_suffix<period, _CharT>(std::move(__out));
     }
 }



      template<typename _Tp, typename _FormatContext>
 typename _FormatContext::iterator
 _M_r(const _Tp& __tt, typename _FormatContext::iterator __out,
      _FormatContext& __ctx) const
 {

   auto __t = _S_floor_seconds(__tt);
   locale __loc = _M_locale(__ctx);
   const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
   const _CharT* __ampm_fmt;
   __tp._M_am_pm_format(&__ampm_fmt);
   basic_string<_CharT> __fmt(_S_empty_spec);
   __fmt.insert(1u, 1u, _S_colon);
   __fmt.insert(2u, __ampm_fmt);
   return std::vformat_to(std::move(__out), __fmt,
     std::make_format_args<_FormatContext>(__t));
 }

      template<typename _Tp, typename _FormatContext>
 typename _FormatContext::iterator
 _M_R_T(const _Tp& __t, typename _FormatContext::iterator __out,
        _FormatContext& __ctx, bool __secs) const
 {


   auto __hms = _S_hms(__t);

   auto __s = std::format(::std::chrono::__detail::_Widen<_CharT>("{:02d}:00", L"{:02d}:00"),
     __hms.hours().count());
   auto __sv = _S_two_digits(__hms.minutes().count());
   __s[__s.size() - 2] = __sv[0];
   __s[__s.size() - 1] = __sv[1];
   __sv = __s;
   __out = __format::__write(std::move(__out), __sv);
   if (__secs)
     {
       *__out++ = _S_colon;
       __out = _M_S(__hms, std::move(__out), __ctx);
     }
   return __out;
 }

      template<typename _Tp, typename _FormatContext>
 typename _FormatContext::iterator
 _M_S(const _Tp& __t, typename _FormatContext::iterator __out,
      _FormatContext& __ctx, bool __mod = false) const
 {


   auto __hms = _S_hms(__t);

   if (__mod) [[unlikely]]
     {
       struct tm __tm{};
       __tm.tm_sec = (int)__hms.seconds().count();
       return _M_locale_fmt(std::move(__out), _M_locale(__ctx), __tm,
       'S', 'O');
     }

   if constexpr (__hms.fractional_width == 0)
     __out = __format::__write(std::move(__out),
          _S_two_digits(__hms.seconds().count()));
   else
     {
       locale __loc = _M_locale(__ctx);
       auto __s = __hms.seconds();
       auto __ss = __hms.subseconds();
       using rep = typename decltype(__ss)::rep;
       if constexpr (is_floating_point_v<rep>)
  {
    chrono::duration<rep> __fs = __s + __ss;
    __out = std::format_to(std::move(__out), __loc,
      ::std::chrono::__detail::_Widen<_CharT>("{:#0{}.{}Lf}", L"{:#0{}.{}Lf}"),
      __fs.count(),
      3 + __hms.fractional_width,
      __hms.fractional_width);
  }
       else
  {
    const auto& __np
      = use_facet<numpunct<_CharT>>(__loc);
    __out = __format::__write(std::move(__out),
         _S_two_digits(__s.count()));
    *__out++ = __np.decimal_point();
    if constexpr (is_integral_v<rep>)
      __out = std::format_to(std::move(__out),
        ::std::chrono::__detail::_Widen<_CharT>("{:0{}}", L"{:0{}}"),
        __ss.count(),
        __hms.fractional_width);
    else
      {
        auto __str = std::format(_S_empty_spec, __ss.count());
        __out = std::format_to(::std::chrono::__detail::_Widen<_CharT>("{:0>{}s}", L"{:0>{}s}"),
          __str,
          __hms.fractional_width);
      }
  }
     }
   return __out;
 }



      template<typename _Tp, typename _FormatContext>
 typename _FormatContext::iterator
 _M_u_w(const _Tp& __t, typename _FormatContext::iterator __out,
        _FormatContext& __ctx, _CharT __conv, bool __mod = false) const
 {





   chrono::weekday __wd = _S_weekday(__t);

   if (__mod) [[unlikely]]
     {
       struct tm __tm{};
       __tm.tm_wday = __wd.c_encoding();
       return _M_locale_fmt(std::move(__out), _M_locale(__ctx), __tm,
       (char)__conv, 'O');
     }

   unsigned __wdi = __conv == 'u' ? __wd.iso_encoding()
      : __wd.c_encoding();
   const _CharT __d = _S_digit(__wdi);
   return __format::__write(std::move(__out), __string_view(&__d, 1));
 }

      template<typename _Tp, typename _FormatContext>
 typename _FormatContext::iterator
 _M_U_V_W(const _Tp& __t, typename _FormatContext::iterator __out,
   _FormatContext& __ctx, _CharT __conv, bool __mod = false) const
 {






   using namespace chrono;
   auto __d = _S_days(__t);
   using _TDays = decltype(__d);

   if (__mod) [[unlikely]]
     {
       const year_month_day __ymd(__d);
       const year __y = __ymd.year();
       struct tm __tm{};
       __tm.tm_year = (int)__y - 1900;
       __tm.tm_yday = (__d - _TDays(__y/January/1)).count();
       __tm.tm_wday = weekday(__d).c_encoding();
       return _M_locale_fmt(std::move(__out), _M_locale(__ctx), __tm,
       (char)__conv, 'O');
     }

   _TDays __first;
   if (__conv == 'V')
     {

       __d -= (weekday(__d) - Monday) - days(3);


       __first = _TDays(year_month_day(__d).year()/January/1);
     }
   else
     {
       year __y;
       if constexpr (requires { __t.year(); })
  __y = __t.year();
       else
  __y = year_month_day(__d).year();
       const weekday __weekstart = __conv == 'U' ? Sunday : Monday;
       __first = _TDays(__y/January/__weekstart[1]);
     }
   auto __weeks = chrono::floor<weeks>(__d - __first);
   __string_view __sv = _S_two_digits(__weeks.count() + 1);
   return __format::__write(std::move(__out), __sv);
 }

      template<typename _Tp, typename _FormatContext>
 typename _FormatContext::iterator
 _M_x(const _Tp& __t, typename _FormatContext::iterator __out,
      _FormatContext& __ctx, bool __mod = false) const
 {


   locale __loc = _M_locale(__ctx);
   const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
   const _CharT* __date_reps[2];
   __tp._M_date_formats(__date_reps);
   const _CharT* __rep = __date_reps[__mod];
   if (!*__rep)
     return _M_D(__t, std::move(__out), __ctx);

   basic_string<_CharT> __fmt(_S_empty_spec);
   __fmt.insert(1u, 1u, _S_colon);
   __fmt.insert(2u, __rep);
   return std::vformat_to(std::move(__out), __fmt,
     std::make_format_args<_FormatContext>(__t));
 }

      template<typename _Tp, typename _FormatContext>
 typename _FormatContext::iterator
 _M_X(const _Tp& __tt, typename _FormatContext::iterator __out,
      _FormatContext& __ctx, bool __mod = false) const
 {


   auto __t = _S_floor_seconds(__tt);
   locale __loc = _M_locale(__ctx);
   const auto& __tp = use_facet<__timepunct<_CharT>>(__loc);
   const _CharT* __time_reps[2];
   __tp._M_time_formats(__time_reps);
   const _CharT* __rep = __time_reps[__mod];
   if (!*__rep)
     return _M_R_T(__t, std::move(__out), __ctx, true);

   basic_string<_CharT> __fmt(_S_empty_spec);
   __fmt.insert(1u, 1u, _S_colon);
   __fmt.insert(2u, __rep);
   return std::vformat_to(std::move(__out), __fmt,
     std::make_format_args<_FormatContext>(__t));
 }

      template<typename _Tp, typename _FormatContext>
 typename _FormatContext::iterator
 _M_z(const _Tp& __t, typename _FormatContext::iterator __out,
      _FormatContext&, bool __mod = false) const
 {
   using ::std::chrono::__detail::__utc_leap_second;
   using ::std::chrono::__detail::__local_time_fmt;

   auto __utc = __mod ? __string_view(::std::chrono::__detail::_Widen<_CharT>("+00:00", L"+00:00"), 6)
        : __string_view(::std::chrono::__detail::_Widen<_CharT>("+0000", L"+0000"), 5);

   if constexpr (chrono::__is_time_point_v<_Tp>)
     {
       if constexpr (is_same_v<typename _Tp::clock,
          chrono::system_clock>)
  return __format::__write(std::move(__out), __utc);
     }
   else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
     {
       if (__t._M_offset_sec)
  {
    auto __sv = __utc;
    basic_string<_CharT> __s;
    if (*__t._M_offset_sec != 0s)
      {
        chrono:: hh_mm_ss __hms(*__t._M_offset_sec);
        __s = _S_plus_minus[__hms.is_negative()];
        __s += _S_two_digits(__hms.hours().count());
        if (__mod)
   __s += _S_colon;
        __s += _S_two_digits(__hms.minutes().count());
        __sv = __s;
      }
    return __format::__write(std::move(__out), __sv);
  }
     }
   else if constexpr (__is_specialization_of<_Tp, __utc_leap_second>)
     return __format::__write(std::move(__out), __utc);

   __no_timezone_available();
 }

      template<typename _Tp, typename _FormatContext>
 typename _FormatContext::iterator
 _M_Z(const _Tp& __t, typename _FormatContext::iterator __out,
      _FormatContext& __ctx) const
 {
   using ::std::chrono::__detail::__utc_leap_second;
   using ::std::chrono::__detail::__local_time_fmt;

   __string_view __utc(::std::chrono::__detail::_Widen<_CharT>("UTC", L"UTC"), 3);
   if constexpr (chrono::__is_time_point_v<_Tp>)
     {
       if constexpr (is_same_v<typename _Tp::clock,
          chrono::system_clock>)
  return __format::__write(std::move(__out), __utc);
     }
   else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
     {
       if (__t._M_abbrev)
  {
    string_view __sv = *__t._M_abbrev;
    if constexpr (is_same_v<_CharT, char>)
      return __format::__write(std::move(__out), __sv);
    else
      {

        basic_string<_CharT> __ws(__sv.size(), _CharT());
        auto& __ct = use_facet<ctype<_CharT>>(_M_locale(__ctx));
        __ct.widen(__sv.begin(), __sv.end(), __ws.data());
        __string_view __wsv = __ws;
        return __format::__write(std::move(__out), __wsv);
      }
  }
     }
   else if constexpr (__is_specialization_of<_Tp, __utc_leap_second>)
     return __format::__write(std::move(__out), __utc);

   __no_timezone_available();
 }




      static _CharT
      _S_digit(int __n) noexcept
      {

 return ::std::chrono::__detail::_Widen<_CharT>("0123456789999999", L"0123456789999999")[__n & 0xf];
      }


      static basic_string_view<_CharT>
      _S_two_digits(int __n) noexcept
      {
 return {
   ::std::chrono::__detail::_Widen<_CharT>("0001020304050607080910111213141516171819" "2021222324252627282930313233343536373839" "4041424344454647484950515253545556575859" "6061626364656667686970717273747576777879" "8081828384858687888990919293949596979899" "9999999999999999999999999999999999999999" "9999999999999999", L"0001020304050607080910111213141516171819" "2021222324252627282930313233343536373839" "4041424344454647484950515253545556575859" "6061626364656667686970717273747576777879" "8081828384858687888990919293949596979899" "9999999999999999999999999999999999999999" "9999999999999999") + 2 * (__n & 0x7f),






   2
 };
      }




      template<typename _Tp>
 static decltype(auto)
 _S_hms(const _Tp& __t)
 {
   using ::std::chrono::__detail::__utc_leap_second;
   using ::std::chrono::__detail::__local_time_fmt;

   if constexpr (__is_specialization_of<_Tp, chrono::hh_mm_ss>)
     return __t;
   else if constexpr (__is_specialization_of<_Tp, __utc_leap_second>)
     return __t._M_time;
   else if constexpr (chrono::__is_duration_v<_Tp>)
     return chrono::hh_mm_ss<_Tp>(__t);
   else if constexpr (chrono::__is_time_point_v<_Tp>)
     return chrono::hh_mm_ss(__t - chrono::floor<chrono::days>(__t));
   else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
     return _S_hms(__t._M_time);
   else
     {
       __invalid_chrono_spec();
       return chrono::hh_mm_ss<chrono::seconds>();
     }
 }


      template<typename _Tp>
 static auto
 _S_days(const _Tp& __t)
 {
   using namespace chrono;
   using ::std::chrono::__detail::__utc_leap_second;
   using ::std::chrono::__detail::__local_time_fmt;

   if constexpr (__is_time_point_v<_Tp>)
     return chrono::floor<days>(__t);
   else if constexpr (__is_specialization_of<_Tp, __utc_leap_second>)
     return __t._M_date;
   else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
     return chrono::floor<days>(__t._M_time);
   else if constexpr (is_same_v<_Tp, year_month_day>
          || is_same_v<_Tp, year_month_day_last>
          || is_same_v<_Tp, year_month_weekday>
          || is_same_v<_Tp, year_month_weekday_last>)
     return sys_days(__t);
   else
     {
       if constexpr (__is_duration_v<_Tp>)
  __not_valid_for_duration();
       else
  __invalid_chrono_spec();
       return chrono::sys_days();
     }
 }


      template<typename _Tp>
 static chrono::year_month_day
 _S_date(const _Tp& __t)
 {
   if constexpr (is_same_v<_Tp, chrono::year_month_day>)
     return __t;
   else
     return chrono::year_month_day(_S_days(__t));
 }

      template<typename _Tp>
 static chrono::day
 _S_day(const _Tp& __t)
 {
   using namespace chrono;

   if constexpr (is_same_v<_Tp, day>)
     return __t;
   else if constexpr (requires { __t.day(); })
     return __t.day();
   else
     return _S_date(__t).day();
 }

      template<typename _Tp>
 static chrono::month
 _S_month(const _Tp& __t)
 {
   using namespace chrono;

   if constexpr (is_same_v<_Tp, month>)
     return __t;
   else if constexpr (requires { __t.month(); })
     return __t.month();
   else
     return _S_date(__t).month();
 }

      template<typename _Tp>
 static chrono::year
 _S_year(const _Tp& __t)
 {
   using namespace chrono;

   if constexpr (is_same_v<_Tp, year>)
     return __t;
   else if constexpr (requires { __t.year(); })
     return __t.year();
   else
     return _S_date(__t).year();
 }

      template<typename _Tp>
 static chrono::weekday
 _S_weekday(const _Tp& __t)
 {
   using namespace ::std::chrono;
   using ::std::chrono::__detail::__local_time_fmt;

   if constexpr (is_same_v<_Tp, weekday>)
     return __t;
   else if constexpr (requires { __t.weekday(); })
     return __t.weekday();
   else if constexpr (is_same_v<_Tp, month_weekday>)
     return __t.weekday_indexed().weekday();
   else if constexpr (is_same_v<_Tp, month_weekday_last>)
     return __t.weekday_last().weekday();
   else
     return weekday(_S_days(__t));
 }


      template<typename _Tp>
 static auto
 _S_floor_seconds(const _Tp& __t)
 {
   using chrono::__detail::__local_time_fmt;
   if constexpr (chrono::__is_time_point_v<_Tp>
     || chrono::__is_duration_v<_Tp>)
     {
       if constexpr (_Tp::period::den != 1)
  return chrono::floor<chrono::seconds>(__t);
       else
  return __t;
     }
   else if constexpr (__is_specialization_of<_Tp, chrono::hh_mm_ss>)
     {
       if constexpr (_Tp::fractional_width != 0)
  return chrono::floor<chrono::seconds>(__t.to_duration());
       else
  return __t;
     }
   else if constexpr (__is_specialization_of<_Tp, __local_time_fmt>)
     return _S_floor_seconds(__t._M_time);
   else
     return __t;
 }



      template<typename _Iter>
 _Iter
 _M_locale_fmt(_Iter __out, const locale& __loc, const struct tm& __tm,
        char __fmt, char __mod) const
 {
   basic_ostringstream<_CharT> __os;
   const auto& __tp = use_facet<time_put<_CharT>>(__loc);
   __tp.put(__os, __os, _S_space, &__tm, __fmt, __mod);
   if (__os)
     __out = __format::__write(std::move(__out), __os.view());
   return __out;
 }
    };

}


  template<typename _Rep, typename _Period, typename _CharT>
    struct formatter<chrono::duration<_Rep, _Period>, _CharT>
    {
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      {
 using namespace __format;
 auto __it = _M_f._M_parse(__pc, _Duration|_TimeOfDay);
 if constexpr (!is_floating_point_v<_Rep>)
   if (_M_f._M_spec._M_prec_kind != __format::_WP_none)
     __throw_format_error("format error: invalid precision for duration");
 return __it;
      }

      template<typename _Out>
 typename basic_format_context<_Out, _CharT>::iterator
 format(const chrono::duration<_Rep, _Period>& __d,
        basic_format_context<_Out, _CharT>& __fc) const
 {
   if constexpr (numeric_limits<_Rep>::is_signed)
     if (__d < __d.zero())
       return _M_f._M_format(-__d, __fc, true);
   return _M_f._M_format(__d, __fc, false);
 }

    private:
      __format::__formatter_chrono<_CharT> _M_f;
    };

  template<typename _CharT>
    struct formatter<chrono::day, _CharT>
    {
      template<typename _ParseContext>
 constexpr typename _ParseContext::iterator
 parse(_ParseContext& __pc)
 { return _M_f._M_parse(__pc, __format::_Day); }

      template<typename _FormatContext>
 typename _FormatContext::iterator
 format(const chrono::day& __t, _FormatContext& __fc) const
 { return _M_f._M_format(__t, __fc); }

    private:
      __format::__formatter_chrono<_CharT> _M_f;
    };

  template<typename _CharT>
    struct formatter<chrono::month, _CharT>
    {
      template<typename _ParseContext>
 constexpr typename _ParseContext::iterator
 parse(_ParseContext& __pc)
 { return _M_f._M_parse(__pc, __format::_Month); }

      template<typename _FormatContext>
 typename _FormatContext::iterator
 format(const chrono::month& __t, _FormatContext& __fc) const
 { return _M_f._M_format(__t, __fc); }

    private:
      __format::__formatter_chrono<_CharT> _M_f;
    };

  template<typename _CharT>
    struct formatter<chrono::year, _CharT>
    {
      template<typename _ParseContext>
 constexpr typename _ParseContext::iterator
 parse(_ParseContext& __pc)
 { return _M_f._M_parse(__pc, __format::_Year); }

      template<typename _FormatContext>
 typename _FormatContext::iterator
 format(const chrono::year& __t, _FormatContext& __fc) const
 { return _M_f._M_format(__t, __fc); }

    private:
      __format::__formatter_chrono<_CharT> _M_f;
    };

  template<typename _CharT>
    struct formatter<chrono::weekday, _CharT>
    {
      template<typename _ParseContext>
 constexpr typename _ParseContext::iterator
 parse(_ParseContext& __pc)
 { return _M_f._M_parse(__pc, __format::_Weekday); }

      template<typename _FormatContext>
 typename _FormatContext::iterator
 format(const chrono::weekday& __t, _FormatContext& __fc) const
 { return _M_f._M_format(__t, __fc); }

    private:
      __format::__formatter_chrono<_CharT> _M_f;
    };

  template<typename _CharT>
    struct formatter<chrono::weekday_indexed, _CharT>
    {
      template<typename _ParseContext>
 constexpr typename _ParseContext::iterator
 parse(_ParseContext& __pc)
 { return _M_f._M_parse(__pc, __format::_Weekday); }

      template<typename _FormatContext>
 typename _FormatContext::iterator
 format(const chrono::weekday_indexed& __t, _FormatContext& __fc) const
 { return _M_f._M_format(__t, __fc); }

    private:
      __format::__formatter_chrono<_CharT> _M_f;
    };

  template<typename _CharT>
    struct formatter<chrono::weekday_last, _CharT>
    {
      template<typename _ParseContext>
 constexpr typename _ParseContext::iterator
 parse(_ParseContext& __pc)
 { return _M_f._M_parse(__pc, __format::_Weekday); }

      template<typename _FormatContext>
 typename _FormatContext::iterator
 format(const chrono::weekday_last& __t, _FormatContext& __fc) const
 { return _M_f._M_format(__t, __fc); }

    private:
      __format::__formatter_chrono<_CharT> _M_f;
    };

  template<typename _CharT>
    struct formatter<chrono::month_day, _CharT>
    {
      template<typename _ParseContext>
 constexpr typename _ParseContext::iterator
 parse(_ParseContext& __pc)
 { return _M_f._M_parse(__pc, __format::_Month|__format::_Day); }

      template<typename _FormatContext>
 typename _FormatContext::iterator
 format(const chrono::month_day& __t, _FormatContext& __fc) const
 { return _M_f._M_format(__t, __fc); }

    private:
      __format::__formatter_chrono<_CharT> _M_f;
    };

  template<typename _CharT>
    struct formatter<chrono::month_day_last, _CharT>
    {
      template<typename _ParseContext>
 constexpr typename _ParseContext::iterator
 parse(_ParseContext& __pc)
 { return _M_f._M_parse(__pc, __format::_Month|__format::_Day); }

      template<typename _FormatContext>
 typename _FormatContext::iterator
 format(const chrono::month_day_last& __t, _FormatContext& __fc) const
 { return _M_f._M_format(__t, __fc); }

    private:
      __format::__formatter_chrono<_CharT> _M_f;
    };

  template<typename _CharT>
    struct formatter<chrono::month_weekday, _CharT>
    {
      template<typename _ParseContext>
 constexpr typename _ParseContext::iterator
 parse(_ParseContext& __pc)
 { return _M_f._M_parse(__pc, __format::_Month|__format::_Weekday); }

      template<typename _FormatContext>
 typename _FormatContext::iterator
 format(const chrono::month_weekday& __t, _FormatContext& __fc) const
 { return _M_f._M_format(__t, __fc); }

    private:
      __format::__formatter_chrono<_CharT> _M_f;
    };

  template<typename _CharT>
    struct formatter<chrono::month_weekday_last, _CharT>
    {
      template<typename _ParseContext>
 constexpr typename _ParseContext::iterator
 parse(_ParseContext& __pc)
 { return _M_f._M_parse(__pc, __format::_Month|__format::_Weekday); }

      template<typename _FormatContext>
 typename _FormatContext::iterator
 format(const chrono::month_weekday_last& __t,
        _FormatContext& __fc) const
 { return _M_f._M_format(__t, __fc); }

    private:
      __format::__formatter_chrono<_CharT> _M_f;
    };

  template<typename _CharT>
    struct formatter<chrono::year_month, _CharT>
    {
      template<typename _ParseContext>
 constexpr typename _ParseContext::iterator
 parse(_ParseContext& __pc)
 { return _M_f._M_parse(__pc, __format::_Year|__format::_Month); }

      template<typename _FormatContext>
 typename _FormatContext::iterator
 format(const chrono::year_month& __t, _FormatContext& __fc) const
 { return _M_f._M_format(__t, __fc); }

    private:
      __format::__formatter_chrono<_CharT> _M_f;
    };

  template<typename _CharT>
    struct formatter<chrono::year_month_day, _CharT>
    {
      template<typename _ParseContext>
 constexpr typename _ParseContext::iterator
 parse(_ParseContext& __pc)
 { return _M_f._M_parse(__pc, __format::_Date); }

      template<typename _FormatContext>
 typename _FormatContext::iterator
 format(const chrono::year_month_day& __t, _FormatContext& __fc) const
 { return _M_f._M_format(__t, __fc); }

    private:
      __format::__formatter_chrono<_CharT> _M_f;
    };

  template<typename _CharT>
    struct formatter<chrono::year_month_day_last, _CharT>
    {
      template<typename _ParseContext>
 constexpr typename _ParseContext::iterator
 parse(_ParseContext& __pc)
 { return _M_f._M_parse(__pc, __format::_Date); }

      template<typename _FormatContext>
 typename _FormatContext::iterator
 format(const chrono::year_month_day_last& __t,
        _FormatContext& __fc) const
 { return _M_f._M_format(__t, __fc); }

    private:
      __format::__formatter_chrono<_CharT> _M_f;
    };

  template<typename _CharT>
    struct formatter<chrono::year_month_weekday, _CharT>
    {
      template<typename _ParseContext>
 constexpr typename _ParseContext::iterator
 parse(_ParseContext& __pc)
 { return _M_f._M_parse(__pc, __format::_Date); }

      template<typename _FormatContext>
 typename _FormatContext::iterator
 format(const chrono::year_month_weekday& __t,
        _FormatContext& __fc) const
 { return _M_f._M_format(__t, __fc); }

    private:
      __format::__formatter_chrono<_CharT> _M_f;
    };

  template<typename _CharT>
    struct formatter<chrono::year_month_weekday_last, _CharT>
    {
      template<typename _ParseContext>
 constexpr typename _ParseContext::iterator
 parse(_ParseContext& __pc)
 { return _M_f._M_parse(__pc, __format::_Date); }

      template<typename _FormatContext>
 typename _FormatContext::iterator
 format(const chrono::year_month_weekday_last& __t,
        _FormatContext& __fc) const
 { return _M_f._M_format(__t, __fc); }

    private:
      __format::__formatter_chrono<_CharT> _M_f;
    };

  template<typename _Rep, typename _Period, typename _CharT>
    struct formatter<chrono::hh_mm_ss<chrono::duration<_Rep, _Period>>, _CharT>
    {
      template<typename _ParseContext>
 constexpr typename _ParseContext::iterator
 parse(_ParseContext& __pc)
 { return _M_f._M_parse(__pc, __format::_TimeOfDay); }

      template<typename _FormatContext>
 typename _FormatContext::iterator
 format(const chrono::hh_mm_ss<chrono::duration<_Rep, _Period>>& __t,
        _FormatContext& __fc) const
 { return _M_f._M_format(__t, __fc); }

    private:
      __format::__formatter_chrono<_CharT> _M_f;
    };


  template<typename _CharT>
    struct formatter<chrono::sys_info, _CharT>
    {
      template<typename _ParseContext>
 constexpr typename _ParseContext::iterator
 parse(_ParseContext& __pc)
 { return _M_f._M_parse(__pc, __format::_ChronoParts{}); }

      template<typename _FormatContext>
 typename _FormatContext::iterator
 format(const chrono::sys_info& __i, _FormatContext& __fc) const
 { return _M_f._M_format(__i, __fc); }

    private:
      __format::__formatter_chrono<_CharT> _M_f;
    };

  template<typename _CharT>
    struct formatter<chrono::local_info, _CharT>
    {
      template<typename _ParseContext>
 constexpr typename _ParseContext::iterator
 parse(_ParseContext& __pc)
 { return _M_f._M_parse(__pc, __format::_ChronoParts{}); }

      template<typename _FormatContext>
 typename _FormatContext::iterator
 format(const chrono::local_info& __i, _FormatContext& __fc) const
 { return _M_f._M_format(__i, __fc); }

    private:
      __format::__formatter_chrono<_CharT> _M_f;
    };


  template<typename _Duration, typename _CharT>
    struct formatter<chrono::sys_time<_Duration>, _CharT>
    {
      template<typename _ParseContext>
 constexpr typename _ParseContext::iterator
 parse(_ParseContext& __pc)
 {
   auto __next = _M_f._M_parse(__pc, __format::_ZonedDateTime);
   if constexpr (!__stream_insertable)
     if (_M_f._M_spec._M_chrono_specs.empty())
       __format::__invalid_chrono_spec();
   return __next;
 }

      template<typename _FormatContext>
 typename _FormatContext::iterator
 format(const chrono::sys_time<_Duration>& __t,
        _FormatContext& __fc) const
 { return _M_f._M_format(__t, __fc); }

    private:
      static constexpr bool __stream_insertable
 = requires (basic_ostream<_CharT>& __os,
      chrono::sys_time<_Duration> __t) { __os << __t; };

      __format::__formatter_chrono<_CharT> _M_f;
    };

  template<typename _Duration, typename _CharT>
    struct formatter<chrono::utc_time<_Duration>, _CharT>
    : __format::__formatter_chrono<_CharT>
    {
      template<typename _ParseContext>
 constexpr typename _ParseContext::iterator
 parse(_ParseContext& __pc)
 { return _M_f._M_parse(__pc, __format::_ZonedDateTime); }

      template<typename _FormatContext>
 typename _FormatContext::iterator
 format(const chrono::utc_time<_Duration>& __t,
        _FormatContext& __fc) const
 {



   using chrono::__detail::__utc_leap_second;
   using chrono::seconds;
   using chrono::sys_time;
   using _CDur = common_type_t<_Duration, seconds>;
   const auto __li = chrono::get_leap_second_info(__t);
   sys_time<_CDur> __s{__t.time_since_epoch() - __li.elapsed};
   if (!__li.is_leap_second) [[likely]]
     return _M_f._M_format(__s, __fc);
   else
     return _M_f._M_format(__utc_leap_second(__s), __fc);
 }

    private:
      friend formatter<chrono::__detail::__utc_leap_second<_Duration>, _CharT>;

      __format::__formatter_chrono<_CharT> _M_f;
    };

  template<typename _Duration, typename _CharT>
    struct formatter<chrono::tai_time<_Duration>, _CharT>
    : __format::__formatter_chrono<_CharT>
    {
      template<typename _ParseContext>
 constexpr typename _ParseContext::iterator
 parse(_ParseContext& __pc)
 { return _M_f._M_parse(__pc, __format::_ZonedDateTime); }

      template<typename _FormatContext>
 typename _FormatContext::iterator
 format(const chrono::tai_time<_Duration>& __t,
        _FormatContext& __fc) const
 {



   constexpr chrono::days __tai_offset = chrono::days(4383);
   using _CDur = common_type_t<_Duration, chrono::days>;
   chrono::local_time<_CDur> __lt(__t.time_since_epoch() - __tai_offset);
   const string __abbrev("TAI", 3);
   const chrono::seconds __off = 0s;
   const auto __lf = chrono::local_time_format(__lt, &__abbrev, &__off);
   return _M_f._M_format(__lf, __fc);
 }

    private:
      __format::__formatter_chrono<_CharT> _M_f;
    };

  template<typename _Duration, typename _CharT>
    struct formatter<chrono::gps_time<_Duration>, _CharT>
    : __format::__formatter_chrono<_CharT>
    {
      template<typename _ParseContext>
 constexpr typename _ParseContext::iterator
 parse(_ParseContext& __pc)
 { return _M_f._M_parse(__pc, __format::_ZonedDateTime); }

      template<typename _FormatContext>
 typename _FormatContext::iterator
 format(const chrono::gps_time<_Duration>& __t,
        _FormatContext& __fc) const
 {



   constexpr chrono::days __gps_offset = chrono::days(3657);
   using _CDur = common_type_t<_Duration, chrono::days>;
   chrono::local_time<_CDur> __lt(__t.time_since_epoch() + __gps_offset);
   const string __abbrev("GPS", 3);
   const chrono::seconds __off = 0s;
   const auto __lf = chrono::local_time_format(__lt, &__abbrev, &__off);
   return _M_f._M_format(__lf, __fc);
 }

    private:
      __format::__formatter_chrono<_CharT> _M_f;
    };

  template<typename _Duration, typename _CharT>
    struct formatter<chrono::file_time<_Duration>, _CharT>
    {
      template<typename _ParseContext>
 constexpr typename _ParseContext::iterator
 parse(_ParseContext& __pc)
 { return _M_f._M_parse(__pc, __format::_ZonedDateTime); }

      template<typename _FormatContext>
 typename _FormatContext::iterator
 format(const chrono::file_time<_Duration>& __t,
        _FormatContext& __ctx) const
 {
   using namespace chrono;
   return _M_f._M_format(chrono::clock_cast<system_clock>(__t), __ctx);
 }

    private:
      __format::__formatter_chrono<_CharT> _M_f;
    };

  template<typename _Duration, typename _CharT>
    struct formatter<chrono::local_time<_Duration>, _CharT>
    {
      template<typename _ParseContext>
 constexpr typename _ParseContext::iterator
 parse(_ParseContext& __pc)
 { return _M_f._M_parse(__pc, __format::_DateTime); }

      template<typename _FormatContext>
 typename _FormatContext::iterator
 format(const chrono::local_time<_Duration>& __t,
        _FormatContext& __ctx) const
 { return _M_f._M_format(__t, __ctx); }

    private:
      __format::__formatter_chrono<_CharT> _M_f;
    };

  template<typename _Duration, typename _CharT>
    struct formatter<chrono::__detail::__local_time_fmt<_Duration>, _CharT>
    {
      template<typename _ParseContext>
 constexpr typename _ParseContext::iterator
 parse(_ParseContext& __pc)
 { return _M_f._M_parse(__pc, __format::_ZonedDateTime); }

      template<typename _FormatContext>
 typename _FormatContext::iterator
 format(const chrono::__detail::__local_time_fmt<_Duration>& __t,
        _FormatContext& __ctx) const
 { return _M_f._M_format(__t, __ctx); }

    private:
      __format::__formatter_chrono<_CharT> _M_f;
    };


  template<typename _Duration, typename _TimeZonePtr, typename _CharT>
    struct formatter<chrono::zoned_time<_Duration, _TimeZonePtr>, _CharT>
    : formatter<chrono::__detail::__local_time_fmt<_Duration>, _CharT>
    {
      template<typename _FormatContext>
 typename _FormatContext::iterator
 format(const chrono::zoned_time<_Duration, _TimeZonePtr>& __tp,
        _FormatContext& __ctx) const
 {
   using chrono::__detail::__local_time_fmt;
   using _Base = formatter<__local_time_fmt<_Duration>, _CharT>;
   const chrono::sys_info __info = __tp.get_info();
   const auto __lf = chrono::local_time_format(__tp.get_local_time(),
            &__info.abbrev,
            &__info.offset);
   return _Base::format(__lf, __ctx);
 }
    };



  template<typename _Duration, typename _CharT>
    struct formatter<chrono::__detail::__utc_leap_second<_Duration>, _CharT>
    : formatter<chrono::utc_time<_Duration>, _CharT>
    {
      template<typename _FormatContext>
 typename _FormatContext::iterator
 format(const chrono::__detail::__utc_leap_second<_Duration>& __t,
        _FormatContext& __fc) const
 { return this->_M_f._M_format(__t, __fc); }
    };

namespace chrono
{




namespace __detail
{
  template<typename _Duration = seconds>
    struct _Parser
    {
      static_assert(is_same_v<common_type_t<_Duration, seconds>, _Duration>);

      explicit
      _Parser(__format::_ChronoParts __need) : _M_need(__need) { }

      _Parser(_Parser&&) = delete;
      void operator=(_Parser&&) = delete;

      _Duration _M_time{};
      sys_days _M_sys_days{};
      year_month_day _M_ymd{};
      weekday _M_wd{};
      __format::_ChronoParts _M_need;
      unsigned _M_is_leap_second : 1 {};
      unsigned _M_reserved : 15 {};

      template<typename _CharT, typename _Traits, typename _Alloc>
 basic_istream<_CharT, _Traits>&
 operator()(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
     basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
     minutes* __offset = nullptr);

    private:


      template<typename _CharT, typename _Traits>
 static int_least32_t
 _S_read_unsigned(basic_istream<_CharT, _Traits>& __is,
    ios_base::iostate& __err, int __n)
 {
   int_least32_t __val = _S_try_read_digit(__is, __err);
   if (__val == -1) [[unlikely]]
     __err |= ios_base::failbit;
   else
     {
       int __n1 = (std::min)(__n, 9);

       for (int __i = 1; __i < __n1; ++__i)
  if (auto __dig = _S_try_read_digit(__is, __err); __dig != -1)
    {
      __val *= 10;
      __val += __dig;
    }

       while (__n1++ < __n) [[unlikely]]
  if (auto __dig = _S_try_read_digit(__is, __err); __dig != -1)
    {
      if (__builtin_mul_overflow(__val, 10, &__val)
     || __builtin_add_overflow(__val, __dig, &__val))
        {
   __err |= ios_base::failbit;
   return -1;
        }
    }
     }
   return __val;
 }



      template<typename _CharT, typename _Traits>
 static int_least32_t
 _S_read_signed(basic_istream<_CharT, _Traits>& __is,
    ios_base::iostate& __err, int __n)
 {
   auto __sign = __is.peek();
   if (__sign == '-' || __sign == '+')
     (void) __is.get();
   int_least32_t __val = _S_read_unsigned(__is, __err, __n);
   if (__err & ios_base::failbit)
     {
       if (__sign == '-') [[unlikely]]
  __val *= -1;
     }
   return __val;
 }



      template<typename _CharT, typename _Traits>
 static int_least32_t
 _S_try_read_digit(basic_istream<_CharT, _Traits>& __is,
     ios_base::iostate& __err)
 {
   int_least32_t __val = -1;
   auto __i = __is.peek();
   if (!_Traits::eq_int_type(__i, _Traits::eof())) [[likely]]
     {
       _CharT __c = _Traits::to_char_type(__i);
       if (_CharT('0') <= __c && __c <= _CharT('9')) [[likely]]
  {
    (void) __is.get();
    __val = __c - _CharT('0');
  }
     }
   else
     __err |= ios_base::eofbit;
   return __val;
 }



      template<typename _CharT, typename _Traits>
 static bool
 _S_read_chr(basic_istream<_CharT, _Traits>& __is,
      ios_base::iostate& __err, _CharT __c)
 {
   auto __i = __is.peek();
   if (_Traits::eq_int_type(__i, _Traits::eof()))
     __err |= ios_base::eofbit;
   else if (_Traits::to_char_type(__i) == __c) [[likely]]
     {
       (void) __is.get();
       return true;
     }
   __err |= ios_base::failbit;
   return false;
 }
    };

  template<typename _Duration>
    using _Parser_t = _Parser<common_type_t<_Duration, seconds>>;

}


  template<typename _CharT, typename _Traits, typename _Rep, typename _Period,
    typename _Alloc = allocator<_CharT>>
    inline basic_istream<_CharT, _Traits>&
    from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
  duration<_Rep, _Period>& __d,
  basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
  minutes* __offset = nullptr)
    {
      auto __need = __format::_ChronoParts::_TimeOfDay;
      __detail::_Parser_t<duration<_Rep, _Period>> __p(__need);
      if (__p(__is, __fmt, __abbrev, __offset))
 __d = chrono::duration_cast<duration<_Rep, _Period>>(__p._M_time);
      return __is;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, const day& __d)
    {
      using _Ctx = __format::__format_context<_CharT>;
      using _Str = basic_string_view<_CharT>;
      _Str __s = ::std::chrono::__detail::_Widen<_CharT>("{:02d} is not a valid day", L"{:02d} is not a valid day");
      if (__d.ok())
 __s = __s.substr(0, 6);
      auto __u = (unsigned)__d;
      __os << std::vformat(__s, make_format_args<_Ctx>(__u));
      return __os;
    }

  template<typename _CharT, typename _Traits,
    typename _Alloc = allocator<_CharT>>
    inline basic_istream<_CharT, _Traits>&
    from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
  day& __d,
  basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
  minutes* __offset = nullptr)
    {
      __detail::_Parser<> __p(__format::_ChronoParts::_Day);
      if (__p(__is, __fmt, __abbrev, __offset))
 __d = __p._M_ymd.day();
      return __is;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, const month& __m)
    {
      using _Ctx = __format::__format_context<_CharT>;
      using _Str = basic_string_view<_CharT>;
      _Str __s = ::std::chrono::__detail::_Widen<_CharT>("{:L%b}{} is not a valid month", L"{:L%b}{} is not a valid month");
      if (__m.ok())
 __os << std::vformat(__os.getloc(), __s.substr(0, 6),
        make_format_args<_Ctx>(__m));
      else
 {
   auto __u = (unsigned)__m;
   __os << std::vformat(__s.substr(6), make_format_args<_Ctx>(__u));
 }
      return __os;
    }

  template<typename _CharT, typename _Traits,
    typename _Alloc = allocator<_CharT>>
    inline basic_istream<_CharT, _Traits>&
    from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
  month& __m,
  basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
  minutes* __offset = nullptr)
    {
      __detail::_Parser<> __p(__format::_ChronoParts::_Month);
      if (__p(__is, __fmt, __abbrev, __offset))
 __m = __p._M_ymd.month();
      return __is;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, const year& __y)
    {
      using _Ctx = __format::__format_context<_CharT>;
      using _Str = basic_string_view<_CharT>;
      _Str __s = ::std::chrono::__detail::_Widen<_CharT>("-{:04d} is not a valid year", L"-{:04d} is not a valid year");
      if (__y.ok())
 __s = __s.substr(0, 7);
      int __i = (int)__y;
      if (__i >= 0) [[likely]]
 __s.remove_prefix(1);
      else
 __i = -__i;
      __os << std::vformat(__s, make_format_args<_Ctx>(__i));
      return __os;
    }

  template<typename _CharT, typename _Traits,
    typename _Alloc = allocator<_CharT>>
    inline basic_istream<_CharT, _Traits>&
    from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
  year& __y,
  basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
  minutes* __offset = nullptr)
    {
      __detail::_Parser<> __p(__format::_ChronoParts::_Year);
      if (__p(__is, __fmt, __abbrev, __offset))
 __y = __p._M_ymd.year();
      return __is;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, const weekday& __wd)
    {
      using _Ctx = __format::__format_context<_CharT>;
      using _Str = basic_string_view<_CharT>;
      _Str __s = ::std::chrono::__detail::_Widen<_CharT>("{:L%a}{} is not a valid weekday", L"{:L%a}{} is not a valid weekday");
      if (__wd.ok())
 __os << std::vformat(__os.getloc(), __s.substr(0, 6),
        make_format_args<_Ctx>(__wd));
      else
 {
   auto __c = __wd.c_encoding();
   __os << std::vformat(__s.substr(6), make_format_args<_Ctx>(__c));
 }
      return __os;
    }

  template<typename _CharT, typename _Traits,
    typename _Alloc = allocator<_CharT>>
    inline basic_istream<_CharT, _Traits>&
    from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
  weekday& __wd,
  basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
  minutes* __offset = nullptr)
    {
      __detail::_Parser<> __p(__format::_ChronoParts::_Weekday);
      if (__p(__is, __fmt, __abbrev, __offset))
 __wd = __p._M_wd;
      return __is;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
        const weekday_indexed& __wdi)
    {



      basic_stringstream<_CharT> __os2;
      __os2.imbue(__os.getloc());
      __os2 << __wdi.weekday();
      const auto __i = __wdi.index();
      basic_string_view<_CharT> __s
 = ::std::chrono::__detail::_Widen<_CharT>("[ is not a valid index]", L"[ is not a valid index]");
      __os2 << __s[0];
      __os2 << std::format(::std::chrono::__detail::_Widen<_CharT>("{}", L"{}"), __i);
      if (__i >= 1 && __i <= 5)
 __os2 << __s.back();
      else
 __os2 << __s.substr(1);
      __os << __os2.view();
      return __os;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
        const weekday_last& __wdl)
    {

      basic_stringstream<_CharT> __os2;
      __os2.imbue(__os.getloc());
      __os2 << __wdl.weekday() << ::std::chrono::__detail::_Widen<_CharT>("[last]", L"[last]");
      __os << __os2.view();
      return __os;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, const month_day& __md)
    {

      basic_stringstream<_CharT> __os2;
      __os2.imbue(__os.getloc());
      __os2 << __md.month();
      if constexpr (is_same_v<_CharT, char>)
 __os2 << '/';
      else
 __os2 << L'/';
      __os2 << __md.day();
      __os << __os2.view();
      return __os;
    }

  template<typename _CharT, typename _Traits,
    typename _Alloc = allocator<_CharT>>
    inline basic_istream<_CharT, _Traits>&
    from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
  month_day& __md,
  basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
  minutes* __offset = nullptr)
    {
      using __format::_ChronoParts;
      auto __need = _ChronoParts::_Month | _ChronoParts::_Day;
      __detail::_Parser<> __p(__need);
      if (__p(__is, __fmt, __abbrev, __offset))
 __md = month_day(__p._M_ymd.month(), __p._M_ymd.day());
      return __is;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
        const month_day_last& __mdl)
    {

      basic_stringstream<_CharT> __os2;
      __os2.imbue(__os.getloc());
      __os2 << __mdl.month() << ::std::chrono::__detail::_Widen<_CharT>("/last", L"/last");
      __os << __os2.view();
      return __os;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
        const month_weekday& __mwd)
    {

      basic_stringstream<_CharT> __os2;
      __os2.imbue(__os.getloc());
      __os2 << __mwd.month();
      if constexpr (is_same_v<_CharT, char>)
 __os2 << '/';
      else
 __os2 << L'/';
      __os2 << __mwd.weekday_indexed();
      __os << __os2.view();
      return __os;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
        const month_weekday_last& __mwdl)
    {

      basic_stringstream<_CharT> __os2;
      __os2.imbue(__os.getloc());
      __os2 << __mwdl.month();
      if constexpr (is_same_v<_CharT, char>)
 __os2 << '/';
      else
 __os2 << L'/';
      __os2 << __mwdl.weekday_last();
      __os << __os2.view();
      return __os;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, const year_month& __ym)
    {

      basic_stringstream<_CharT> __os2;
      __os2.imbue(__os.getloc());
      __os2 << __ym.year();
      if constexpr (is_same_v<_CharT, char>)
 __os2 << '/';
      else
 __os2 << L'/';
      __os2 << __ym.month();
      __os << __os2.view();
      return __os;
    }

  template<typename _CharT, typename _Traits,
    typename _Alloc = allocator<_CharT>>
    inline basic_istream<_CharT, _Traits>&
    from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
  year_month& __ym,
  basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
  minutes* __offset = nullptr)
    {
      using __format::_ChronoParts;
      auto __need = _ChronoParts::_Year | _ChronoParts::_Month;
      __detail::_Parser<> __p(__need);
      if (__p(__is, __fmt, __abbrev, __offset))
 __ym = year_month(__p._M_ymd.year(), __p._M_ymd.month());
      return __is;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
        const year_month_day& __ymd)
    {
      using _Ctx = __format::__format_context<_CharT>;
      using _Str = basic_string_view<_CharT>;
      _Str __s = ::std::chrono::__detail::_Widen<_CharT>("{:%F} is not a valid date", L"{:%F} is not a valid date");
      __os << std::vformat(__ymd.ok() ? __s.substr(0, 5) : __s,
      make_format_args<_Ctx>(__ymd));
      return __os;
    }

  template<typename _CharT, typename _Traits,
    typename _Alloc = allocator<_CharT>>
    inline basic_istream<_CharT, _Traits>&
    from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
  year_month_day& __ymd,
  basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
  minutes* __offset = nullptr)
    {
      using __format::_ChronoParts;
      auto __need = _ChronoParts::_Year | _ChronoParts::_Month
      | _ChronoParts::_Day;
      __detail::_Parser<> __p(__need);
      if (__p(__is, __fmt, __abbrev, __offset))
 __ymd = __p._M_ymd;
      return __is;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
        const year_month_day_last& __ymdl)
    {

      basic_stringstream<_CharT> __os2;
      __os2.imbue(__os.getloc());
      __os2 << __ymdl.year();
      if constexpr (is_same_v<_CharT, char>)
 __os2 << '/';
      else
 __os2 << L'/';
      __os2 << __ymdl.month_day_last();
      __os << __os2.view();
      return __os;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
        const year_month_weekday& __ymwd)
    {


      basic_stringstream<_CharT> __os2;
      __os2.imbue(__os.getloc());
      _CharT __slash;
      if constexpr (is_same_v<_CharT, char>)
 __slash = '/';
      else
 __slash = L'/';
      __os2 << __ymwd.year() << __slash << __ymwd.month() << __slash
     << __ymwd.weekday_indexed();
      __os << __os2.view();
      return __os;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
        const year_month_weekday_last& __ymwdl)
    {


      basic_stringstream<_CharT> __os2;
      __os2.imbue(__os.getloc());
      _CharT __slash;
      if constexpr (is_same_v<_CharT, char>)
 __slash = '/';
      else
 __slash = L'/';
      __os2 << __ymwdl.year() << __slash << __ymwdl.month() << __slash
     << __ymwdl.weekday_last();
      __os << __os2.view();
      return __os;
    }

  template<typename _CharT, typename _Traits, typename _Duration>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
        const hh_mm_ss<_Duration>& __hms)
    {
      return __os << format(__os.getloc(), ::std::chrono::__detail::_Widen<_CharT>("{:L%T}", L"{:L%T}"), __hms);
    }



  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, const sys_info& __i)
    {
      __os << '[' << __i.begin << ',' << __i.end
    << ',' << hh_mm_ss(__i.offset) << ',' << __i.save
    << ',' << __i.abbrev << ']';
      return __os;
    }


  template<typename _CharT, typename _Traits>
    basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, const local_info& __li)
    {
      __os << '[';
      if (__li.result == local_info::unique)
 __os << __li.first;
      else
 {
   if (__li.result == local_info::nonexistent)
     __os << "nonexistent";
   else
     __os << "ambiguous";
   __os << " local time between " << __li.first;
   __os << " and " << __li.second;
 }
      __os << ']';
      return __os;
    }

  template<typename _CharT, typename _Traits, typename _Duration,
    typename _TimeZonePtr>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
        const zoned_time<_Duration, _TimeZonePtr>& __t)
    {
      __os << format(__os.getloc(), ::std::chrono::__detail::_Widen<_CharT>("{:L%F %T %Z}", L"{:L%F %T %Z}"), __t);
      return __os;
    }


  template<typename _CharT, typename _Traits, typename _Duration>
    requires (!treat_as_floating_point_v<typename _Duration::rep>)
      && ratio_less_v<typename _Duration::period, days::period>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
        const sys_time<_Duration>& __tp)
    {
      __os << std::format(__os.getloc(), ::std::chrono::__detail::_Widen<_CharT>("{:L%F %T}", L"{:L%F %T}"), __tp);
      return __os;
    }

  template<typename _CharT, typename _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os, const sys_days& __dp)
    {
      __os << year_month_day{__dp};
      return __os;
    }

  template<typename _CharT, typename _Traits, typename _Duration,
    typename _Alloc = allocator<_CharT>>
    basic_istream<_CharT, _Traits>&
    from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
  sys_time<_Duration>& __tp,
  basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
  minutes* __offset = nullptr)
    {
      minutes __off{};
      if (!__offset)
 __offset = &__off;
      using __format::_ChronoParts;
      auto __need = _ChronoParts::_Year | _ChronoParts::_Month
      | _ChronoParts::_Day | _ChronoParts::_TimeOfDay;
      __detail::_Parser_t<_Duration> __p(__need);
      if (__p(__is, __fmt, __abbrev, __offset))
 {
   if (__p._M_is_leap_second)
     __is.setstate(ios_base::failbit);
   else
     {
       auto __st = __p._M_sys_days + __p._M_time - *__offset;
       __tp = chrono::time_point_cast<_Duration>(__st);
     }
 }
      return __is;
    }

  template<typename _CharT, typename _Traits, typename _Duration>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
        const utc_time<_Duration>& __t)
    {
      __os << std::format(__os.getloc(), ::std::chrono::__detail::_Widen<_CharT>("{:L%F %T}", L"{:L%F %T}"), __t);
      return __os;
    }

  template<typename _CharT, typename _Traits, typename _Duration,
    typename _Alloc = allocator<_CharT>>
    inline basic_istream<_CharT, _Traits>&
    from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
  utc_time<_Duration>& __tp,
  basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
  minutes* __offset = nullptr)
    {
      minutes __off{};
      if (!__offset)
 __offset = &__off;
      using __format::_ChronoParts;
      auto __need = _ChronoParts::_Year | _ChronoParts::_Month
      | _ChronoParts::_Day | _ChronoParts::_TimeOfDay;
      __detail::_Parser_t<_Duration> __p(__need);
      if (__p(__is, __fmt, __abbrev, __offset))
 {


   auto __ut = utc_clock::from_sys(__p._M_sys_days) + __p._M_time
   - *__offset;
   __tp = chrono::time_point_cast<_Duration>(__ut);
 }
      return __is;
    }

  template<typename _CharT, typename _Traits, typename _Duration>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
        const tai_time<_Duration>& __t)
    {
      __os << std::format(__os.getloc(), ::std::chrono::__detail::_Widen<_CharT>("{:L%F %T}", L"{:L%F %T}"), __t);
      return __os;
    }

  template<typename _CharT, typename _Traits, typename _Duration,
    typename _Alloc = allocator<_CharT>>
    inline basic_istream<_CharT, _Traits>&
    from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
  tai_time<_Duration>& __tp,
  basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
  minutes* __offset = nullptr)
    {
      minutes __off{};
      if (!__offset)
 __offset = &__off;
      using __format::_ChronoParts;
      auto __need = _ChronoParts::_Year | _ChronoParts::_Month
      | _ChronoParts::_Day | _ChronoParts::_TimeOfDay;
      __detail::_Parser_t<_Duration> __p(__need);
      if (__p(__is, __fmt, __abbrev, __offset))
 {
   if (__p._M_is_leap_second)
     __is.setstate(ios_base::failbit);
   else
     {
       auto __st = __p._M_sys_days + __p._M_time - *__offset;
       auto __tt = tai_clock::from_utc(utc_clock::from_sys(__st));
       __tp = chrono::time_point_cast<_Duration>(__tt);
     }
 }
      return __is;
    }

  template<typename _CharT, typename _Traits, typename _Duration>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
        const gps_time<_Duration>& __t)
    {
      __os << std::format(__os.getloc(), ::std::chrono::__detail::_Widen<_CharT>("{:L%F %T}", L"{:L%F %T}"), __t);
      return __os;
    }

  template<typename _CharT, typename _Traits, typename _Duration,
    typename _Alloc = allocator<_CharT>>
    inline basic_istream<_CharT, _Traits>&
    from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
  gps_time<_Duration>& __tp,
  basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
  minutes* __offset = nullptr)
    {
      minutes __off{};
      if (!__offset)
 __offset = &__off;
      using __format::_ChronoParts;
      auto __need = _ChronoParts::_Year | _ChronoParts::_Month
      | _ChronoParts::_Day | _ChronoParts::_TimeOfDay;
      __detail::_Parser_t<_Duration> __p(__need);
      if (__p(__is, __fmt, __abbrev, __offset))
 {
   if (__p._M_is_leap_second)
     __is.setstate(ios_base::failbit);
   else
     {
       auto __st = __p._M_sys_days + __p._M_time - *__offset;
       auto __tt = gps_clock::from_utc(utc_clock::from_sys(__st));
       __tp = chrono::time_point_cast<_Duration>(__tt);
     }
 }
      return __is;
    }

  template<typename _CharT, typename _Traits, typename _Duration>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
        const file_time<_Duration>& __t)
    {
      __os << std::format(__os.getloc(), ::std::chrono::__detail::_Widen<_CharT>("{:L%F %T}", L"{:L%F %T}"), __t);
      return __os;
    }

  template<typename _CharT, typename _Traits, typename _Duration,
    typename _Alloc = allocator<_CharT>>
    inline basic_istream<_CharT, _Traits>&
    from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
  file_time<_Duration>& __tp,
  basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
  minutes* __offset = nullptr)
    {
      sys_time<_Duration> __st;
      if (chrono::from_stream(__is, __fmt, __st, __abbrev, __offset))
 __tp = chrono::time_point_cast<_Duration>(file_clock::from_sys(__st));
      return __is;
    }

  template<typename _CharT, typename _Traits, typename _Duration>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __os,
        const local_time<_Duration>& __lt)
    {
      __os << sys_time<_Duration>{__lt.time_since_epoch()};
      return __os;
    }

  template<typename _CharT, typename _Traits, typename _Duration,
    typename _Alloc = allocator<_CharT>>
    basic_istream<_CharT, _Traits>&
    from_stream(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
  local_time<_Duration>& __tp,
  basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
  minutes* __offset = nullptr)
    {
      using __format::_ChronoParts;
      auto __need = _ChronoParts::_Year | _ChronoParts::_Month
      | _ChronoParts::_Day | _ChronoParts::_TimeOfDay;
      __detail::_Parser_t<_Duration> __p(__need);
      if (__p(__is, __fmt, __abbrev, __offset))
 {
   days __d = __p._M_sys_days.time_since_epoch();
   auto __t = local_days(__d) + __p._M_time;
   __tp = chrono::time_point_cast<_Duration>(__t);
 }
      return __is;
    }



namespace __detail
{
  template<typename _Parsable, typename _CharT,
    typename _Traits = std::char_traits<_CharT>,
    typename... _OptArgs>
    concept __parsable = requires (basic_istream<_CharT, _Traits>& __is,
       const _CharT* __fmt, _Parsable& __tp,
       _OptArgs*... __args)
    { from_stream(__is, __fmt, __tp, __args...); };

  template<typename _Parsable, typename _CharT,
    typename _Traits = char_traits<_CharT>,
    typename _Alloc = allocator<_CharT>>
    struct _Parse
    {
    private:
      using __string_type = basic_string<_CharT, _Traits, _Alloc>;

    public:
      _Parse(const _CharT* __fmt, _Parsable& __tp,
      basic_string<_CharT, _Traits, _Alloc>* __abbrev = nullptr,
      minutes* __offset = nullptr)
      : _M_fmt(__fmt), _M_tp(std::__addressof(__tp)),
 _M_abbrev(__abbrev), _M_offset(__offset)
      { }

      _Parse(_Parse&&) = delete;
      _Parse& operator=(_Parse&&) = delete;

    private:
      using __stream_type = basic_istream<_CharT, _Traits>;

      const _CharT* const _M_fmt;
      _Parsable* const _M_tp;
      __string_type* const _M_abbrev;
      minutes* const _M_offset;

      friend __stream_type&
      operator>>(__stream_type& __is, _Parse&& __p)
      {
 if (__p._M_offset)
   from_stream(__is, __p._M_fmt, *__p._M_tp, __p._M_abbrev,
        __p._M_offset);
 else if (__p._M_abbrev)
   from_stream(__is, __p._M_fmt, *__p._M_tp, __p._M_abbrev);
 else
   from_stream(__is, __p._M_fmt, *__p._M_tp);
 return __is;
      }

      friend void operator>>(__stream_type&, _Parse&) = delete;
      friend void operator>>(__stream_type&, const _Parse&) = delete;
    };
}

  template<typename _CharT, __detail::__parsable<_CharT> _Parsable>
    [[nodiscard, __gnu__::__access__(__read_only__, 1)]]
    inline auto
    parse(const _CharT* __fmt, _Parsable& __tp)
    { return __detail::_Parse<_Parsable, _CharT>(__fmt, __tp); }

  template<typename _CharT, typename _Traits, typename _Alloc,
    __detail::__parsable<_CharT, _Traits> _Parsable>
    [[nodiscard]]
    inline auto
    parse(const basic_string<_CharT, _Traits, _Alloc>& __fmt, _Parsable& __tp)
    {
      return __detail::_Parse<_Parsable, _CharT, _Traits>(__fmt.c_str(), __tp);
    }

  template<typename _CharT, typename _Traits, typename _Alloc,
    typename _StrT = basic_string<_CharT, _Traits, _Alloc>,
    __detail::__parsable<_CharT, _Traits, _StrT> _Parsable>
    [[nodiscard, __gnu__::__access__(__read_only__, 1)]]
    inline auto
    parse(const _CharT* __fmt, _Parsable& __tp,
   basic_string<_CharT, _Traits, _Alloc>& __abbrev)
    {
      auto __pa = std::__addressof(__abbrev);
      return __detail::_Parse<_Parsable, _CharT, _Traits, _Alloc>(__fmt, __tp,
          __pa);
    }

  template<typename _CharT, typename _Traits, typename _Alloc,
    typename _StrT = basic_string<_CharT, _Traits, _Alloc>,
    __detail::__parsable<_CharT, _Traits, _StrT> _Parsable>
    [[nodiscard]]
    inline auto
    parse(const basic_string<_CharT, _Traits, _Alloc>& __fmt, _Parsable& __tp,
   basic_string<_CharT, _Traits, _Alloc>& __abbrev)
    {
      auto __pa = std::__addressof(__abbrev);
      return __detail::_Parse<_Parsable, _CharT, _Traits, _Alloc>(__fmt.c_str(),
          __tp, __pa);
    }

  template<typename _CharT, typename _Traits = char_traits<_CharT>,
    typename _StrT = basic_string<_CharT, _Traits>,
    __detail::__parsable<_CharT, _Traits, _StrT, minutes> _Parsable>
    [[nodiscard, __gnu__::__access__(__read_only__, 1)]]
    inline auto
    parse(const _CharT* __fmt, _Parsable& __tp, minutes& __offset)
    {
      return __detail::_Parse<_Parsable, _CharT>(__fmt, __tp, nullptr,
       &__offset);
    }

  template<typename _CharT, typename _Traits, typename _Alloc,
    typename _StrT = basic_string<_CharT, _Traits>,
    __detail::__parsable<_CharT, _Traits, _StrT, minutes> _Parsable>
    [[nodiscard]]
    inline auto
    parse(const basic_string<_CharT, _Traits, _Alloc>& __fmt, _Parsable& __tp,
   minutes& __offset)
    {
      return __detail::_Parse<_Parsable, _CharT, _Traits, _Alloc>(__fmt.c_str(),
          __tp, nullptr,
          &__offset);
    }

  template<typename _CharT, typename _Traits, typename _Alloc,
    typename _StrT = basic_string<_CharT, _Traits, _Alloc>,
    __detail::__parsable<_CharT, _Traits, _StrT, minutes> _Parsable>
    [[nodiscard, __gnu__::__access__(__read_only__, 1)]]
    inline auto
    parse(const _CharT* __fmt, _Parsable& __tp,
   basic_string<_CharT, _Traits, _Alloc>& __abbrev, minutes& __offset)
    {
      auto __pa = std::__addressof(__abbrev);
      return __detail::_Parse<_Parsable, _CharT, _Traits, _Alloc>(__fmt, __tp,
          __pa,
          &__offset);
    }

  template<typename _CharT, typename _Traits, typename _Alloc,
    typename _StrT = basic_string<_CharT, _Traits, _Alloc>,
    __detail::__parsable<_CharT, _Traits, _StrT, minutes> _Parsable>
    [[nodiscard]]
    inline auto
    parse(const basic_string<_CharT, _Traits, _Alloc>& __fmt, _Parsable& __tp,
   basic_string<_CharT, _Traits, _Alloc>& __abbrev, minutes& __offset)
    {
      auto __pa = std::__addressof(__abbrev);
      return __detail::_Parse<_Parsable, _CharT, _Traits, _Alloc>(__fmt.c_str(),
          __tp, __pa,
          &__offset);
    }


  template<typename _Duration>
  template<typename _CharT, typename _Traits, typename _Alloc>
    basic_istream<_CharT, _Traits>&
    __detail::_Parser<_Duration>::
    operator()(basic_istream<_CharT, _Traits>& __is, const _CharT* __fmt,
        basic_string<_CharT, _Traits, _Alloc>* __abbrev,
        minutes* __offset)
    {
      using sentry = typename basic_istream<_CharT, _Traits>::sentry;
      ios_base::iostate __err = ios_base::goodbit;
      if (sentry __cerb(__is, true); __cerb)
 {
   locale __loc = __is.getloc();
   auto& __tmget = std::use_facet<std::time_get<_CharT>>(__loc);
   auto& __tmpunct = std::use_facet<std::__timepunct<_CharT>>(__loc);


   struct _Stream_state
   {
     explicit
     _Stream_state(basic_istream<_CharT, _Traits>& __i)
     : _M_is(__i),
       _M_flags(__i.flags(ios_base::skipws | ios_base::dec)),
       _M_w(__i.width(0))
     { }

     ~_Stream_state()
     {
       _M_is.flags(_M_flags);
       _M_is.width(_M_w);
     }

     _Stream_state(_Stream_state&&) = delete;

     basic_istream<_CharT, _Traits>& _M_is;
     ios_base::fmtflags _M_flags;
     streamsize _M_w;
   };

   auto __is_failed = [](ios_base::iostate __e) {
     return static_cast<bool>(__e & ios_base::failbit);
   };



   auto __read_unsigned = [&] (int __n) {
     return _S_read_unsigned(__is, __err, __n);
   };



   auto __read_signed = [&] (int __n) {
     return _S_read_signed(__is, __err, __n);
   };


   auto __read_chr = [&__is, &__err] (_CharT __c) {
     return _S_read_chr(__is, __err, __c);
   };

   using __format::_ChronoParts;
   _ChronoParts __parts{};

   const year __bad_y = --year::min();
   const month __bad_mon(255);
   const day __bad_day(255);
   const weekday __bad_wday(255);
   const hours __bad_h(-1);
   const minutes __bad_min(-9999);
   const seconds __bad_sec(-1);

   year __y = __bad_y, __yy = __bad_y;
   year __iso_y = __bad_y, __iso_yy = __bad_y;
   month __m = __bad_mon;
   day __d = __bad_day;
   weekday __wday = __bad_wday;
   hours __h = __bad_h, __h12 = __bad_h;
   minutes __min = __bad_min;
   _Duration __s = __bad_sec;
   int __ampm = 0;
   int __iso_wk = -1, __sunday_wk = -1, __monday_wk = -1;
   int __century = -1;
   int __dayofyear = -1;

   minutes __tz_offset = __bad_min;
   basic_string<_CharT, _Traits> __tz_abbr;

   if ((_M_need & _ChronoParts::_TimeOfDay)
  && (_M_need & _ChronoParts::_Year))
     {



       __h = hours(0);
       __parts = _ChronoParts::_TimeOfDay;
     }



   _CharT __mod{};
   unsigned __num = 0;
   bool __is_flag = false;

   constexpr bool __is_floating
     = treat_as_floating_point_v<typename _Duration::rep>;
# 3197 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/chrono_io.h" 3
   while (*__fmt)
     {
       _CharT __c = *__fmt++;
       if (!__is_flag)
  {
    if (__c == '%')
      __is_flag = true;
    else if (std::isspace(__c, __loc))
      std::ws(__is);
    else if (!__read_chr(__c)) [[unlikely]]
      break;

    continue;
  }


       switch (__c)
       {
  case 'a':
  case 'A':
    if (__mod || __num) [[unlikely]]
      __err = ios_base::failbit;
    else
      {
        struct tm __tm{};
        __tmget.get(__is, {}, __is, __err, &__tm,
      __fmt - 2, __fmt);
        if (!__is_failed(__err))
   __wday = weekday(__tm.tm_wday);
      }
    __parts |= _ChronoParts::_Weekday;
    break;

  case 'b':
  case 'h':
  case 'B':
    if (__mod || __num) [[unlikely]]
      __err = ios_base::failbit;
    else
      {



        struct tm __tm{};
        __tmget.get(__is, {}, __is, __err, &__tm,
      __fmt - 2, __fmt);
        if (!__is_failed(__err))
   __m = month(__tm.tm_mon + 1);
      }
    __parts |= _ChronoParts::_Month;
    break;

  case 'c':
    if (__mod == 'O' || __num) [[unlikely]]
      __err |= ios_base::failbit;
    else
      {
        struct tm __tm{};
        __tmget.get(__is, {}, __is, __err, &__tm,
      __fmt - 2 - (__mod == 'E'), __fmt);
        if (!__is_failed(__err))
   {
     __y = year(__tm.tm_year + 1900);
     __m = month(__tm.tm_mon + 1);
     __d = day(__tm.tm_mday);
     __h = hours(__tm.tm_hour);
     __min = minutes(__tm.tm_min);
     __s = seconds(__tm.tm_sec);
   }
      }
    __parts |= _ChronoParts::_DateTime;
    break;

  case 'C':
    if (!__mod) [[likely]]
      {
        auto __v = __read_signed(__num ? __num : 2);
        if (!__is_failed(__err))
   {
     int __cmin = (int)year::min() / 100;
     int __cmax = (int)year::max() / 100;
     if (__cmin <= __v && __v <= __cmax)
       __century = __v * 100;
     else
       __century = -2;
   }
      }
    else if (__mod == 'E')
      {
        struct tm __tm{};
        __tmget.get(__is, {}, __is, __err, &__tm,
      __fmt - 3, __fmt);
        if (!__is_failed(__err))
   __century = __tm.tm_year;
      }
    else [[unlikely]]
      __err |= ios_base::failbit;

    break;

  case 'd':
  case 'e':
    if (!__mod) [[likely]]
      {
        auto __v = __read_unsigned(__num ? __num : 2);
        if (!__is_failed(__err))
   __d = day(__v);
      }
    else if (__mod == 'O')
      {
        struct tm __tm{};
        __tmget.get(__is, {}, __is, __err, &__tm,
      __fmt - 3, __fmt);
        if (!__is_failed(__err))
   __d = day(__tm.tm_mday);
      }
    else [[unlikely]]
      __err |= ios_base::failbit;
    __parts |= _ChronoParts::_Day;
    break;

  case 'D':
    if (__mod || __num) [[unlikely]]
      __err |= ios_base::failbit;
    else
      {
        auto __month = __read_unsigned(2);
        __read_chr('/');
        auto __day = __read_unsigned(2);
        __read_chr('/');
        auto __year = __read_unsigned(2);
        if (__is_failed(__err))
   break;
        __y = year(__year + 1900 + 100 * int(__year < 69));
        __m = month(__month);
        __d = day(__day);
        if (!year_month_day(__y, __m, __d).ok())
   {
     __y = __yy = __iso_y = __iso_yy = __bad_y;
     __m = __bad_mon;
     __d = __bad_day;
     break;
   }
      }
    __parts |= _ChronoParts::_Date;
    break;

  case 'F':
    if (__mod) [[unlikely]]
      __err |= ios_base::failbit;
    else
      {
        auto __year = __read_signed(__num ? __num : 4);
        __read_chr('-');
        auto __month = __read_unsigned(2);
        __read_chr('-');
        auto __day = __read_unsigned(2);
        if (__is_failed(__err))
   break;
        __y = year(__year);
        __m = month(__month);
        __d = day(__day);
        if (!year_month_day(__y, __m, __d).ok())
   {
     __y = __yy = __iso_y = __iso_yy = __bad_y;
     __m = __bad_mon;
     __d = __bad_day;
     break;
   }
      }
    __parts |= _ChronoParts::_Date;
    break;

  case 'g':
    if (__mod) [[unlikely]]
      __err |= ios_base::failbit;
    else
      {
        auto __val = __read_unsigned(__num ? __num : 2);
        if (__val >= 0 && __val <= 99)
   {
     __iso_yy = year(__val);
     if (__century == -1)
       __century = 2000;
   }
        else
   __iso_yy = __iso_y = __y = __yy = __bad_y;
      }
    __parts |= _ChronoParts::_Year;
    break;

  case 'G':
    if (__mod) [[unlikely]]
      __err |= ios_base::failbit;
    else
      __iso_y = year(__read_unsigned(__num ? __num : 4));
    __parts |= _ChronoParts::_Year;
    break;

  case 'H':
  case 'I':
    if (__mod == 'E') [[unlikely]]
      __err |= ios_base::failbit;
    else if (__mod == 'O')
      {
# 3419 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/chrono_io.h" 3
        __err |= ios_base::failbit;

      }
    else
      {
        auto __val = __read_unsigned(__num ? __num : 2);
        if (__c == 'I' && __val >= 1 && __val <= 12)
   {
     __h12 = hours(__val);
     __h = __bad_h;
   }
        else if (__c == 'H' && __val >= 0 && __val <= 23)
   {
     __h = hours(__val);
     __h12 = __bad_h;
   }
        else
   {
     if (_M_need & _ChronoParts::_TimeOfDay)
       __err |= ios_base::failbit;
     break;
   }
      }
    __parts |= _ChronoParts::_TimeOfDay;
    break;

  case 'j':
    if (__mod) [[unlikely]]
      __err |= ios_base::failbit;
    else if (_M_need == _ChronoParts::_TimeOfDay)
      {
        auto __val = __read_signed(__num ? __num : 3);
        if (!__is_failed(__err))
   {
     __h = days(__val);
     __parts |= _ChronoParts::_TimeOfDay;
   }
      }
    else
      {
        __dayofyear = __read_unsigned(__num ? __num : 3);


      }
    break;

  case 'm':
    if (__mod == 'E') [[unlikely]]
      __err |= ios_base::failbit;
    else if (__mod == 'O')
      {
        struct tm __tm{};
        __tmget.get(__is, {}, __is, __err, &__tm,
      __fmt - 2, __fmt);
        if (!__is_failed(__err))
   __m = month(__tm.tm_mon + 1);
      }
    else
      {
        auto __val = __read_unsigned(__num ? __num : 2);
        if (__val >= 1 && __val <= 12)
   __m = month(__val);
        else
   __m = __bad_mon;
      }
    __parts |= _ChronoParts::_Month;
    break;

  case 'M':
    if (__mod == 'E') [[unlikely]]
      __err |= ios_base::failbit;
    else if (__mod == 'O')
      {
        struct tm __tm{};
        __tmget.get(__is, {}, __is, __err, &__tm,
      __fmt - 2, __fmt);
        if (!__is_failed(__err))
   __min = minutes(__tm.tm_min);
      }
    else
      {
        auto __val = __read_unsigned(__num ? __num : 2);
        if (0 <= __val && __val < 60)
   __min = minutes(__val);
        else
   {
     if (_M_need & _ChronoParts::_TimeOfDay)
       __err |= ios_base::failbit;
     break;
   }
      }
    __parts |= _ChronoParts::_TimeOfDay;
    break;

  case 'p':
    if (__mod || __num)
      __err |= ios_base::failbit;
    else
      {


        const _CharT* __ampms[2];
        __tmpunct._M_am_pm(__ampms);
        int __n = 0, __which = 3;
        while (__which != 0)
   {
     auto __i = __is.peek();
     if (_Traits::eq_int_type(__i, _Traits::eof()))
       {
         __err |= ios_base::eofbit | ios_base::failbit;
         break;
       }
     __i = std::toupper(_Traits::to_char_type(__i), __loc);
     if (__which & 1)
       {
         if (__i != std::toupper(__ampms[0][__n], __loc))
    __which ^= 1;
         else if (__ampms[0][__n + 1] == _CharT())
    {
      __which = 1;
      (void) __is.get();
      break;
    }
       }
     if (__which & 2)
       {
         if (__i != std::toupper(__ampms[1][__n], __loc))
    __which ^= 2;
         else if (__ampms[1][__n + 1] == _CharT())
    {
      __which = 2;
      (void) __is.get();
      break;
    }
       }
     if (__which)
       (void) __is.get();
     ++__n;
   }
        if (__which == 0 || __which == 3)
   __err |= ios_base::failbit;
        else
   __ampm = __which;
      }
    break;

  case 'r':
    if (__mod || __num)
      __err |= ios_base::failbit;
    else
      {
        struct tm __tm{};
        __tmget.get(__is, {}, __is, __err, &__tm,
      __fmt - 2, __fmt);
        if (!__is_failed(__err))
   {
     __h = hours(__tm.tm_hour);
     __min = minutes(__tm.tm_min);
     __s = seconds(__tm.tm_sec);
   }
      }
    __parts |= _ChronoParts::_TimeOfDay;
    break;

  case 'R':
  case 'T':
    if (__mod || __num) [[unlikely]]
      {
        __err |= ios_base::failbit;
        break;
      }
    else
      {
        auto __val = __read_unsigned(2);
        if (__val == -1 || __val > 23) [[unlikely]]
   {
     if (_M_need & _ChronoParts::_TimeOfDay)
       __err |= ios_base::failbit;
     break;
   }
        if (!__read_chr(':')) [[unlikely]]
   break;
        __h = hours(__val);

        __val = __read_unsigned(2);
        if (__val == -1 || __val > 60) [[unlikely]]
   {
     if (_M_need & _ChronoParts::_TimeOfDay)
       __err |= ios_base::failbit;
     break;
   }
        __min = minutes(__val);

        if (__c == 'R')
   {
     __parts |= _ChronoParts::_TimeOfDay;
     break;
   }
        else if (!__read_chr(':')) [[unlikely]]
   break;
      }
    [[fallthrough]];

  case 'S':
    if (__mod == 'E') [[unlikely]]
      __err |= ios_base::failbit;
    else if (__mod == 'O')
      {
        struct tm __tm{};
        __tmget.get(__is, {}, __is, __err, &__tm,
      __fmt - 3, __fmt);
        if (!__is_failed(__err))
   __s = seconds(__tm.tm_sec);
      }
    else if constexpr (_Duration::period::den == 1
           && !__is_floating)
      {
        auto __val = __read_unsigned(__num ? __num : 2);
        if (0 <= __val && __val <= 59) [[likely]]
   __s = seconds(__val);
        else
   {
     if (_M_need & _ChronoParts::_TimeOfDay)
       __err |= ios_base::failbit;
     break;
   }
      }
    else
      {
        basic_stringstream<_CharT> __buf;
        auto __digit = _S_try_read_digit(__is, __err);
        if (__digit != -1)
   {
     __buf.put(_CharT('0') + __digit);
     __digit = _S_try_read_digit(__is, __err);
     if (__digit != -1)
       __buf.put(_CharT('0') + __digit);
   }

        auto __i = __is.peek();
        if (_Traits::eq_int_type(__i, _Traits::eof()))
   __err |= ios_base::eofbit;
        else
   {
     _CharT __dp = '.';
     if (__loc != locale::classic())
       {
         auto& __np = use_facet<numpunct<_CharT>>(__loc);
         __dp = __np.decimal_point();
       }
     _CharT __c = _Traits::to_char_type(__i);
     if (__c == __dp)
       {
         (void) __is.get();
         __buf.put('.');
         int __prec
    = hh_mm_ss<_Duration>::fractional_width;
         do
    {
      __digit = _S_try_read_digit(__is, __err);
      if (__digit != -1)
        __buf.put(_CharT('0') + __digit);
      else
        break;
    }
         while (--__prec);
       }
   }

        if (!__is_failed(__err)) [[likely]]
   {
     long double __val{};

     string __str = std::move(__buf).str();
     auto __first = __str.data();
     auto __last = __first + __str.size();
     using enum chars_format;
     auto [ptr, ec] = std::from_chars(__first, __last,
          __val, fixed);
     if ((bool)ec || ptr != __last) [[unlikely]]
       __err |= ios_base::failbit;
     else



       {
         duration<long double> __fs(__val);
         if constexpr (__is_floating)
    __s = __fs;
         else
    __s = chrono::round<_Duration>(__fs);
       }
   }
      }
    __parts |= _ChronoParts::_TimeOfDay;
    break;

  case 'u':
  case 'w':
    if (__mod == 'E') [[unlikely]]
      __err |= ios_base::failbit;
    else if (__mod == 'O')
      {
        if (__c == 'w')
   {
     struct tm __tm{};
     __tmget.get(__is, {}, __is, __err, &__tm,
          __fmt - 3, __fmt);
     if (!__is_failed(__err))
       __wday = weekday(__tm.tm_wday);
   }
        else
   __err |= ios_base::failbit;
      }
    else
      {
        const int __lo = __c == 'u' ? 1 : 0;
        const int __hi = __lo + 6;
        auto __val = __read_unsigned(__num ? __num : 1);
        if (__lo <= __val && __val <= __hi)
   __wday = weekday(__val);
        else
   {
     __wday = __bad_wday;
     break;
   }
      }
    __parts |= _ChronoParts::_Weekday;
    break;

  case 'U':
  case 'V':
  case 'W':
    if (__mod == 'E') [[unlikely]]
      __err |= ios_base::failbit;
    else if (__mod == 'O')
      {
        if (__c == 'V') [[unlikely]]
   __err |= ios_base::failbit;
        else
   {


   }
      }
    else
      {
        const int __lo = __c == 'V' ? 1 : 0;
        const int __hi = 53;
        auto __val = __read_unsigned(__num ? __num : 2);
        if (__lo <= __val && __val <= __hi)
   {
     switch (__c)
     {
       case 'U':
         __sunday_wk = __val;
         break;
       case 'V':
         __iso_wk = __val;
         break;
       case 'W':
         __monday_wk = __val;
         break;
     }
   }
        else
   __iso_wk = __sunday_wk = __monday_wk = -1;
      }

    break;

  case 'x':
    if (__mod == 'O' || __num) [[unlikely]]
      __err |= ios_base::failbit;
    else
      {
        struct tm __tm{};
        __tmget.get(__is, {}, __is, __err, &__tm,
      __fmt - 2 - (__mod == 'E'), __fmt);
        if (!__is_failed(__err))
   {
     __y = year(__tm.tm_year + 1900);
     __m = month(__tm.tm_mon + 1);
     __d = day(__tm.tm_mday);
   }
      }
    __parts |= _ChronoParts::_Date;
    break;

  case 'X':
    if (__mod == 'O' || __num) [[unlikely]]
      __err |= ios_base::failbit;
    else
      {
        struct tm __tm{};
        __tmget.get(__is, {}, __is, __err, &__tm,
      __fmt - 2 - (__mod == 'E'), __fmt);
        if (!__is_failed(__err))
   {
     __h = hours(__tm.tm_hour);
     __min = minutes(__tm.tm_min);
     __s = seconds(__tm.tm_sec);
   }
      }
    __parts |= _ChronoParts::_TimeOfDay;
    break;

  case 'y':
    if (__mod) [[unlikely]]
      {
        struct tm __tm{};
        __tmget.get(__is, {}, __is, __err, &__tm,
      __fmt - 3, __fmt);
        if (!__is_failed(__err))
   {
     int __cent = __tm.tm_year < 2000 ? 1900 : 2000;
     __yy = year(__tm.tm_year - __cent);
     if (__century == -1)
       __century = __cent;
   }
      }
    else
      {
        auto __val = __read_unsigned(__num ? __num : 2);
        if (__val >= 0 && __val <= 99)
   {
     __yy = year(__val);
     if (__century == -1)
       __century = __val < 69 ? 2000 : 1900;
   }
        else
   __y = __yy = __iso_yy = __iso_y = __bad_y;
      }
    __parts |= _ChronoParts::_Year;
    break;

  case 'Y':
    if (__mod == 'O') [[unlikely]]
      __err |= ios_base::failbit;
    else if (__mod == 'E')
      {
        struct tm __tm{};
        __tmget.get(__is, {}, __is, __err, &__tm,
      __fmt - 3, __fmt);
        if (!__is_failed(__err))
   __y = year(__tm.tm_year);
      }
    else
      {
        auto __val = __read_unsigned(__num ? __num : 4);
        if (!__is_failed(__err))
   __y = year(__val);
      }
    __parts |= _ChronoParts::_Year;
    break;

  case 'z':
    if (__num) [[unlikely]]
      __err |= ios_base::failbit;
    else
      {



        auto __i = __is.peek();
        if (_Traits::eq_int_type(__i, _Traits::eof()))
   {
     __err |= ios_base::eofbit | ios_base::failbit;
     break;
   }
        _CharT __ic = _Traits::to_char_type(__i);
        const bool __neg = __ic == _CharT('-');
        if (__ic == _CharT('-') || __ic == _CharT('+'))
   (void) __is.get();

        int_least32_t __hh;
        if (__mod)
   {

     __hh = __read_unsigned(2);
   }
        else
   {

     __hh = 10 * _S_try_read_digit(__is, __err);
     __hh += _S_try_read_digit(__is, __err);
   }

        if (__is_failed(__err))
   break;

        __i = __is.peek();
        if (_Traits::eq_int_type(__i, _Traits::eof()))
   {
     __err |= ios_base::eofbit;
     __tz_offset = minutes(__hh * (__neg ? -60 : 60));
     break;
   }
        __ic = _Traits::to_char_type(__i);

        bool __read_mm = false;
        if (__mod)
   {
     if (__ic == ::std::chrono::__detail::_Widen<_CharT>(":", L":")[0])
       {

         (void) __is.get();
         __read_mm = true;
       }
   }
        else if (_CharT('0') <= __ic && __ic <= _CharT('9'))
   {

     __read_mm = true;
   }

        int_least32_t __mm = 0;
        if (__read_mm)
   {
     __mm = 10 * _S_try_read_digit(__is, __err);
     __mm += _S_try_read_digit(__is, __err);
   }

        if (!__is_failed(__err))
   {
     auto __z = __hh * 60 + __mm;
     __tz_offset = minutes(__neg ? -__z : __z);
   }
      }
    break;

  case 'Z':
    if (__mod || __num) [[unlikely]]
      __err |= ios_base::failbit;
    else
      {
        basic_string_view<_CharT> __x = ::std::chrono::__detail::_Widen<_CharT>("_/-+", L"_/-+");
        __tz_abbr.clear();
        while (true)
   {
     auto __i = __is.peek();
     if (!_Traits::eq_int_type(__i, _Traits::eof()))
       {
         _CharT __a = _Traits::to_char_type(__i);
         if (std::isalnum(__a, __loc)
        || __x.find(__a) != __x.npos)
    {
      __tz_abbr.push_back(__a);
      (void) __is.get();
      continue;
    }
       }
     else
       __err |= ios_base::eofbit;
     break;
   }
        if (__tz_abbr.empty())
   __err |= ios_base::failbit;
      }
    break;

  case 'n':
    if (__mod || __num) [[unlikely]]
      __err |= ios_base::failbit;
    else
      {
        _CharT __i = __is.peek();
        if (_Traits::eq_int_type(__i, _Traits::eof()))
   __err |= ios_base::eofbit | ios_base::failbit;
        else if (std::isspace(_Traits::to_char_type(__i), __loc))
   (void) __is.get();
        else
   __err |= ios_base::failbit;
      }
    break;

  case 't':
    if (__mod || __num) [[unlikely]]
      __err |= ios_base::failbit;
    else
      {
        _CharT __i = __is.peek();
        if (_Traits::eq_int_type(__i, _Traits::eof()))
   __err |= ios_base::eofbit;
        else if (std::isspace(_Traits::to_char_type(__i), __loc))
   (void) __is.get();
      }
    break;

  case '%':
    if (__mod || __num) [[unlikely]]
      __err |= ios_base::failbit;
    else
      __read_chr('%');
    break;

  case 'O':
  case 'E':
    if (__mod || __num) [[unlikely]]
      {
        __err |= ios_base::failbit;
        break;
      }
    __mod = __c;
    continue;

  default:
    if (_CharT('1') <= __c && __c <= _CharT('9'))
      {
        if (!__mod) [[likely]]
   {

     auto __end = __fmt + _Traits::length(__fmt);
     auto [__v, __ptr]
       = __format::__parse_integer(__fmt - 1, __end);
     if (__ptr) [[likely]]
       {
         __num = __v;
         __fmt = __ptr;
         continue;
       }
   }
      }
    __err |= ios_base::failbit;
  }

       if (__is_failed(__err)) [[unlikely]]
  break;

       __is_flag = false;
       __num = 0;
       __mod = _CharT();
     }

   if (__century >= 0)
     {
       if (__yy != __bad_y && __y == __bad_y)
  __y = years(__century) + __yy;
       if (__iso_yy != __bad_y && __iso_y == __bad_y)
  __iso_y = years(__century) + __iso_yy;
     }

   bool __can_use_doy = false;
   bool __can_use_iso_wk = false;
   bool __can_use_sun_wk = false;
   bool __can_use_mon_wk = false;


   if (__y != __bad_y && __dayofyear >= 0)
     {
       __can_use_doy = true;
       __parts |= _ChronoParts::_Date;
     }
   else if (__y != __bad_y && __wday != __bad_wday && __sunday_wk >= 0)
     {
       __can_use_sun_wk = true;
       __parts |= _ChronoParts::_Date;
     }
   else if (__y != __bad_y && __wday != __bad_wday && __monday_wk >= 0)
     {
       __can_use_mon_wk = true;
       __parts |= _ChronoParts::_Date;
     }
   else if (__iso_y != __bad_y && __wday != __bad_wday && __iso_wk > 0)
     {

       __can_use_iso_wk = true;
       __parts |= _ChronoParts::_Date;
     }

   if (__is_failed(__err)) [[unlikely]]
     ;
   else if (__is_flag) [[unlikely]]
     __err |= ios_base::failbit;
   else if ((_M_need & __parts) == _M_need) [[likely]]
     {
# 4115 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/chrono_io.h" 3
       const bool __need_wday = _M_need & _ChronoParts::_Weekday;



       const bool __need_time = _M_need & _ChronoParts::_TimeOfDay;

       if (__need_wday && __wday != __bad_wday)
  _M_wd = __wday;
       else if (_M_need & _ChronoParts::_Date)
  {


    const bool __need_ymd = !__need_wday && !__need_time;

    if ((_M_need & _ChronoParts::_Year && __y == __bad_y)
       || (_M_need & _ChronoParts::_Month && __m == __bad_mon)
       || (_M_need & _ChronoParts::_Day && __d == __bad_day))
      {



        if (__can_use_doy)
   {
     if ((0 < __dayofyear && __dayofyear <= 365)
    || (__dayofyear == 366 && __y.is_leap()))
       [[likely]]
       {
         _M_sys_days = sys_days(__y/January/1)
           + days(__dayofyear - 1);
         if (__need_ymd)
    _M_ymd = year_month_day(_M_sys_days);
       }
     else
       __err |= ios_base::failbit;
   }
        else if (__can_use_iso_wk)
   {


     if (__iso_wk == 53)
       {


         const sys_days __jan4(__iso_y/January/4);
         weekday __wd1(__jan4 - days(3));
         if (__wd1 != Thursday)
    if (__wd1 != Wednesday || !__iso_y.is_leap())
      __err |= ios_base::failbit;
       }

     if (!__is_failed(__err)) [[likely]]
       {

         sys_days __w(Thursday[1]/January/__iso_y);

         __w -= Thursday - Monday;
         __w += days(weeks(__iso_wk - 1));
         __w += __wday - Monday;
         _M_sys_days = __w;

         if (__need_ymd)
    _M_ymd = year_month_day(_M_sys_days);
       }
   }
        else if (__can_use_sun_wk)
   {

     sys_days __wk1(__y/January/Sunday[1]);
     _M_sys_days = __wk1 + weeks(__sunday_wk - 1)
     + days(__wday.c_encoding());
     _M_ymd = year_month_day(_M_sys_days);
     if (_M_ymd.year() != __y) [[unlikely]]
       __err |= ios_base::failbit;
   }
        else if (__can_use_mon_wk)
   {

     sys_days __wk1(__y/January/Monday[1]);
     _M_sys_days = __wk1 + weeks(__monday_wk - 1)
     + days(__wday.c_encoding() - 1);
     _M_ymd = year_month_day(_M_sys_days);
     if (_M_ymd.year() != __y) [[unlikely]]
       __err |= ios_base::failbit;
   }
        else
   __err |= ios_base::failbit;
      }
    else
      {




        if (_M_need & _ChronoParts::_Year)
   {
     if (!__y.ok()) [[unlikely]]
       __err |= ios_base::failbit;
   }
        else if (__y == __bad_y)
   __y = 1972y;

        if (_M_need & _ChronoParts::_Month)
   {
     if (!__m.ok()) [[unlikely]]
       __err |= ios_base::failbit;
   }
        else if (__m == __bad_mon)
   __m = January;

        if (_M_need & _ChronoParts::_Day)
   {
     if (__d < day(1) || __d > (__y/__m/last).day())
       __err |= ios_base::failbit;
   }
        else if (__d == __bad_day)
   __d = 1d;

        if (year_month_day __ymd(__y, __m, __d); __ymd.ok())
   {
     _M_ymd = __ymd;
     if (__need_wday || __need_time)
       _M_sys_days = sys_days(_M_ymd);
   }
        else [[unlikely]]
   __err |= ios_base::failbit;
      }

    if (__need_wday)
      _M_wd = weekday(_M_sys_days);
  }


       if (__need_time)
  {
    if (__h == __bad_h && __h12 != __bad_h)
      {
        if (__ampm == 1)
   __h = __h12 == hours(12) ? hours(0) : __h12;
        else if (__ampm == 2)
   __h = __h12 == hours(12) ? __h12 : __h12 + hours(12);
        else [[unlikely]]
   __err |= ios_base::failbit;
      }

    auto __t = _M_time.zero();
    bool __ok = false;

    if (__h != __bad_h)
      {
        __ok = true;
        __t += __h;
      }

    if (__min != __bad_min)
      {
        __ok = true;
        __t += __min;
      }

    if (__s != __bad_sec)
      {
        __ok = true;
        __t += __s;
        _M_is_leap_second = __s >= seconds(60);
      }

    if (__ok)
      _M_time = __t;
    else
      __err |= ios_base::failbit;
  }

       if (!__is_failed(__err)) [[likely]]
  {
    if (__offset && __tz_offset != __bad_min)
      *__offset = __tz_offset;
    if (__abbrev && !__tz_abbr.empty())
      *__abbrev = std::move(__tz_abbr);
  }
     }
   else
     __err |= ios_base::failbit;
 }
      if (__err)
 __is.setstate(__err);
      return __is;
    }




}


}
# 3361 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/chrono" 2 3
# 26 "/home/avi/scylla-maint/seastar/include/seastar/core/scheduling.hh" 2


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/typeindex" 1 3
# 33 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/typeindex" 3
# 43 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/typeindex" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 55 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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<typename _Tp> struct hash;


  template<>
    struct hash<type_index>
    {
      typedef size_t result_type;
      typedef type_index argument_type;

      size_t
      operator()(const type_index& __ti) const noexcept
      { return __ti.hash_code(); }
    };


}
# 29 "/home/avi/scylla-maint/seastar/include/seastar/core/scheduling.hh" 2

# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/sstring.hh" 1
# 26 "/home/avi/scylla-maint/seastar/include/seastar/core/sstring.hh"
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/algorithm" 1 3
# 59 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/algorithm" 3




# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ranges_algo.h" 1 3
# 43 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/ranges_algo.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{

namespace ranges
{
  namespace __detail
  {
    template<typename _Comp, typename _Proj>
      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<typename _Pred, typename _Proj>
      constexpr auto
      __make_pred_proj(_Pred& __pred, _Proj& __proj)
      {
 return [&] <typename _Tp> (_Tp&& __arg) -> bool {
   return std::__invoke(__pred,
          std::__invoke(__proj, std::forward<_Tp>(__arg)));
 };
      }
  }

  struct __all_of_fn
  {
    template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Proj = identity,
      indirect_unary_predicate<projected<_Iter, _Proj>> _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<input_range _Range, typename _Proj = identity,
      indirect_unary_predicate<projected<iterator_t<_Range>, _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<input_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Proj = identity,
      indirect_unary_predicate<projected<_Iter, _Proj>> _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<input_range _Range, typename _Proj = identity,
      indirect_unary_predicate<projected<iterator_t<_Range>, _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<input_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Proj = identity,
      indirect_unary_predicate<projected<_Iter, _Proj>> _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<input_range _Range, typename _Proj = identity,
      indirect_unary_predicate<projected<iterator_t<_Range>, _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<typename _Iter, typename _Fp>
    struct in_fun_result
    {
      [[no_unique_address]] _Iter in;
      [[no_unique_address]] _Fp fun;

      template<typename _Iter2, typename _F2p>
 requires convertible_to<const _Iter&, _Iter2>
   && convertible_to<const _Fp&, _F2p>
 constexpr
 operator in_fun_result<_Iter2, _F2p>() const &
 { return {in, fun}; }

      template<typename _Iter2, typename _F2p>
 requires convertible_to<_Iter, _Iter2> && convertible_to<_Fp, _F2p>
 constexpr
 operator in_fun_result<_Iter2, _F2p>() &&
 { return {std::move(in), std::move(fun)}; }
    };

  template<typename _Iter, typename _Fp>
    using for_each_result = in_fun_result<_Iter, _Fp>;

  struct __for_each_fn
  {
    template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Proj = identity,
      indirectly_unary_invocable<projected<_Iter, _Proj>> _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<input_range _Range, typename _Proj = identity,
      indirectly_unary_invocable<projected<iterator_t<_Range>, _Proj>>
        _Fun>
      constexpr for_each_result<borrowed_iterator_t<_Range>, _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<typename _Iter, typename _Fp>
    using for_each_n_result = in_fun_result<_Iter, _Fp>;

  struct __for_each_n_fn
  {
    template<input_iterator _Iter, typename _Proj = identity,
      indirectly_unary_invocable<projected<_Iter, _Proj>> _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_first_of_fn
  {
    template<input_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
      forward_iterator _Iter2, sentinel_for<_Iter2> _Sent2,
      typename _Pred = ranges::equal_to,
      typename _Proj1 = identity, typename _Proj2 = identity>
      requires indirectly_comparable<_Iter1, _Iter2, _Pred, _Proj1, _Proj2>
      constexpr _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<input_range _Range1, forward_range _Range2,
      typename _Pred = ranges::equal_to,
      typename _Proj1 = identity, typename _Proj2 = identity>
      requires indirectly_comparable<iterator_t<_Range1>, iterator_t<_Range2>,
         _Pred, _Proj1, _Proj2>
      constexpr borrowed_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<input_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Tp, typename _Proj = identity>
      requires indirect_binary_predicate<ranges::equal_to,
      projected<_Iter, _Proj>,
      const _Tp*>
      constexpr iter_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<input_range _Range, typename _Tp, typename _Proj = identity>
      requires indirect_binary_predicate<ranges::equal_to,
      projected<iterator_t<_Range>, _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<input_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Proj = identity,
      indirect_unary_predicate<projected<_Iter, _Proj>> _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<input_range _Range,
      typename _Proj = identity,
      indirect_unary_predicate<projected<iterator_t<_Range>, _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{};



  struct __search_n_fn
  {
    template<forward_iterator _Iter, sentinel_for<_Iter> _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 = [&] <typename _Rp> (_Rp&& __arg) -> bool {
     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<forward_range _Range, typename _Tp,
      typename _Pred = ranges::equal_to, typename _Proj = identity>
      requires indirectly_comparable<iterator_t<_Range>, 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<forward_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
      forward_iterator _Iter2, sentinel_for<_Iter2> _Sent2,
      typename _Pred = ranges::equal_to,
      typename _Proj1 = identity, typename _Proj2 = identity>
      requires indirectly_comparable<_Iter1, _Iter2, _Pred, _Proj1, _Proj2>
      constexpr subrange<_Iter1>
      operator()(_Iter1 __first1, _Sent1 __last1,
   _Iter2 __first2, _Sent2 __last2, _Pred __pred = {},
   _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
      {
 if 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<forward_range _Range1, forward_range _Range2,
      typename _Pred = ranges::equal_to,
      typename _Proj1 = identity, typename _Proj2 = identity>
      requires indirectly_comparable<iterator_t<_Range1>, iterator_t<_Range2>,
         _Pred, _Proj1, _Proj2>
      constexpr borrowed_subrange_t<_Range1>
      operator()(_Range1&& __r1, _Range2&& __r2, _Pred __pred = {},
   _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
      {
 return (*this)(ranges::begin(__r1), ranges::end(__r1),
         ranges::begin(__r2), ranges::end(__r2),
         std::move(__pred),
         std::move(__proj1), std::move(__proj2));
      }
  };

  inline constexpr __find_end_fn find_end{};



  struct __is_permutation_fn
  {
    template<forward_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
      forward_iterator _Iter2, sentinel_for<_Iter2> _Sent2,
      typename _Proj1 = identity, typename _Proj2 = identity,
      indirect_equivalence_relation<projected<_Iter1, _Proj1>,
        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 = [&] <typename _Tp> (_Tp&& __arg) -> bool {
       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<forward_range _Range1, forward_range _Range2,
      typename _Proj1 = identity, typename _Proj2 = identity,
      indirect_equivalence_relation<
        projected<iterator_t<_Range1>, _Proj1>,
        projected<iterator_t<_Range2>, _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<typename _Iter, typename _Out>
    using copy_if_result = in_out_result<_Iter, _Out>;

  struct __copy_if_fn
  {
    template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
      weakly_incrementable _Out, typename _Proj = identity,
      indirect_unary_predicate<projected<_Iter, _Proj>> _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<input_range _Range, weakly_incrementable _Out,
      typename _Proj = identity,
      indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>>
        _Pred>
      requires indirectly_copyable<iterator_t<_Range>, _Out>
      constexpr copy_if_result<borrowed_iterator_t<_Range>, _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<typename _Iter1, typename _Iter2>
    using swap_ranges_result = in_in_result<_Iter1, _Iter2>;

  struct __swap_ranges_fn
  {
    template<input_iterator _Iter1, sentinel_for<_Iter1> _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<input_range _Range1, input_range _Range2>
      requires indirectly_swappable<iterator_t<_Range1>, iterator_t<_Range2>>
      constexpr swap_ranges_result<borrowed_iterator_t<_Range1>,
       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<typename _Iter, typename _Out>
    using unary_transform_result = in_out_result<_Iter, _Out>;

  template<typename _Iter1, typename _Iter2, typename _Out>
    struct in_in_out_result
    {
      [[no_unique_address]] _Iter1 in1;
      [[no_unique_address]] _Iter2 in2;
      [[no_unique_address]] _Out out;

      template<typename _IIter1, typename _IIter2, typename _OOut>
 requires convertible_to<const _Iter1&, _IIter1>
   && convertible_to<const _Iter2&, _IIter2>
   && convertible_to<const _Out&, _OOut>
 constexpr
 operator in_in_out_result<_IIter1, _IIter2, _OOut>() const &
 { return {in1, in2, out}; }

      template<typename _IIter1, typename _IIter2, typename _OOut>
 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<typename _Iter1, typename _Iter2, typename _Out>
    using binary_transform_result = in_in_out_result<_Iter1, _Iter2, _Out>;

  struct __transform_fn
  {
    template<input_iterator _Iter, sentinel_for<_Iter> _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<input_range _Range, weakly_incrementable _Out,
      copy_constructible _Fp, typename _Proj = identity>
      requires indirectly_writable<_Out,
       indirect_result_t<_Fp&,
         projected<iterator_t<_Range>, _Proj>>>
      constexpr unary_transform_result<borrowed_iterator_t<_Range>, _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<input_iterator _Iter1, sentinel_for<_Iter1> _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<input_range _Range1, input_range _Range2,
      weakly_incrementable _Out, copy_constructible _Fp,
      typename _Proj1 = identity, typename _Proj2 = identity>
      requires indirectly_writable<_Out,
       indirect_result_t<_Fp&,
         projected<iterator_t<_Range1>, _Proj1>,
         projected<iterator_t<_Range2>, _Proj2>>>
      constexpr binary_transform_result<borrowed_iterator_t<_Range1>,
     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<input_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Tp1, typename _Tp2, typename _Proj = identity>
      requires indirectly_writable<_Iter, const _Tp2&>
 && indirect_binary_predicate<ranges::equal_to, projected<_Iter, _Proj>,
         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<input_range _Range,
      typename _Tp1, typename _Tp2, typename _Proj = identity>
      requires indirectly_writable<iterator_t<_Range>, const _Tp2&>
 && indirect_binary_predicate<ranges::equal_to,
         projected<iterator_t<_Range>, _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<input_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Tp, typename _Proj = identity,
      indirect_unary_predicate<projected<_Iter, _Proj>> _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<input_range _Range, typename _Tp, typename _Proj = identity,
      indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>>
        _Pred>
      requires indirectly_writable<iterator_t<_Range>, 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<typename _Iter, typename _Out>
    using replace_copy_result = in_out_result<_Iter, _Out>;

  struct __replace_copy_fn
  {
    template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Tp1, typename _Tp2, output_iterator<const _Tp2&> _Out,
      typename _Proj = identity>
      requires indirectly_copyable<_Iter, _Out>
 && indirect_binary_predicate<ranges::equal_to,
         projected<_Iter, _Proj>, 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<input_range _Range, typename _Tp1, typename _Tp2,
      output_iterator<const _Tp2&> _Out, typename _Proj = identity>
      requires indirectly_copyable<iterator_t<_Range>, _Out>
 && indirect_binary_predicate<ranges::equal_to,
         projected<iterator_t<_Range>, _Proj>,
         const _Tp1*>
      constexpr replace_copy_result<borrowed_iterator_t<_Range>, _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<typename _Iter, typename _Out>
    using replace_copy_if_result = in_out_result<_Iter, _Out>;

  struct __replace_copy_if_fn
  {
    template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Tp, output_iterator<const _Tp&> _Out,
      typename _Proj = identity,
      indirect_unary_predicate<projected<_Iter, _Proj>> _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<input_range _Range,
      typename _Tp, output_iterator<const _Tp&> _Out,
      typename _Proj = identity,
      indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>>
        _Pred>
      requires indirectly_copyable<iterator_t<_Range>, _Out>
      constexpr replace_copy_if_result<borrowed_iterator_t<_Range>, _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<input_or_output_iterator _Out, copy_constructible _Fp>
      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<input_or_output_iterator _Out, sentinel_for<_Out> _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<typename _Range, copy_constructible _Fp>
      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<permutable _Iter, sentinel_for<_Iter> _Sent,
      typename _Proj = identity,
      indirect_unary_predicate<projected<_Iter, _Proj>> _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<forward_range _Range, typename _Proj = identity,
      indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>>
        _Pred>
      requires permutable<iterator_t<_Range>>
      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<permutable _Iter, sentinel_for<_Iter> _Sent,
      typename _Tp, typename _Proj = identity>
      requires indirect_binary_predicate<ranges::equal_to,
      projected<_Iter, _Proj>,
      const _Tp*>
      constexpr subrange<_Iter>
      operator()(_Iter __first, _Sent __last,
   const _Tp& __value, _Proj __proj = {}) const
      {
 auto __pred = [&] (auto&& __arg) -> bool {
   return std::forward<decltype(__arg)>(__arg) == __value;
 };
 return ranges::remove_if(__first, __last,
     std::move(__pred), std::move(__proj));
      }

    template<forward_range _Range, typename _Tp, typename _Proj = identity>
      requires permutable<iterator_t<_Range>>
 && indirect_binary_predicate<ranges::equal_to,
         projected<iterator_t<_Range>, _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<typename _Iter, typename _Out>
    using remove_copy_if_result = in_out_result<_Iter, _Out>;

  struct __remove_copy_if_fn
  {
    template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
      weakly_incrementable _Out, typename _Proj = identity,
      indirect_unary_predicate<projected<_Iter, _Proj>> _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<input_range _Range, weakly_incrementable _Out,
      typename _Proj = identity,
      indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>>
        _Pred>
      requires indirectly_copyable<iterator_t<_Range>, _Out>
      constexpr remove_copy_if_result<borrowed_iterator_t<_Range>, _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<typename _Iter, typename _Out>
    using remove_copy_result = in_out_result<_Iter, _Out>;

  struct __remove_copy_fn
  {
    template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
      weakly_incrementable _Out, typename _Tp, typename _Proj = identity>
      requires indirectly_copyable<_Iter, _Out>
 && indirect_binary_predicate<ranges::equal_to,
         projected<_Iter, _Proj>,
         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<input_range _Range, weakly_incrementable _Out,
      typename _Tp, typename _Proj = identity>
      requires indirectly_copyable<iterator_t<_Range>, _Out>
 && indirect_binary_predicate<ranges::equal_to,
         projected<iterator_t<_Range>, _Proj>,
         const _Tp*>
      constexpr remove_copy_result<borrowed_iterator_t<_Range>, _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<permutable _Iter, sentinel_for<_Iter> _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<forward_range _Range, typename _Proj = identity,
      indirect_equivalence_relation<
        projected<iterator_t<_Range>, _Proj>> _Comp = ranges::equal_to>
      requires permutable<iterator_t<_Range>>
      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{};

  namespace __detail
  {
    template<typename _Out, typename _Tp>
      concept __can_reread_output = input_iterator<_Out>
 && same_as<_Tp, iter_value_t<_Out>>;
  }

  template<typename _Iter, typename _Out>
    using unique_copy_result = in_out_result<_Iter, _Out>;

  struct __unique_copy_fn
  {
    template<input_iterator _Iter, sentinel_for<_Iter> _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>
     || __detail::__can_reread_output<_Out, iter_value_t<_Iter>>
     || 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 (__detail::__can_reread_output<_Out, iter_value_t<_Iter>>)
   {
     *__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<input_range _Range,
      weakly_incrementable _Out, typename _Proj = identity,
      indirect_equivalence_relation<
        projected<iterator_t<_Range>, _Proj>> _Comp = ranges::equal_to>
      requires indirectly_copyable<iterator_t<_Range>, _Out>
 && (forward_iterator<iterator_t<_Range>>
     || __detail::__can_reread_output<_Out, range_value_t<_Range>>
     || indirectly_copyable_storable<iterator_t<_Range>, _Out>)
      constexpr unique_copy_result<borrowed_iterator_t<_Range>, _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<bidirectional_iterator _Iter, sentinel_for<_Iter> _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<bidirectional_range _Range>
      requires permutable<iterator_t<_Range>>
      constexpr borrowed_iterator_t<_Range>
      operator()(_Range&& __r) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r));
      }
  };

  inline constexpr __reverse_fn reverse{};

  template<typename _Iter, typename _Out>
    using reverse_copy_result = in_out_result<_Iter, _Out>;

  struct __reverse_copy_fn
  {
    template<bidirectional_iterator _Iter, sentinel_for<_Iter> _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, std::move(__result)};
      }

    template<bidirectional_range _Range, weakly_incrementable _Out>
      requires indirectly_copyable<iterator_t<_Range>, _Out>
      constexpr reverse_copy_result<borrowed_iterator_t<_Range>, _Out>
      operator()(_Range&& __r, _Out __result) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__result));
      }
  };

  inline constexpr __reverse_copy_fn reverse_copy{};

  struct __rotate_fn
  {
    template<permutable _Iter, sentinel_for<_Iter> _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<forward_range _Range>
      requires permutable<iterator_t<_Range>>
      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<typename _Iter, typename _Out>
    using rotate_copy_result = in_out_result<_Iter, _Out>;

  struct __rotate_copy_fn
  {
    template<forward_iterator _Iter, sentinel_for<_Iter> _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<forward_range _Range, weakly_incrementable _Out>
      requires indirectly_copyable<iterator_t<_Range>, _Out>
      constexpr rotate_copy_result<borrowed_iterator_t<_Range>, _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<input_iterator _Iter, sentinel_for<_Iter> _Sent,
      weakly_incrementable _Out, typename _Gen>
      requires (forward_iterator<_Iter> || random_access_iterator<_Out>)
 && indirectly_copyable<_Iter, _Out>
 && uniform_random_bit_generator<remove_reference_t<_Gen>>
      _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<iter_difference_t<_Iter>>;
     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<input_range _Range, weakly_incrementable _Out, typename _Gen>
      requires (forward_range<_Range> || random_access_iterator<_Out>)
 && indirectly_copyable<iterator_t<_Range>, _Out>
 && uniform_random_bit_generator<remove_reference_t<_Gen>>
      _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<random_access_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Gen>
      requires permutable<_Iter>
 && uniform_random_bit_generator<remove_reference_t<_Gen>>
      _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<random_access_range _Range, typename _Gen>
      requires permutable<iterator_t<_Range>>
 && uniform_random_bit_generator<remove_reference_t<_Gen>>
      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<random_access_iterator _Iter, sentinel_for<_Iter> _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<random_access_range _Range,
      typename _Comp = ranges::less, typename _Proj = identity>
      requires sortable<iterator_t<_Range>, _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<random_access_iterator _Iter, sentinel_for<_Iter> _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<random_access_range _Range,
      typename _Comp = ranges::less, typename _Proj = identity>
      requires sortable<iterator_t<_Range>, _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<random_access_iterator _Iter, sentinel_for<_Iter> _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<random_access_range _Range,
      typename _Comp = ranges::less, typename _Proj = identity>
      requires sortable<iterator_t<_Range>, _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<random_access_iterator _Iter, sentinel_for<_Iter> _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<random_access_range _Range,
      typename _Comp = ranges::less, typename _Proj = identity>
      requires sortable<iterator_t<_Range>, _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<random_access_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Proj = identity,
      indirect_strict_weak_order<projected<_Iter, _Proj>>
        _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<random_access_range _Range,
      typename _Proj = identity,
      indirect_strict_weak_order<projected<iterator_t<_Range>, _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<random_access_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Proj = identity,
      indirect_strict_weak_order<projected<_Iter, _Proj>>
        _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<random_access_range _Range,
      typename _Proj = identity,
      indirect_strict_weak_order<projected<iterator_t<_Range>, _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<random_access_iterator _Iter, sentinel_for<_Iter> _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<random_access_range _Range,
      typename _Comp = ranges::less, typename _Proj = identity>
      requires sortable<iterator_t<_Range>, _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<random_access_iterator _Iter, sentinel_for<_Iter> _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<random_access_range _Range,
      typename _Comp = ranges::less, typename _Proj = identity>
      requires sortable<iterator_t<_Range>, _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<random_access_iterator _Iter, sentinel_for<_Iter> _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<random_access_range _Range,
      typename _Comp = ranges::less, typename _Proj = identity>
      requires sortable<iterator_t<_Range>, _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<typename _Iter, typename _Out>
    using partial_sort_copy_result = in_out_result<_Iter, _Out>;

  struct __partial_sort_copy_fn
  {
    template<input_iterator _Iter1, sentinel_for<_Iter1> _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<input_range _Range1, random_access_range _Range2,
      typename _Comp = ranges::less,
      typename _Proj1 = identity, typename _Proj2 = identity>
      requires indirectly_copyable<iterator_t<_Range1>, iterator_t<_Range2>>
 && sortable<iterator_t<_Range2>, _Comp, _Proj2>
 && indirect_strict_weak_order<_Comp,
          projected<iterator_t<_Range1>, _Proj1>,
          projected<iterator_t<_Range2>, _Proj2>>
      constexpr partial_sort_copy_result<borrowed_iterator_t<_Range1>,
      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<forward_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Proj = identity,
      indirect_strict_weak_order<projected<_Iter, _Proj>>
        _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<forward_range _Range, typename _Proj = identity,
      indirect_strict_weak_order<projected<iterator_t<_Range>, _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<forward_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Proj = identity,
      indirect_strict_weak_order<projected<_Iter, _Proj>>
        _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<forward_range _Range, typename _Proj = identity,
      indirect_strict_weak_order<projected<iterator_t<_Range>, _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<random_access_iterator _Iter, sentinel_for<_Iter> _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<random_access_range _Range,
      typename _Comp = ranges::less, typename _Proj = identity>
      requires sortable<iterator_t<_Range>, _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<forward_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Tp, typename _Proj = identity,
      indirect_strict_weak_order<const _Tp*, projected<_Iter, _Proj>>
        _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<forward_range _Range, typename _Tp, typename _Proj = identity,
      indirect_strict_weak_order<const _Tp*,
     projected<iterator_t<_Range>, _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<forward_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Tp, typename _Proj = identity,
      indirect_strict_weak_order<const _Tp*, projected<_Iter, _Proj>>
        _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<forward_range _Range, typename _Tp, typename _Proj = identity,
      indirect_strict_weak_order<const _Tp*,
     projected<iterator_t<_Range>, _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<forward_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Tp, typename _Proj = identity,
      indirect_strict_weak_order<const _Tp*, projected<_Iter, _Proj>>
        _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<forward_range _Range,
      typename _Tp, typename _Proj = identity,
      indirect_strict_weak_order<const _Tp*,
     projected<iterator_t<_Range>, _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<forward_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Tp, typename _Proj = identity,
      indirect_strict_weak_order<const _Tp*, projected<_Iter, _Proj>>
        _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<forward_range _Range,
      typename _Tp, typename _Proj = identity,
      indirect_strict_weak_order<const _Tp*,
     projected<iterator_t<_Range>, _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<input_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Proj = identity,
      indirect_unary_predicate<projected<_Iter, _Proj>> _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<input_range _Range, typename _Proj = identity,
      indirect_unary_predicate<projected<iterator_t<_Range>, _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<permutable _Iter, sentinel_for<_Iter> _Sent,
      typename _Proj = identity,
      indirect_unary_predicate<projected<_Iter, _Proj>> _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 {__first, __first};

     while (std::__invoke(__pred, std::__invoke(__proj, *__first)))
       if (++__first == __last)
  return {__first, __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<forward_range _Range, typename _Proj = identity,
      indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>>
        _Pred>
      requires permutable<iterator_t<_Range>>
      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<bidirectional_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Proj = identity,
      indirect_unary_predicate<projected<_Iter, _Proj>> _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<bidirectional_range _Range, typename _Proj = identity,
      indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>>
        _Pred>
      requires permutable<iterator_t<_Range>>
      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<typename _Iter, typename _Out1, typename _Out2>
    struct in_out_out_result
    {
      [[no_unique_address]] _Iter in;
      [[no_unique_address]] _Out1 out1;
      [[no_unique_address]] _Out2 out2;

      template<typename _IIter, typename _OOut1, typename _OOut2>
 requires convertible_to<const _Iter&, _IIter>
   && convertible_to<const _Out1&, _OOut1>
   && convertible_to<const _Out2&, _OOut2>
 constexpr
 operator in_out_out_result<_IIter, _OOut1, _OOut2>() const &
 { return {in, out1, out2}; }

      template<typename _IIter, typename _OOut1, typename _OOut2>
 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<typename _Iter, typename _Out1, typename _Out2>
    using partition_copy_result = in_out_out_result<_Iter, _Out1, _Out2>;

  struct __partition_copy_fn
  {
    template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
      weakly_incrementable _Out1, weakly_incrementable _Out2,
      typename _Proj = identity,
      indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
      requires indirectly_copyable<_Iter, _Out1>
 && indirectly_copyable<_Iter, _Out2>
      constexpr partition_copy_result<_Iter, _Out1, _Out2>
      operator()(_Iter __first, _Sent __last,
   _Out1 __out_true, _Out2 __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<input_range _Range, weakly_incrementable _Out1,
      weakly_incrementable _Out2,
      typename _Proj = identity,
      indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>>
        _Pred>
      requires indirectly_copyable<iterator_t<_Range>, _Out1>
 && indirectly_copyable<iterator_t<_Range>, _Out2>
      constexpr partition_copy_result<borrowed_iterator_t<_Range>, _Out1, _Out2>
      operator()(_Range&& __r, _Out1 __out_true, _Out2 __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<forward_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Proj = identity,
      indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
      constexpr _Iter
      operator()(_Iter __first, _Sent __last,
   _Pred __pred, _Proj __proj = {}) const
      {
 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<forward_range _Range, typename _Proj = identity,
      indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>>
        _Pred>
      constexpr borrowed_iterator_t<_Range>
      operator()(_Range&& __r, _Pred __pred, _Proj __proj = {}) const
      {
 return (*this)(ranges::begin(__r), ranges::end(__r),
         std::move(__pred), std::move(__proj));
      }
  };

  inline constexpr __partition_point_fn partition_point{};

  template<typename _Iter1, typename _Iter2, typename _Out>
    using merge_result = in_in_out_result<_Iter1, _Iter2, _Out>;

  struct __merge_fn
  {
    template<input_iterator _Iter1, sentinel_for<_Iter1> _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<input_range _Range1, input_range _Range2, weakly_incrementable _Out,
      typename _Comp = ranges::less,
      typename _Proj1 = identity, typename _Proj2 = identity>
      requires mergeable<iterator_t<_Range1>, iterator_t<_Range2>, _Out,
    _Comp, _Proj1, _Proj2>
      constexpr merge_result<borrowed_iterator_t<_Range1>,
        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<bidirectional_iterator _Iter, sentinel_for<_Iter> _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<bidirectional_range _Range,
      typename _Comp = ranges::less, typename _Proj = identity>
      requires sortable<iterator_t<_Range>, _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<input_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
      input_iterator _Iter2, sentinel_for<_Iter2> _Sent2,
      typename _Proj1 = identity, typename _Proj2 = identity,
      indirect_strict_weak_order<projected<_Iter1, _Proj1>,
     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<input_range _Range1, input_range _Range2,
      typename _Proj1 = identity, typename _Proj2 = identity,
      indirect_strict_weak_order<projected<iterator_t<_Range1>, _Proj1>,
     projected<iterator_t<_Range2>, _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<typename _Iter1, typename _Iter2, typename _Out>
    using set_union_result = in_in_out_result<_Iter1, _Iter2, _Out>;

  struct __set_union_fn
  {
    template<input_iterator _Iter1, sentinel_for<_Iter1> _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<input_range _Range1, input_range _Range2, weakly_incrementable _Out,
      typename _Comp = ranges::less,
      typename _Proj1 = identity, typename _Proj2 = identity>
      requires mergeable<iterator_t<_Range1>, iterator_t<_Range2>, _Out,
    _Comp, _Proj1, _Proj2>
      constexpr set_union_result<borrowed_iterator_t<_Range1>,
     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<typename _Iter1, typename _Iter2, typename _Out>
    using set_intersection_result = in_in_out_result<_Iter1, _Iter2, _Out>;

  struct __set_intersection_fn
  {
    template<input_iterator _Iter1, sentinel_for<_Iter1> _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<input_range _Range1, input_range _Range2, weakly_incrementable _Out,
      typename _Comp = ranges::less,
      typename _Proj1 = identity, typename _Proj2 = identity>
      requires mergeable<iterator_t<_Range1>, iterator_t<_Range2>, _Out,
    _Comp, _Proj1, _Proj2>
      constexpr set_intersection_result<borrowed_iterator_t<_Range1>,
     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<typename _Iter, typename _Out>
    using set_difference_result = in_out_result<_Iter, _Out>;

  struct __set_difference_fn
  {
    template<input_iterator _Iter1, sentinel_for<_Iter1> _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<input_range _Range1, input_range _Range2, weakly_incrementable _Out,
      typename _Comp = ranges::less,
      typename _Proj1 = identity, typename _Proj2 = identity>
      requires mergeable<iterator_t<_Range1>, iterator_t<_Range2>, _Out,
    _Comp, _Proj1, _Proj2>
      constexpr set_difference_result<borrowed_iterator_t<_Range1>, _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<typename _Iter1, typename _Iter2, typename _Out>
    using set_symmetric_difference_result
      = in_in_out_result<_Iter1, _Iter2, _Out>;

  struct __set_symmetric_difference_fn
  {
    template<input_iterator _Iter1, sentinel_for<_Iter1> _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<input_range _Range1, input_range _Range2, weakly_incrementable _Out,
      typename _Comp = ranges::less,
      typename _Proj1 = identity, typename _Proj2 = identity>
      requires mergeable<iterator_t<_Range1>, iterator_t<_Range2>, _Out,
    _Comp, _Proj1, _Proj2>
      constexpr set_symmetric_difference_result<borrowed_iterator_t<_Range1>,
      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 __max_fn
  {
    template<typename _Tp, typename _Proj = identity,
      indirect_strict_weak_order<projected<const _Tp*, _Proj>>
        _Comp = ranges::less>
      constexpr const _Tp&
      operator()(const _Tp& __a, const _Tp& __b,
   _Comp __comp = {}, _Proj __proj = {}) const
      {
 if (std::__invoke(__comp,
     std::__invoke(__proj, __a),
     std::__invoke(__proj, __b)))
   return __b;
 else
   return __a;
      }

    template<input_range _Range, typename _Proj = identity,
      indirect_strict_weak_order<projected<iterator_t<_Range>, _Proj>>
        _Comp = ranges::less>
      requires indirectly_copyable_storable<iterator_t<_Range>,
         range_value_t<_Range>*>
      constexpr range_value_t<_Range>
      operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const
      {
 auto __first = ranges::begin(__r);
 auto __last = ranges::end(__r);
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__first != __last), false)) std::__glibcxx_assert_fail(); } while (false);
 auto __result = *__first;
 while (++__first != __last)
   {
     auto __tmp = *__first;
     if (std::__invoke(__comp,
         std::__invoke(__proj, __result),
         std::__invoke(__proj, __tmp)))
       __result = std::move(__tmp);
   }
 return __result;
      }

    template<copyable _Tp, typename _Proj = identity,
      indirect_strict_weak_order<projected<const _Tp*, _Proj>>
        _Comp = ranges::less>
      constexpr _Tp
      operator()(initializer_list<_Tp> __r,
   _Comp __comp = {}, _Proj __proj = {}) const
      {
 return (*this)(ranges::subrange(__r),
         std::move(__comp), std::move(__proj));
      }
  };

  inline constexpr __max_fn max{};

  struct __clamp_fn
  {
    template<typename _Tp, typename _Proj = identity,
      indirect_strict_weak_order<projected<const _Tp*, _Proj>> _Comp
        = ranges::less>
      constexpr const _Tp&
      operator()(const _Tp& __val, const _Tp& __lo, const _Tp& __hi,
   _Comp __comp = {}, _Proj __proj = {}) const
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(!(std::__invoke(__comp, std::__invoke(__proj, __hi), std::__invoke(__proj, __lo)))), false)) std::__glibcxx_assert_fail(); } while (false);


 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<typename _Tp>
    struct min_max_result
    {
      [[no_unique_address]] _Tp min;
      [[no_unique_address]] _Tp max;

      template<typename _Tp2>
 requires convertible_to<const _Tp&, _Tp2>
 constexpr
 operator min_max_result<_Tp2>() const &
 { return {min, max}; }

      template<typename _Tp2>
 requires convertible_to<_Tp, _Tp2>
 constexpr
 operator min_max_result<_Tp2>() &&
 { return {std::move(min), std::move(max)}; }
    };

  template<typename _Tp>
    using minmax_result = min_max_result<_Tp>;

  struct __minmax_fn
  {
    template<typename _Tp, typename _Proj = identity,
      indirect_strict_weak_order<projected<const _Tp*, _Proj>>
        _Comp = ranges::less>
      constexpr minmax_result<const _Tp&>
      operator()(const _Tp& __a, const _Tp& __b,
   _Comp __comp = {}, _Proj __proj = {}) const
      {
 if (std::__invoke(__comp,
     std::__invoke(__proj, __b),
     std::__invoke(__proj, __a)))
   return {__b, __a};
 else
   return {__a, __b};
      }

    template<input_range _Range, typename _Proj = identity,
      indirect_strict_weak_order<projected<iterator_t<_Range>, _Proj>>
        _Comp = ranges::less>
      requires indirectly_copyable_storable<iterator_t<_Range>, range_value_t<_Range>*>
      constexpr minmax_result<range_value_t<_Range>>
      operator()(_Range&& __r, _Comp __comp = {}, _Proj __proj = {}) const
      {
 auto __first = ranges::begin(__r);
 auto __last = ranges::end(__r);
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__first != __last), false)) std::__glibcxx_assert_fail(); } while (false);
 auto __comp_proj = __detail::__make_comp_proj(__comp, __proj);
 minmax_result<range_value_t<_Range>> __result = {*__first, __result.min};
 if (++__first == __last)
   return __result;
 else
   {


     auto&& __val = *__first;
     if (__comp_proj(__val, __result.min))
       __result.min = std::forward<decltype(__val)>(__val);
     else
       __result.max = std::forward<decltype(__val)>(__val);
   }
 while (++__first != __last)
   {



     range_value_t<_Range> __val1 = *__first;
     if (++__first == __last)
       {



  if (__comp_proj(__val1, __result.min))
    __result.min = std::move(__val1);
  else if (!__comp_proj(__val1, __result.max))
    __result.max = std::move(__val1);
  break;
       }
     auto&& __val2 = *__first;
     if (!__comp_proj(__val2, __val1))
       {
  if (__comp_proj(__val1, __result.min))
    __result.min = std::move(__val1);
  if (!__comp_proj(__val2, __result.max))
    __result.max = std::forward<decltype(__val2)>(__val2);
       }
     else
       {
  if (__comp_proj(__val2, __result.min))
    __result.min = std::forward<decltype(__val2)>(__val2);
  if (!__comp_proj(__val1, __result.max))
    __result.max = std::move(__val1);
       }
   }
 return __result;
      }

    template<copyable _Tp, typename _Proj = identity,
      indirect_strict_weak_order<projected<const _Tp*, _Proj>>
        _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<forward_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Proj = identity,
      indirect_strict_weak_order<projected<_Iter, _Proj>>
        _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<forward_range _Range, typename _Proj = identity,
      indirect_strict_weak_order<projected<iterator_t<_Range>, _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<forward_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Proj = identity,
      indirect_strict_weak_order<projected<_Iter, _Proj>>
        _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<forward_range _Range, typename _Proj = identity,
      indirect_strict_weak_order<projected<iterator_t<_Range>, _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<typename _Iter>
    using minmax_element_result = min_max_result<_Iter>;

  struct __minmax_element_fn
  {
    template<forward_iterator _Iter, sentinel_for<_Iter> _Sent,
      typename _Proj = identity,
      indirect_strict_weak_order<projected<_Iter, _Proj>>
        _Comp = ranges::less>
      constexpr minmax_element_result<_Iter>
      operator()(_Iter __first, _Sent __last,
   _Comp __comp = {}, _Proj __proj = {}) const
      {
 auto __comp_proj = __detail::__make_comp_proj(__comp, __proj);
 minmax_element_result<_Iter> __result = {__first, __first};
 if (__first == __last || ++__first == __last)
   return __result;
 else
   {


     if (__comp_proj(*__first, *__result.min))
       __result.min = __first;
     else
       __result.max = __first;
   }
 while (++__first != __last)
   {



     auto __prev = __first;
     if (++__first == __last)
       {



  if (__comp_proj(*__prev, *__result.min))
    __result.min = __prev;
  else if (!__comp_proj(*__prev, *__result.max))
    __result.max = __prev;
  break;
       }
     if (!__comp_proj(*__first, *__prev))
       {
  if (__comp_proj(*__prev, *__result.min))
    __result.min = __prev;
  if (!__comp_proj(*__first, *__result.max))
    __result.max = __first;
       }
     else
       {
  if (__comp_proj(*__first, *__result.min))
    __result.min = __first;
  if (!__comp_proj(*__prev, *__result.max))
    __result.max = __prev;
       }
   }
 return __result;
      }

    template<forward_range _Range, typename _Proj = identity,
      indirect_strict_weak_order<projected<iterator_t<_Range>, _Proj>>
        _Comp = ranges::less>
      constexpr minmax_element_result<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 __minmax_element_fn minmax_element{};

  struct __lexicographical_compare_fn
  {
    template<input_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
      input_iterator _Iter2, sentinel_for<_Iter2> _Sent2,
      typename _Proj1 = identity, typename _Proj2 = identity,
      indirect_strict_weak_order<projected<_Iter1, _Proj1>,
     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<input_range _Range1, input_range _Range2,
      typename _Proj1 = identity, typename _Proj2 = identity,
      indirect_strict_weak_order<projected<iterator_t<_Range1>, _Proj1>,
     projected<iterator_t<_Range2>, _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<typename _Iter, typename _Ref = iter_reference_t<_Iter>>
      static constexpr bool __ptr_to_nonvolatile
 = is_pointer_v<_Iter> && !is_volatile_v<remove_reference_t<_Ref>>;
  };

  inline constexpr __lexicographical_compare_fn lexicographical_compare;

  template<typename _Iter>
    struct in_found_result
    {
      [[no_unique_address]] _Iter in;
      bool found;

      template<typename _Iter2>
 requires convertible_to<const _Iter&, _Iter2>
 constexpr
 operator in_found_result<_Iter2>() const &
 { return {in, found}; }

      template<typename _Iter2>
 requires convertible_to<_Iter, _Iter2>
 constexpr
 operator in_found_result<_Iter2>() &&
 { return {std::move(in), found}; }
    };

  template<typename _Iter>
    using next_permutation_result = in_found_result<_Iter>;

  struct __next_permutation_fn
  {
    template<bidirectional_iterator _Iter, sentinel_for<_Iter> _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<bidirectional_range _Range, typename _Comp = ranges::less,
      typename _Proj = identity>
      requires sortable<iterator_t<_Range>, _Comp, _Proj>
      constexpr next_permutation_result<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 __next_permutation_fn next_permutation{};

  template<typename _Iter>
    using prev_permutation_result = in_found_result<_Iter>;

  struct __prev_permutation_fn
  {
    template<bidirectional_iterator _Iter, sentinel_for<_Iter> _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<bidirectional_range _Range, typename _Comp = ranges::less,
      typename _Proj = identity>
      requires sortable<iterator_t<_Range>, _Comp, _Proj>
      constexpr prev_permutation_result<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 __prev_permutation_fn prev_permutation{};


  struct __contains_fn
  {
    template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
     typename _Tp, typename _Proj = identity>
      requires indirect_binary_predicate<ranges::equal_to,
      projected<_Iter, _Proj>, const _Tp*>
      constexpr bool
      operator()(_Iter __first, _Sent __last, const _Tp& __value, _Proj __proj = {}) const
      { return ranges::find(std::move(__first), __last, __value, std::move(__proj)) != __last; }

    template<input_range _Range, typename _Tp, typename _Proj = identity>
      requires indirect_binary_predicate<ranges::equal_to,
      projected<iterator_t<_Range>, _Proj>, const _Tp*>
      constexpr bool
      operator()(_Range&& __r, const _Tp& __value, _Proj __proj = {}) const
      { return (*this)(ranges::begin(__r), ranges::end(__r), __value, std::move(__proj)); }
  };

  inline constexpr __contains_fn contains{};

  struct __contains_subrange_fn
  {
    template<forward_iterator _Iter1, sentinel_for<_Iter1> _Sent1,
      forward_iterator _Iter2, sentinel_for<_Iter2> _Sent2,
      typename _Pred = ranges::equal_to,
      typename _Proj1 = identity, typename _Proj2 = identity>
      requires indirectly_comparable<_Iter1, _Iter2, _Pred, _Proj1, _Proj2>
      constexpr bool
      operator()(_Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2,
   _Pred __pred = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
      {
 return __first2 == __last2
   || !ranges::search(__first1, __last1, __first2, __last2,
        std::move(__pred), std::move(__proj1), std::move(__proj2)).empty();
      }

    template<forward_range _Range1, forward_range _Range2,
      typename _Pred = ranges::equal_to,
      typename _Proj1 = identity, typename _Proj2 = identity>
      requires indirectly_comparable<iterator_t<_Range1>, iterator_t<_Range2>,
         _Pred, _Proj1, _Proj2>
      constexpr 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 __contains_subrange_fn contains_subrange{};





  template<typename _Out, typename _Tp>
    struct out_value_result
    {
      [[no_unique_address]] _Out out;
      [[no_unique_address]] _Tp value;

      template<typename _Out2, typename _Tp2>
 requires convertible_to<const _Out&, _Out2>
   && convertible_to<const _Tp&, _Tp2>
 constexpr
 operator out_value_result<_Out2, _Tp2>() const &
 { return {out, value}; }

      template<typename _Out2, typename _Tp2>
 requires convertible_to<_Out, _Out2>
   && convertible_to<_Tp, _Tp2>
 constexpr
 operator out_value_result<_Out2, _Tp2>() &&
 { return {std::move(out), std::move(value)}; }
    };

  template<typename _Out, typename _Tp>
    using iota_result = out_value_result<_Out, _Tp>;

  struct __iota_fn
  {
    template<input_or_output_iterator _Out, sentinel_for<_Out> _Sent, weakly_incrementable _Tp>
      requires indirectly_writable<_Out, const _Tp&>
      constexpr iota_result<_Out, _Tp>
      operator()(_Out __first, _Sent __last, _Tp __value) const
      {
 while (__first != __last)
   {
     *__first = static_cast<const _Tp&>(__value);
     ++__first;
     ++__value;
   }
 return {std::move(__first), std::move(__value)};
      }

    template<weakly_incrementable _Tp, output_range<const _Tp&> _Range>
      constexpr iota_result<borrowed_iterator_t<_Range>, _Tp>
      operator()(_Range&& __r, _Tp __value) const
      { return (*this)(ranges::begin(__r), ranges::end(__r), std::move(__value)); }
  };

  inline constexpr __iota_fn iota{};





  struct __find_last_fn
  {
    template<forward_iterator _Iter, sentinel_for<_Iter> _Sent, typename _Tp, typename _Proj = identity>
      requires indirect_binary_predicate<ranges::equal_to, projected<_Iter, _Proj>, const _Tp*>
      constexpr subrange<_Iter>
      operator()(_Iter __first, _Sent __last, const _Tp& __value, _Proj __proj = {}) const
      {
 if constexpr (same_as<_Iter, _Sent> && bidirectional_iterator<_Iter>)
   {
     _Iter __found = ranges::find(reverse_iterator<_Iter>{__last},
      reverse_iterator<_Iter>{__first},
      __value, std::move(__proj)).base();
     if (__found == __first)
       return {__last, __last};
     else
       return {ranges::prev(__found), __last};
   }
 else
   {
     _Iter __found = ranges::find(__first, __last, __value, __proj);
     if (__found == __last)
       return {__found, __found};
     __first = __found;
     for (;;)
       {
  __first = ranges::find(ranges::next(__first), __last, __value, __proj);
  if (__first == __last)
    return {__found, __first};
  __found = __first;
       }
   }
      }

    template<forward_range _Range, typename _Tp, typename _Proj = identity>
      requires indirect_binary_predicate<ranges::equal_to, projected<iterator_t<_Range>, _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 __find_last_fn find_last{};

  struct __find_last_if_fn
  {
    template<forward_iterator _Iter, sentinel_for<_Iter> _Sent, typename _Proj = identity,
      indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
      constexpr subrange<_Iter>
      operator()(_Iter __first, _Sent __last, _Pred __pred, _Proj __proj = {}) const
      {
 if constexpr (same_as<_Iter, _Sent> && bidirectional_iterator<_Iter>)
   {
     _Iter __found = ranges::find_if(reverse_iterator<_Iter>{__last},
         reverse_iterator<_Iter>{__first},
         std::move(__pred), std::move(__proj)).base();
     if (__found == __first)
       return {__last, __last};
     else
       return {ranges::prev(__found), __last};
   }
 else
   {
     _Iter __found = ranges::find_if(__first, __last, __pred, __proj);
     if (__found == __last)
       return {__found, __found};
     __first = __found;
     for (;;)
       {
  __first = ranges::find_if(ranges::next(__first), __last, __pred, __proj);
  if (__first == __last)
    return {__found, __first};
  __found = __first;
       }
   }
      }

    template<forward_range _Range, typename _Proj = identity,
      indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>> _Pred>
      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 __find_last_if_fn find_last_if{};

  struct __find_last_if_not_fn
  {
    template<forward_iterator _Iter, sentinel_for<_Iter> _Sent, typename _Proj = identity,
      indirect_unary_predicate<projected<_Iter, _Proj>> _Pred>
      constexpr subrange<_Iter>
      operator()(_Iter __first, _Sent __last, _Pred __pred, _Proj __proj = {}) const
      {
 if constexpr (same_as<_Iter, _Sent> && bidirectional_iterator<_Iter>)
   {
     _Iter __found = ranges::find_if_not(reverse_iterator<_Iter>{__last},
      reverse_iterator<_Iter>{__first},
      std::move(__pred), std::move(__proj)).base();
     if (__found == __first)
       return {__last, __last};
     else
       return {ranges::prev(__found), __last};
   }
 else
   {
     _Iter __found = ranges::find_if_not(__first, __last, __pred, __proj);
     if (__found == __last)
       return {__found, __found};
     __first = __found;
     for (;;)
       {
  __first = ranges::find_if_not(ranges::next(__first), __last, __pred, __proj);
  if (__first == __last)
    return {__found, __first};
  __found = __first;
       }
   }
      }

    template<forward_range _Range, typename _Proj = identity,
      indirect_unary_predicate<projected<iterator_t<_Range>, _Proj>> _Pred>
      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 __find_last_if_not_fn find_last_if_not{};





  template<typename _Iter, typename _Tp>
    struct in_value_result
    {
      [[no_unique_address]] _Iter in;
      [[no_unique_address]] _Tp value;

      template<typename _Iter2, typename _Tp2>
 requires convertible_to<const _Iter&, _Iter2>
   && convertible_to<const _Tp&, _Tp2>
      constexpr
      operator in_value_result<_Iter2, _Tp2>() const &
      { return {in, value}; }

      template<typename _Iter2, typename _Tp2>
 requires convertible_to<_Iter, _Iter2>
   && convertible_to<_Tp, _Tp2>
      constexpr
      operator in_value_result<_Iter2, _Tp2>() &&
      { return {std::move(in), std::move(value)}; }
    };

  namespace __detail
  {
    template<typename _Fp>
      class __flipped
      {
 _Fp _M_f;

      public:
 template<typename _Tp, typename _Up>
   requires invocable<_Fp&, _Up, _Tp>
 invoke_result_t<_Fp&, _Up, _Tp>
 operator()(_Tp&&, _Up&&);
      };

      template<typename _Fp, typename _Tp, typename _Iter, typename _Up>
      concept __indirectly_binary_left_foldable_impl = movable<_Tp> && movable<_Up>
 && convertible_to<_Tp, _Up>
 && invocable<_Fp&, _Up, iter_reference_t<_Iter>>
 && assignable_from<_Up&, invoke_result_t<_Fp&, _Up, iter_reference_t<_Iter>>>;

      template<typename _Fp, typename _Tp, typename _Iter>
      concept __indirectly_binary_left_foldable = copy_constructible<_Fp>
 && indirectly_readable<_Iter>
 && invocable<_Fp&, _Tp, iter_reference_t<_Iter>>
 && convertible_to<invoke_result_t<_Fp&, _Tp, iter_reference_t<_Iter>>,
     decay_t<invoke_result_t<_Fp&, _Tp, iter_reference_t<_Iter>>>>
 && __indirectly_binary_left_foldable_impl
     <_Fp, _Tp, _Iter, decay_t<invoke_result_t<_Fp&, _Tp, iter_reference_t<_Iter>>>>;

      template <typename _Fp, typename _Tp, typename _Iter>
      concept __indirectly_binary_right_foldable
 = __indirectly_binary_left_foldable<__flipped<_Fp>, _Tp, _Iter>;
  }

  template<typename _Iter, typename _Tp>
    using fold_left_with_iter_result = in_value_result<_Iter, _Tp>;

  struct __fold_left_with_iter_fn
  {
    template<typename _Ret_iter,
      typename _Iter, typename _Sent, typename _Tp, typename _Fp>
      static constexpr auto
      _S_impl(_Iter __first, _Sent __last, _Tp __init, _Fp __f)
      {
 using _Up = decay_t<invoke_result_t<_Fp&, _Tp, iter_reference_t<_Iter>>>;
 using _Ret = fold_left_with_iter_result<_Ret_iter, _Up>;

 if (__first == __last)
   return _Ret{std::move(__first), _Up(std::move(__init))};

 _Up __accum = std::__invoke(__f, std::move(__init), *__first);
 for (++__first; __first != __last; ++__first)
   __accum = std::__invoke(__f, std::move(__accum), *__first);
 return _Ret{std::move(__first), std::move(__accum)};
      }

    template<input_iterator _Iter, sentinel_for<_Iter> _Sent, typename _Tp,
      __detail::__indirectly_binary_left_foldable<_Tp, _Iter> _Fp>
      constexpr auto
      operator()(_Iter __first, _Sent __last, _Tp __init, _Fp __f) const
      {
 using _Ret_iter = _Iter;
 return _S_impl<_Ret_iter>(std::move(__first), __last,
      std::move(__init), std::move(__f));
      }

    template<input_range _Range, typename _Tp,
      __detail::__indirectly_binary_left_foldable<_Tp, iterator_t<_Range>> _Fp>
      constexpr auto
      operator()(_Range&& __r, _Tp __init, _Fp __f) const
      {
 using _Ret_iter = borrowed_iterator_t<_Range>;
 return _S_impl<_Ret_iter>(ranges::begin(__r), ranges::end(__r),
      std::move(__init), std::move(__f));
      }
  };

  inline constexpr __fold_left_with_iter_fn fold_left_with_iter{};

  struct __fold_left_fn
  {
    template<input_iterator _Iter, sentinel_for<_Iter> _Sent, typename _Tp,
      __detail::__indirectly_binary_left_foldable<_Tp, _Iter> _Fp>
      constexpr auto
      operator()(_Iter __first, _Sent __last, _Tp __init, _Fp __f) const
      {
 return ranges::fold_left_with_iter(std::move(__first), __last,
        std::move(__init), std::move(__f)).value;
      }

    template<input_range _Range, typename _Tp,
      __detail::__indirectly_binary_left_foldable<_Tp, iterator_t<_Range>> _Fp>
      constexpr auto
      operator()(_Range&& __r, _Tp __init, _Fp __f) const
      { return (*this)(ranges::begin(__r), ranges::end(__r), std::move(__init), std::move(__f)); }
  };

  inline constexpr __fold_left_fn fold_left{};

  template<typename _Iter, typename _Tp>
    using fold_left_first_with_iter_result = in_value_result<_Iter, _Tp>;

  struct __fold_left_first_with_iter_fn
  {
    template<typename _Ret_iter, typename _Iter, typename _Sent, typename _Fp>
      static constexpr auto
      _S_impl(_Iter __first, _Sent __last, _Fp __f)
      {
 using _Up = decltype(ranges::fold_left(std::move(__first), __last,
            iter_value_t<_Iter>(*__first), __f));
 using _Ret = fold_left_first_with_iter_result<_Ret_iter, optional<_Up>>;

 if (__first == __last)
   return _Ret{std::move(__first), optional<_Up>()};

 optional<_Up> __init(in_place, *__first);
 for (++__first; __first != __last; ++__first)
   *__init = std::__invoke(__f, std::move(*__init), *__first);
 return _Ret{std::move(__first), std::move(__init)};
      }

    template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
      __detail::__indirectly_binary_left_foldable<iter_value_t<_Iter>, _Iter> _Fp>
      requires constructible_from<iter_value_t<_Iter>, iter_reference_t<_Iter>>
      constexpr auto
      operator()(_Iter __first, _Sent __last, _Fp __f) const
      {
 using _Ret_iter = _Iter;
 return _S_impl<_Ret_iter>(std::move(__first), __last, std::move(__f));
      }

    template<input_range _Range,
      __detail::__indirectly_binary_left_foldable<range_value_t<_Range>, iterator_t<_Range>> _Fp>
      requires constructible_from<range_value_t<_Range>, range_reference_t<_Range>>
      constexpr auto
      operator()(_Range&& __r, _Fp __f) const
      {
 using _Ret_iter = borrowed_iterator_t<_Range>;
 return _S_impl<_Ret_iter>(ranges::begin(__r), ranges::end(__r), std::move(__f));
      }
  };

  inline constexpr __fold_left_first_with_iter_fn fold_left_first_with_iter{};

  struct __fold_left_first_fn
  {
    template<input_iterator _Iter, sentinel_for<_Iter> _Sent,
      __detail::__indirectly_binary_left_foldable<iter_value_t<_Iter>, _Iter> _Fp>
      requires constructible_from<iter_value_t<_Iter>, iter_reference_t<_Iter>>
      constexpr auto
      operator()(_Iter __first, _Sent __last, _Fp __f) const
      {
 return ranges::fold_left_first_with_iter(std::move(__first), __last,
       std::move(__f)).value;
      }

    template<input_range _Range,
      __detail::__indirectly_binary_left_foldable<range_value_t<_Range>, iterator_t<_Range>> _Fp>
      requires constructible_from<range_value_t<_Range>, range_reference_t<_Range>>
      constexpr auto
      operator()(_Range&& __r, _Fp __f) const
      { return (*this)(ranges::begin(__r), ranges::end(__r), std::move(__f)); }
  };

  inline constexpr __fold_left_first_fn fold_left_first{};

  struct __fold_right_fn
  {
    template<bidirectional_iterator _Iter, sentinel_for<_Iter> _Sent, typename _Tp,
      __detail::__indirectly_binary_right_foldable<_Tp, _Iter> _Fp>
      constexpr auto
      operator()(_Iter __first, _Sent __last, _Tp __init, _Fp __f) const
      {
 using _Up = decay_t<invoke_result_t<_Fp&, iter_reference_t<_Iter>, _Tp>>;

 if (__first == __last)
   return _Up(std::move(__init));

 _Iter __tail = ranges::next(__first, __last);
 _Up __accum = std::__invoke(__f, *--__tail, std::move(__init));
 while (__first != __tail)
   __accum = std::__invoke(__f, *--__tail, std::move(__accum));
 return __accum;
      }

    template<bidirectional_range _Range, typename _Tp,
      __detail::__indirectly_binary_right_foldable<_Tp, iterator_t<_Range>> _Fp>
      constexpr auto
      operator()(_Range&& __r, _Tp __init, _Fp __f) const
      { return (*this)(ranges::begin(__r), ranges::end(__r), std::move(__init), std::move(__f)); }
  };

  inline constexpr __fold_right_fn fold_right{};

  struct __fold_right_last_fn
  {
    template<bidirectional_iterator _Iter, sentinel_for<_Iter> _Sent,
      __detail::__indirectly_binary_right_foldable<iter_value_t<_Iter>, _Iter> _Fp>
      requires constructible_from<iter_value_t<_Iter>, iter_reference_t<_Iter>>
      constexpr auto
      operator()(_Iter __first, _Sent __last, _Fp __f) const
      {
 using _Up = decltype(ranges::fold_right(__first, __last,
      iter_value_t<_Iter>(*__first), __f));

 if (__first == __last)
   return optional<_Up>();

 _Iter __tail = ranges::prev(ranges::next(__first, std::move(__last)));
 return optional<_Up>(in_place,
        ranges::fold_right(std::move(__first), __tail,
      iter_value_t<_Iter>(*__tail),
      std::move(__f)));
      }

    template<bidirectional_range _Range,
      __detail::__indirectly_binary_right_foldable<range_value_t<_Range>, iterator_t<_Range>> _Fp>
      requires constructible_from<range_value_t<_Range>, range_reference_t<_Range>>
      constexpr auto
      operator()(_Range&& __r, _Fp __f) const
      { return (*this)(ranges::begin(__r), ranges::end(__r), std::move(__f)); }
  };

  inline constexpr __fold_right_last_fn fold_right_last{};

}

  template<typename _ForwardIterator>
    constexpr _ForwardIterator
    shift_left(_ForwardIterator __first, _ForwardIterator __last,
        typename iterator_traits<_ForwardIterator>::difference_type __n)
    {
      do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__n >= 0), false)) std::__glibcxx_assert_fail(); } while (false);
      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<typename _ForwardIterator>
    constexpr _ForwardIterator
    shift_right(_ForwardIterator __first, _ForwardIterator __last,
  typename iterator_traits<_ForwardIterator>::difference_type __n)
    {
      do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__n >= 0), false)) std::__glibcxx_assert_fail(); } while (false);
      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), __result);
    return __result;
  }
       ++__dest_head;
       ++__dest_tail;
     }

   for (;;)
     {
# 4024 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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;
  }
     }
 }
    }


}
# 64 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/algorithm" 2 3
# 76 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/algorithm" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 77 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/algorithm" 2 3








# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/pstl/glue_algorithm_defs.h" 1 3
# 17 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/pstl/glue_algorithm_defs.h" 3
namespace std
{



template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
any_of(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred);



template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
all_of(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred);



template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
none_of(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred);



template <class _ExecutionPolicy, class _ForwardIterator, class _Function>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
for_each(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Function __f);

template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Function>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
for_each_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n, _Function __f);



template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
find_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred);

template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
find_if_not(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred);

template <class _ExecutionPolicy, class _ForwardIterator, class _Tp>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
find(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value);



template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
find_end(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
         _ForwardIterator2 __s_last, _BinaryPredicate __pred);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
find_end(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
         _ForwardIterator2 __s_last);



template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
find_first_of(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
              _ForwardIterator2 __s_first, _ForwardIterator2 __s_last, _BinaryPredicate __pred);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
find_first_of(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
              _ForwardIterator2 __s_first, _ForwardIterator2 __s_last);



template <class _ExecutionPolicy, class _ForwardIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
adjacent_find(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);

template <class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
adjacent_find(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred);



template <class _ExecutionPolicy, class _ForwardIterator, class _Tp>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy,
                                                 typename iterator_traits<_ForwardIterator>::difference_type>
count(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value);

template <class _ExecutionPolicy, class _ForwardIterator, class _Predicate>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy,
                                                 typename iterator_traits<_ForwardIterator>::difference_type>
count_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred);



template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
search(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
       _ForwardIterator2 __s_last, _BinaryPredicate __pred);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator1>
search(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __s_first,
       _ForwardIterator2 __s_last);

template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Tp, class _BinaryPredicate>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
search_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Size __count,
         const _Tp& __value, _BinaryPredicate __pred);

template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Tp>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
search_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Size __count,
         const _Tp& __value);



template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result);

template <class _ExecutionPolicy, class _ForwardIterator1, class _Size, class _ForwardIterator2>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
copy_n(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _Size __n, _ForwardIterator2 __result);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Predicate>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
copy_if(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 result,
        _Predicate __pred);



template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
swap_ranges(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
            _ForwardIterator2 __first2);



template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _UnaryOperation>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
transform(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result,
          _UnaryOperation __op);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator,
          class _BinaryOperation>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
transform(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
          _ForwardIterator __result, _BinaryOperation __op);



template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate, class _Tp>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
replace_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred,
           const _Tp& __new_value);

template <class _ExecutionPolicy, class _ForwardIterator, class _Tp>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
replace(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __old_value,
        const _Tp& __new_value);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _UnaryPredicate, class _Tp>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
replace_copy_if(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
                _ForwardIterator2 __result, _UnaryPredicate __pred, const _Tp& __new_value);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
replace_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result,
             const _Tp& __old_value, const _Tp& __new_value);



template <class _ExecutionPolicy, class _ForwardIterator, class _Tp>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
fill(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value);

template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Tp>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
fill_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __count, const _Tp& __value);


template <class _ExecutionPolicy, class _ForwardIterator, class _Generator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
generate(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Generator __g);

template <class _ExecutionPolicy, class _ForwardIterator, class _Size, class _Generator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
generate_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size count, _Generator __g);



template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Predicate>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
remove_copy_if(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
               _ForwardIterator2 __result, _Predicate __pred);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
remove_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result,
            const _Tp& __value);

template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
remove_if(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred);

template <class _ExecutionPolicy, class _ForwardIterator, class _Tp>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
remove(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value);



template <class _ExecutionPolicy, class _ForwardIterator, class _BinaryPredicate>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
unique(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred);

template <class _ExecutionPolicy, class _ForwardIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
unique(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
unique_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result,
            _BinaryPredicate __pred);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
unique_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __result);



template <class _ExecutionPolicy, class _BidirectionalIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
reverse(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last);

template <class _ExecutionPolicy, class _BidirectionalIterator, class _ForwardIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
reverse_copy(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last,
             _ForwardIterator __d_first);



template <class _ExecutionPolicy, class _ForwardIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
rotate(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
rotate_copy(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __middle, _ForwardIterator1 __last,
            _ForwardIterator2 __result);



template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
is_partitioned(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred);

template <class _ExecutionPolicy, class _ForwardIterator, class _UnaryPredicate>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
partition(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _UnaryPredicate __pred);

template <class _ExecutionPolicy, class _BidirectionalIterator, class _UnaryPredicate>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _BidirectionalIterator>
stable_partition(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __last,
                 _UnaryPredicate __pred);

template <class _ExecutionPolicy, class _ForwardIterator, class _ForwardIterator1, class _ForwardIterator2,
          class _UnaryPredicate>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>>
partition_copy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last,
               _ForwardIterator1 __out_true, _ForwardIterator2 __out_false, _UnaryPredicate __pred);



template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp);

template <class _ExecutionPolicy, class _RandomAccessIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last);



template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
stable_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp);

template <class _ExecutionPolicy, class _RandomAccessIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
stable_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last);



template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>>
mismatch(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
         _ForwardIterator2 __last2, _BinaryPredicate __pred);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>>
mismatch(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
         _BinaryPredicate __pred);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>>
mismatch(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
         _ForwardIterator2 __last2);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator1, _ForwardIterator2>>
mismatch(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2);



template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
      _BinaryPredicate __p);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
      _ForwardIterator2 __last2, _BinaryPredicate __p);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
equal(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
      _ForwardIterator2 __last2);


template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
move(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last, _ForwardIterator2 __d_first);



template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
partial_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __middle,
             _RandomAccessIterator __last, _Compare __comp);

template <class _ExecutionPolicy, class _RandomAccessIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
partial_sort(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __middle,
             _RandomAccessIterator __last);



template <class _ExecutionPolicy, class _ForwardIterator, class _RandomAccessIterator, class _Compare>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator>
partial_sort_copy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last,
                  _RandomAccessIterator __d_first, _RandomAccessIterator __d_last, _Compare __comp);

template <class _ExecutionPolicy, class _ForwardIterator, class _RandomAccessIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator>
partial_sort_copy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last,
                  _RandomAccessIterator __d_first, _RandomAccessIterator __d_last);


template <class _ExecutionPolicy, class _ForwardIterator, class _Compare>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
is_sorted_until(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp);

template <class _ExecutionPolicy, class _ForwardIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
is_sorted_until(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);

template <class _ExecutionPolicy, class _ForwardIterator, class _Compare>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
is_sorted(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp);

template <class _ExecutionPolicy, class _ForwardIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
is_sorted(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);



template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
nth_element(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __nth,
            _RandomAccessIterator __last, _Compare __comp);

template <class _ExecutionPolicy, class _RandomAccessIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
nth_element(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __nth,
            _RandomAccessIterator __last);


template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator,
          class _Compare>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
merge(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
      _ForwardIterator2 __last2, _ForwardIterator __d_first, _Compare __comp);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
merge(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
      _ForwardIterator2 __last2, _ForwardIterator __d_first);

template <class _ExecutionPolicy, class _BidirectionalIterator, class _Compare>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
inplace_merge(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __middle,
              _BidirectionalIterator __last, _Compare __comp);

template <class _ExecutionPolicy, class _BidirectionalIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void>
inplace_merge(_ExecutionPolicy&& __exec, _BidirectionalIterator __first, _BidirectionalIterator __middle,
              _BidirectionalIterator __last);



template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
includes(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
         _ForwardIterator2 __last2, _Compare __comp);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
includes(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
         _ForwardIterator2 __last2);



template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator,
          class _Compare>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
set_union(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
          _ForwardIterator2 __last2, _ForwardIterator __result, _Compare __comp);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
set_union(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2,
          _ForwardIterator2 __last2, _ForwardIterator __result);



template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator,
          class _Compare>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
set_intersection(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
                 _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result, _Compare __comp);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
set_intersection(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
                 _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result);



template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator,
          class _Compare>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
set_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
               _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result, _Compare __comp);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
set_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
               _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result);



template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator,
          class _Compare>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
set_symmetric_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
                         _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator result,
                         _Compare __comp);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _ForwardIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
set_symmetric_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
                         _ForwardIterator2 __first2, _ForwardIterator2 __last2, _ForwardIterator __result);


template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator>
is_heap_until(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp);

template <class _ExecutionPolicy, class _RandomAccessIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _RandomAccessIterator>
is_heap_until(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last);

template <class _ExecutionPolicy, class _RandomAccessIterator, class _Compare>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
is_heap(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp);

template <class _ExecutionPolicy, class _RandomAccessIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
is_heap(_ExecutionPolicy&& __exec, _RandomAccessIterator __first, _RandomAccessIterator __last);



template <class _ExecutionPolicy, class _ForwardIterator, class _Compare>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
min_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp);

template <class _ExecutionPolicy, class _ForwardIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
min_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);

template <class _ExecutionPolicy, class _ForwardIterator, class _Compare>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
max_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp);

template <class _ExecutionPolicy, class _ForwardIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator>
max_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);

template <class _ExecutionPolicy, class _ForwardIterator, class _Compare>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator, _ForwardIterator>>
minmax_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Compare __comp);

template <class _ExecutionPolicy, class _ForwardIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, std::pair<_ForwardIterator, _ForwardIterator>>
minmax_element(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);



template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Compare>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
lexicographical_compare(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
                        _ForwardIterator2 __first2, _ForwardIterator2 __last2, _Compare __comp);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, bool>
lexicographical_compare(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
                        _ForwardIterator2 __first2, _ForwardIterator2 __last2);

}
# 86 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/algorithm" 2 3
# 27 "/home/avi/scylla-maint/seastar/include/seastar/core/sstring.hh" 2
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 1 3
# 42 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 3


# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 45 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 2 3
# 28 "/home/avi/scylla-maint/seastar/include/seastar/core/sstring.hh" 2






# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 1 3
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 3


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 43 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 2 3
# 35 "/home/avi/scylla-maint/seastar/include/seastar/core/sstring.hh" 2





# 1 "/usr/include/fmt/format.h" 1 3 4
# 36 "/usr/include/fmt/format.h" 3 4
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cmath" 1 3 4
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cmath" 3







# 1 "/usr/include/math.h" 1 3 4
# 27 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/libc-header-start.h" 1 3 4
# 28 "/usr/include/math.h" 2 3 4






extern "C" {





# 1 "/usr/include/bits/math-vector.h" 1 3 4
# 25 "/usr/include/bits/math-vector.h" 3 4
# 1 "/usr/include/bits/libm-simd-decl-stubs.h" 1 3 4
# 26 "/usr/include/bits/math-vector.h" 2 3 4
# 41 "/usr/include/math.h" 2 3 4
# 152 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/flt-eval-method.h" 1 3 4
# 153 "/usr/include/math.h" 2 3 4
# 163 "/usr/include/math.h" 3 4
typedef float float_t;
typedef double double_t;
# 204 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/fp-logb.h" 1 3 4
# 205 "/usr/include/math.h" 2 3 4
# 247 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/fp-fast.h" 1 3 4
# 248 "/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,
  };
# 312 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls-helper-functions.h" 1 3 4
# 20 "/usr/include/bits/mathcalls-helper-functions.h" 3 4
extern int __fpclassify (double __value) noexcept (true)
     __attribute__ ((__const__));


extern int __signbit (double __value) noexcept (true)
     __attribute__ ((__const__));



extern int __isinf (double __value) noexcept (true)
  __attribute__ ((__const__));


extern int __finite (double __value) noexcept (true)
  __attribute__ ((__const__));


extern int __isnan (double __value) noexcept (true)
  __attribute__ ((__const__));


extern int __iseqsig (double __x, double __y) noexcept (true);


extern int __issignaling (double __value) noexcept (true)
     __attribute__ ((__const__));
# 313 "/usr/include/math.h" 2 3 4
# 1 "/usr/include/bits/mathcalls.h" 1 3 4
# 53 "/usr/include/bits/mathcalls.h" 3 4
 extern double acos (double __x) noexcept (true); extern double __acos (double __x) noexcept (true);

 extern double asin (double __x) noexcept (true); extern double __asin (double __x) noexcept (true);

 extern double atan (double __x) noexcept (true); extern double __atan (double __x) noexcept (true);

 extern double atan2 (double __y, double __x) noexcept (true); extern double __atan2 (double __y, double __x) noexcept (true);


 extern double cos (double __x) noexcept (true); extern double __cos (double __x) noexcept (true);

 extern double sin (double __x) noexcept (true); extern double __sin (double __x) noexcept (true);

 extern double tan (double __x) noexcept (true); extern double __tan (double __x) noexcept (true);




 extern double cosh (double __x) noexcept (true); extern double __cosh (double __x) noexcept (true);

 extern double sinh (double __x) noexcept (true); extern double __sinh (double __x) noexcept (true);

 extern double tanh (double __x) noexcept (true); extern double __tanh (double __x) noexcept (true);



 extern void sincos (double __x, double *__sinx, double *__cosx) noexcept (true); extern void __sincos (double __x, double *__sinx, double *__cosx) noexcept (true);





 extern double acosh (double __x) noexcept (true); extern double __acosh (double __x) noexcept (true);

 extern double asinh (double __x) noexcept (true); extern double __asinh (double __x) noexcept (true);

 extern double atanh (double __x) noexcept (true); extern double __atanh (double __x) noexcept (true);





 extern double exp (double __x) noexcept (true); extern double __exp (double __x) noexcept (true);


extern double frexp (double __x, int *__exponent) noexcept (true); extern double __frexp (double __x, int *__exponent) noexcept (true);


extern double ldexp (double __x, int __exponent) noexcept (true); extern double __ldexp (double __x, int __exponent) noexcept (true);


 extern double log (double __x) noexcept (true); extern double __log (double __x) noexcept (true);


 extern double log10 (double __x) noexcept (true); extern double __log10 (double __x) noexcept (true);


extern double modf (double __x, double *__iptr) noexcept (true); extern double __modf (double __x, double *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2)));



 extern double exp10 (double __x) noexcept (true); extern double __exp10 (double __x) noexcept (true);




 extern double expm1 (double __x) noexcept (true); extern double __expm1 (double __x) noexcept (true);


 extern double log1p (double __x) noexcept (true); extern double __log1p (double __x) noexcept (true);


extern double logb (double __x) noexcept (true); extern double __logb (double __x) noexcept (true);




 extern double exp2 (double __x) noexcept (true); extern double __exp2 (double __x) noexcept (true);


 extern double log2 (double __x) noexcept (true); extern double __log2 (double __x) noexcept (true);






 extern double pow (double __x, double __y) noexcept (true); extern double __pow (double __x, double __y) noexcept (true);


extern double sqrt (double __x) noexcept (true); extern double __sqrt (double __x) noexcept (true);



 extern double hypot (double __x, double __y) noexcept (true); extern double __hypot (double __x, double __y) noexcept (true);




 extern double cbrt (double __x) noexcept (true); extern double __cbrt (double __x) noexcept (true);






extern double ceil (double __x) noexcept (true) __attribute__ ((__const__)); extern double __ceil (double __x) noexcept (true) __attribute__ ((__const__));


extern double fabs (double __x) noexcept (true) __attribute__ ((__const__)); extern double __fabs (double __x) noexcept (true) __attribute__ ((__const__));


extern double floor (double __x) noexcept (true) __attribute__ ((__const__)); extern double __floor (double __x) noexcept (true) __attribute__ ((__const__));


extern double fmod (double __x, double __y) noexcept (true); extern double __fmod (double __x, double __y) noexcept (true);
# 183 "/usr/include/bits/mathcalls.h" 3 4
extern int finite (double __value) noexcept (true)
  __attribute__ ((__const__));


extern double drem (double __x, double __y) noexcept (true); extern double __drem (double __x, double __y) noexcept (true);



extern double significand (double __x) noexcept (true); extern double __significand (double __x) noexcept (true);






extern double copysign (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __copysign (double __x, double __y) noexcept (true) __attribute__ ((__const__));




extern double nan (const char *__tagb) noexcept (true); extern double __nan (const char *__tagb) noexcept (true);
# 220 "/usr/include/bits/mathcalls.h" 3 4
extern double j0 (double) noexcept (true); extern double __j0 (double) noexcept (true);
extern double j1 (double) noexcept (true); extern double __j1 (double) noexcept (true);
extern double jn (int, double) noexcept (true); extern double __jn (int, double) noexcept (true);
extern double y0 (double) noexcept (true); extern double __y0 (double) noexcept (true);
extern double y1 (double) noexcept (true); extern double __y1 (double) noexcept (true);
extern double yn (int, double) noexcept (true); extern double __yn (int, double) noexcept (true);





 extern double erf (double) noexcept (true); extern double __erf (double) noexcept (true);
 extern double erfc (double) noexcept (true); extern double __erfc (double) noexcept (true);
extern double lgamma (double) noexcept (true); extern double __lgamma (double) noexcept (true);




extern double tgamma (double) noexcept (true); extern double __tgamma (double) noexcept (true);





extern double gamma (double) noexcept (true); extern double __gamma (double) noexcept (true);







extern double lgamma_r (double, int *__signgamp) noexcept (true); extern double __lgamma_r (double, int *__signgamp) noexcept (true);






extern double rint (double __x) noexcept (true); extern double __rint (double __x) noexcept (true);


extern double nextafter (double __x, double __y) noexcept (true); extern double __nextafter (double __x, double __y) noexcept (true);

extern double nexttoward (double __x, long double __y) noexcept (true); extern double __nexttoward (double __x, long double __y) noexcept (true);




extern double nextdown (double __x) noexcept (true); extern double __nextdown (double __x) noexcept (true);

extern double nextup (double __x) noexcept (true); extern double __nextup (double __x) noexcept (true);



extern double remainder (double __x, double __y) noexcept (true); extern double __remainder (double __x, double __y) noexcept (true);



extern double scalbn (double __x, int __n) noexcept (true); extern double __scalbn (double __x, int __n) noexcept (true);



extern int ilogb (double __x) noexcept (true); extern int __ilogb (double __x) noexcept (true);




extern long int llogb (double __x) noexcept (true); extern long int __llogb (double __x) noexcept (true);




extern double scalbln (double __x, long int __n) noexcept (true); extern double __scalbln (double __x, long int __n) noexcept (true);



extern double nearbyint (double __x) noexcept (true); extern double __nearbyint (double __x) noexcept (true);



extern double round (double __x) noexcept (true) __attribute__ ((__const__)); extern double __round (double __x) noexcept (true) __attribute__ ((__const__));



extern double trunc (double __x) noexcept (true) __attribute__ ((__const__)); extern double __trunc (double __x) noexcept (true) __attribute__ ((__const__));




extern double remquo (double __x, double __y, int *__quo) noexcept (true); extern double __remquo (double __x, double __y, int *__quo) noexcept (true);






extern long int lrint (double __x) noexcept (true); extern long int __lrint (double __x) noexcept (true);
__extension__
extern long long int llrint (double __x) noexcept (true); extern long long int __llrint (double __x) noexcept (true);



extern long int lround (double __x) noexcept (true); extern long int __lround (double __x) noexcept (true);
__extension__
extern long long int llround (double __x) noexcept (true); extern long long int __llround (double __x) noexcept (true);



extern double fdim (double __x, double __y) noexcept (true); extern double __fdim (double __x, double __y) noexcept (true);



extern double fmax (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fmax (double __x, double __y) noexcept (true) __attribute__ ((__const__));


extern double fmin (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fmin (double __x, double __y) noexcept (true) __attribute__ ((__const__));



extern double fma (double __x, double __y, double __z) noexcept (true); extern double __fma (double __x, double __y, double __z) noexcept (true);




extern double roundeven (double __x) noexcept (true) __attribute__ ((__const__)); extern double __roundeven (double __x) noexcept (true) __attribute__ ((__const__));



extern __intmax_t fromfp (double __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfp (double __x, int __round, unsigned int __width) noexcept (true);




extern __uintmax_t ufromfp (double __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfp (double __x, int __round, unsigned int __width) noexcept (true);





extern __intmax_t fromfpx (double __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpx (double __x, int __round, unsigned int __width) noexcept (true);





extern __uintmax_t ufromfpx (double __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpx (double __x, int __round, unsigned int __width) noexcept (true);



extern int canonicalize (double *__cx, const double *__x) noexcept (true);






extern double fmaxmag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fmaxmag (double __x, double __y) noexcept (true) __attribute__ ((__const__));


extern double fminmag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fminmag (double __x, double __y) noexcept (true) __attribute__ ((__const__));




extern double fmaximum (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fmaximum (double __x, double __y) noexcept (true) __attribute__ ((__const__));


extern double fminimum (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fminimum (double __x, double __y) noexcept (true) __attribute__ ((__const__));


extern double fmaximum_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fmaximum_num (double __x, double __y) noexcept (true) __attribute__ ((__const__));


extern double fminimum_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fminimum_num (double __x, double __y) noexcept (true) __attribute__ ((__const__));


extern double fmaximum_mag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fmaximum_mag (double __x, double __y) noexcept (true) __attribute__ ((__const__));


extern double fminimum_mag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fminimum_mag (double __x, double __y) noexcept (true) __attribute__ ((__const__));


extern double fmaximum_mag_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fmaximum_mag_num (double __x, double __y) noexcept (true) __attribute__ ((__const__));


extern double fminimum_mag_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fminimum_mag_num (double __x, double __y) noexcept (true) __attribute__ ((__const__));




extern int totalorder (const double *__x, const double *__y) noexcept (true)

     __attribute__ ((__pure__));


extern int totalordermag (const double *__x, const double *__y) noexcept (true)

     __attribute__ ((__pure__));


extern double getpayload (const double *__x) noexcept (true); extern double __getpayload (const double *__x) noexcept (true);


extern int setpayload (double *__x, double __payload) noexcept (true);


extern int setpayloadsig (double *__x, double __payload) noexcept (true);







extern double scalb (double __x, double __n) noexcept (true); extern double __scalb (double __x, double __n) noexcept (true);
# 314 "/usr/include/math.h" 2 3 4
# 329 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls-helper-functions.h" 1 3 4
# 20 "/usr/include/bits/mathcalls-helper-functions.h" 3 4
extern int __fpclassifyf (float __value) noexcept (true)
     __attribute__ ((__const__));


extern int __signbitf (float __value) noexcept (true)
     __attribute__ ((__const__));



extern int __isinff (float __value) noexcept (true)
  __attribute__ ((__const__));


extern int __finitef (float __value) noexcept (true)
  __attribute__ ((__const__));


extern int __isnanf (float __value) noexcept (true)
  __attribute__ ((__const__));


extern int __iseqsigf (float __x, float __y) noexcept (true);


extern int __issignalingf (float __value) noexcept (true)
     __attribute__ ((__const__));
# 330 "/usr/include/math.h" 2 3 4
# 1 "/usr/include/bits/mathcalls.h" 1 3 4
# 53 "/usr/include/bits/mathcalls.h" 3 4
 extern float acosf (float __x) noexcept (true); extern float __acosf (float __x) noexcept (true);

 extern float asinf (float __x) noexcept (true); extern float __asinf (float __x) noexcept (true);

 extern float atanf (float __x) noexcept (true); extern float __atanf (float __x) noexcept (true);

 extern float atan2f (float __y, float __x) noexcept (true); extern float __atan2f (float __y, float __x) noexcept (true);


 extern float cosf (float __x) noexcept (true); extern float __cosf (float __x) noexcept (true);

 extern float sinf (float __x) noexcept (true); extern float __sinf (float __x) noexcept (true);

 extern float tanf (float __x) noexcept (true); extern float __tanf (float __x) noexcept (true);




 extern float coshf (float __x) noexcept (true); extern float __coshf (float __x) noexcept (true);

 extern float sinhf (float __x) noexcept (true); extern float __sinhf (float __x) noexcept (true);

 extern float tanhf (float __x) noexcept (true); extern float __tanhf (float __x) noexcept (true);



 extern void sincosf (float __x, float *__sinx, float *__cosx) noexcept (true); extern void __sincosf (float __x, float *__sinx, float *__cosx) noexcept (true);





 extern float acoshf (float __x) noexcept (true); extern float __acoshf (float __x) noexcept (true);

 extern float asinhf (float __x) noexcept (true); extern float __asinhf (float __x) noexcept (true);

 extern float atanhf (float __x) noexcept (true); extern float __atanhf (float __x) noexcept (true);





 extern float expf (float __x) noexcept (true); extern float __expf (float __x) noexcept (true);


extern float frexpf (float __x, int *__exponent) noexcept (true); extern float __frexpf (float __x, int *__exponent) noexcept (true);


extern float ldexpf (float __x, int __exponent) noexcept (true); extern float __ldexpf (float __x, int __exponent) noexcept (true);


 extern float logf (float __x) noexcept (true); extern float __logf (float __x) noexcept (true);


 extern float log10f (float __x) noexcept (true); extern float __log10f (float __x) noexcept (true);


extern float modff (float __x, float *__iptr) noexcept (true); extern float __modff (float __x, float *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2)));



 extern float exp10f (float __x) noexcept (true); extern float __exp10f (float __x) noexcept (true);




 extern float expm1f (float __x) noexcept (true); extern float __expm1f (float __x) noexcept (true);


 extern float log1pf (float __x) noexcept (true); extern float __log1pf (float __x) noexcept (true);


extern float logbf (float __x) noexcept (true); extern float __logbf (float __x) noexcept (true);




 extern float exp2f (float __x) noexcept (true); extern float __exp2f (float __x) noexcept (true);


 extern float log2f (float __x) noexcept (true); extern float __log2f (float __x) noexcept (true);






 extern float powf (float __x, float __y) noexcept (true); extern float __powf (float __x, float __y) noexcept (true);


extern float sqrtf (float __x) noexcept (true); extern float __sqrtf (float __x) noexcept (true);



 extern float hypotf (float __x, float __y) noexcept (true); extern float __hypotf (float __x, float __y) noexcept (true);




 extern float cbrtf (float __x) noexcept (true); extern float __cbrtf (float __x) noexcept (true);






extern float ceilf (float __x) noexcept (true) __attribute__ ((__const__)); extern float __ceilf (float __x) noexcept (true) __attribute__ ((__const__));


extern float fabsf (float __x) noexcept (true) __attribute__ ((__const__)); extern float __fabsf (float __x) noexcept (true) __attribute__ ((__const__));


extern float floorf (float __x) noexcept (true) __attribute__ ((__const__)); extern float __floorf (float __x) noexcept (true) __attribute__ ((__const__));


extern float fmodf (float __x, float __y) noexcept (true); extern float __fmodf (float __x, float __y) noexcept (true);
# 177 "/usr/include/bits/mathcalls.h" 3 4
extern int isinff (float __value) noexcept (true)
  __attribute__ ((__const__));




extern int finitef (float __value) noexcept (true)
  __attribute__ ((__const__));


extern float dremf (float __x, float __y) noexcept (true); extern float __dremf (float __x, float __y) noexcept (true);



extern float significandf (float __x) noexcept (true); extern float __significandf (float __x) noexcept (true);






extern float copysignf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __copysignf (float __x, float __y) noexcept (true) __attribute__ ((__const__));




extern float nanf (const char *__tagb) noexcept (true); extern float __nanf (const char *__tagb) noexcept (true);
# 213 "/usr/include/bits/mathcalls.h" 3 4
extern int isnanf (float __value) noexcept (true)
  __attribute__ ((__const__));





extern float j0f (float) noexcept (true); extern float __j0f (float) noexcept (true);
extern float j1f (float) noexcept (true); extern float __j1f (float) noexcept (true);
extern float jnf (int, float) noexcept (true); extern float __jnf (int, float) noexcept (true);
extern float y0f (float) noexcept (true); extern float __y0f (float) noexcept (true);
extern float y1f (float) noexcept (true); extern float __y1f (float) noexcept (true);
extern float ynf (int, float) noexcept (true); extern float __ynf (int, float) noexcept (true);





 extern float erff (float) noexcept (true); extern float __erff (float) noexcept (true);
 extern float erfcf (float) noexcept (true); extern float __erfcf (float) noexcept (true);
extern float lgammaf (float) noexcept (true); extern float __lgammaf (float) noexcept (true);




extern float tgammaf (float) noexcept (true); extern float __tgammaf (float) noexcept (true);





extern float gammaf (float) noexcept (true); extern float __gammaf (float) noexcept (true);







extern float lgammaf_r (float, int *__signgamp) noexcept (true); extern float __lgammaf_r (float, int *__signgamp) noexcept (true);






extern float rintf (float __x) noexcept (true); extern float __rintf (float __x) noexcept (true);


extern float nextafterf (float __x, float __y) noexcept (true); extern float __nextafterf (float __x, float __y) noexcept (true);

extern float nexttowardf (float __x, long double __y) noexcept (true); extern float __nexttowardf (float __x, long double __y) noexcept (true);




extern float nextdownf (float __x) noexcept (true); extern float __nextdownf (float __x) noexcept (true);

extern float nextupf (float __x) noexcept (true); extern float __nextupf (float __x) noexcept (true);



extern float remainderf (float __x, float __y) noexcept (true); extern float __remainderf (float __x, float __y) noexcept (true);



extern float scalbnf (float __x, int __n) noexcept (true); extern float __scalbnf (float __x, int __n) noexcept (true);



extern int ilogbf (float __x) noexcept (true); extern int __ilogbf (float __x) noexcept (true);




extern long int llogbf (float __x) noexcept (true); extern long int __llogbf (float __x) noexcept (true);




extern float scalblnf (float __x, long int __n) noexcept (true); extern float __scalblnf (float __x, long int __n) noexcept (true);



extern float nearbyintf (float __x) noexcept (true); extern float __nearbyintf (float __x) noexcept (true);



extern float roundf (float __x) noexcept (true) __attribute__ ((__const__)); extern float __roundf (float __x) noexcept (true) __attribute__ ((__const__));



extern float truncf (float __x) noexcept (true) __attribute__ ((__const__)); extern float __truncf (float __x) noexcept (true) __attribute__ ((__const__));




extern float remquof (float __x, float __y, int *__quo) noexcept (true); extern float __remquof (float __x, float __y, int *__quo) noexcept (true);






extern long int lrintf (float __x) noexcept (true); extern long int __lrintf (float __x) noexcept (true);
__extension__
extern long long int llrintf (float __x) noexcept (true); extern long long int __llrintf (float __x) noexcept (true);



extern long int lroundf (float __x) noexcept (true); extern long int __lroundf (float __x) noexcept (true);
__extension__
extern long long int llroundf (float __x) noexcept (true); extern long long int __llroundf (float __x) noexcept (true);



extern float fdimf (float __x, float __y) noexcept (true); extern float __fdimf (float __x, float __y) noexcept (true);



extern float fmaxf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fmaxf (float __x, float __y) noexcept (true) __attribute__ ((__const__));


extern float fminf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fminf (float __x, float __y) noexcept (true) __attribute__ ((__const__));



extern float fmaf (float __x, float __y, float __z) noexcept (true); extern float __fmaf (float __x, float __y, float __z) noexcept (true);




extern float roundevenf (float __x) noexcept (true) __attribute__ ((__const__)); extern float __roundevenf (float __x) noexcept (true) __attribute__ ((__const__));



extern __intmax_t fromfpf (float __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf (float __x, int __round, unsigned int __width) noexcept (true);




extern __uintmax_t ufromfpf (float __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf (float __x, int __round, unsigned int __width) noexcept (true);





extern __intmax_t fromfpxf (float __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf (float __x, int __round, unsigned int __width) noexcept (true);





extern __uintmax_t ufromfpxf (float __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf (float __x, int __round, unsigned int __width) noexcept (true);



extern int canonicalizef (float *__cx, const float *__x) noexcept (true);






extern float fmaxmagf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fmaxmagf (float __x, float __y) noexcept (true) __attribute__ ((__const__));


extern float fminmagf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fminmagf (float __x, float __y) noexcept (true) __attribute__ ((__const__));




extern float fmaximumf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fmaximumf (float __x, float __y) noexcept (true) __attribute__ ((__const__));


extern float fminimumf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fminimumf (float __x, float __y) noexcept (true) __attribute__ ((__const__));


extern float fmaximum_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fmaximum_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__));


extern float fminimum_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fminimum_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__));


extern float fmaximum_magf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fmaximum_magf (float __x, float __y) noexcept (true) __attribute__ ((__const__));


extern float fminimum_magf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fminimum_magf (float __x, float __y) noexcept (true) __attribute__ ((__const__));


extern float fmaximum_mag_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fmaximum_mag_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__));


extern float fminimum_mag_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fminimum_mag_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__));




extern int totalorderf (const float *__x, const float *__y) noexcept (true)

     __attribute__ ((__pure__));


extern int totalordermagf (const float *__x, const float *__y) noexcept (true)

     __attribute__ ((__pure__));


extern float getpayloadf (const float *__x) noexcept (true); extern float __getpayloadf (const float *__x) noexcept (true);


extern int setpayloadf (float *__x, float __payload) noexcept (true);


extern int setpayloadsigf (float *__x, float __payload) noexcept (true);







extern float scalbf (float __x, float __n) noexcept (true); extern float __scalbf (float __x, float __n) noexcept (true);
# 331 "/usr/include/math.h" 2 3 4
# 398 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls-helper-functions.h" 1 3 4
# 20 "/usr/include/bits/mathcalls-helper-functions.h" 3 4
extern int __fpclassifyl (long double __value) noexcept (true)
     __attribute__ ((__const__));


extern int __signbitl (long double __value) noexcept (true)
     __attribute__ ((__const__));



extern int __isinfl (long double __value) noexcept (true)
  __attribute__ ((__const__));


extern int __finitel (long double __value) noexcept (true)
  __attribute__ ((__const__));


extern int __isnanl (long double __value) noexcept (true)
  __attribute__ ((__const__));


extern int __iseqsigl (long double __x, long double __y) noexcept (true);


extern int __issignalingl (long double __value) noexcept (true)
     __attribute__ ((__const__));
# 399 "/usr/include/math.h" 2 3 4
# 1 "/usr/include/bits/mathcalls.h" 1 3 4
# 53 "/usr/include/bits/mathcalls.h" 3 4
 extern long double acosl (long double __x) noexcept (true); extern long double __acosl (long double __x) noexcept (true);

 extern long double asinl (long double __x) noexcept (true); extern long double __asinl (long double __x) noexcept (true);

 extern long double atanl (long double __x) noexcept (true); extern long double __atanl (long double __x) noexcept (true);

 extern long double atan2l (long double __y, long double __x) noexcept (true); extern long double __atan2l (long double __y, long double __x) noexcept (true);


 extern long double cosl (long double __x) noexcept (true); extern long double __cosl (long double __x) noexcept (true);

 extern long double sinl (long double __x) noexcept (true); extern long double __sinl (long double __x) noexcept (true);

 extern long double tanl (long double __x) noexcept (true); extern long double __tanl (long double __x) noexcept (true);




 extern long double coshl (long double __x) noexcept (true); extern long double __coshl (long double __x) noexcept (true);

 extern long double sinhl (long double __x) noexcept (true); extern long double __sinhl (long double __x) noexcept (true);

 extern long double tanhl (long double __x) noexcept (true); extern long double __tanhl (long double __x) noexcept (true);



 extern void sincosl (long double __x, long double *__sinx, long double *__cosx) noexcept (true); extern void __sincosl (long double __x, long double *__sinx, long double *__cosx) noexcept (true);





 extern long double acoshl (long double __x) noexcept (true); extern long double __acoshl (long double __x) noexcept (true);

 extern long double asinhl (long double __x) noexcept (true); extern long double __asinhl (long double __x) noexcept (true);

 extern long double atanhl (long double __x) noexcept (true); extern long double __atanhl (long double __x) noexcept (true);





 extern long double expl (long double __x) noexcept (true); extern long double __expl (long double __x) noexcept (true);


extern long double frexpl (long double __x, int *__exponent) noexcept (true); extern long double __frexpl (long double __x, int *__exponent) noexcept (true);


extern long double ldexpl (long double __x, int __exponent) noexcept (true); extern long double __ldexpl (long double __x, int __exponent) noexcept (true);


 extern long double logl (long double __x) noexcept (true); extern long double __logl (long double __x) noexcept (true);


 extern long double log10l (long double __x) noexcept (true); extern long double __log10l (long double __x) noexcept (true);


extern long double modfl (long double __x, long double *__iptr) noexcept (true); extern long double __modfl (long double __x, long double *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2)));



 extern long double exp10l (long double __x) noexcept (true); extern long double __exp10l (long double __x) noexcept (true);




 extern long double expm1l (long double __x) noexcept (true); extern long double __expm1l (long double __x) noexcept (true);


 extern long double log1pl (long double __x) noexcept (true); extern long double __log1pl (long double __x) noexcept (true);


extern long double logbl (long double __x) noexcept (true); extern long double __logbl (long double __x) noexcept (true);




 extern long double exp2l (long double __x) noexcept (true); extern long double __exp2l (long double __x) noexcept (true);


 extern long double log2l (long double __x) noexcept (true); extern long double __log2l (long double __x) noexcept (true);






 extern long double powl (long double __x, long double __y) noexcept (true); extern long double __powl (long double __x, long double __y) noexcept (true);


extern long double sqrtl (long double __x) noexcept (true); extern long double __sqrtl (long double __x) noexcept (true);



 extern long double hypotl (long double __x, long double __y) noexcept (true); extern long double __hypotl (long double __x, long double __y) noexcept (true);




 extern long double cbrtl (long double __x) noexcept (true); extern long double __cbrtl (long double __x) noexcept (true);






extern long double ceill (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __ceill (long double __x) noexcept (true) __attribute__ ((__const__));


extern long double fabsl (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __fabsl (long double __x) noexcept (true) __attribute__ ((__const__));


extern long double floorl (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __floorl (long double __x) noexcept (true) __attribute__ ((__const__));


extern long double fmodl (long double __x, long double __y) noexcept (true); extern long double __fmodl (long double __x, long double __y) noexcept (true);
# 177 "/usr/include/bits/mathcalls.h" 3 4
extern int isinfl (long double __value) noexcept (true)
  __attribute__ ((__const__));




extern int finitel (long double __value) noexcept (true)
  __attribute__ ((__const__));


extern long double dreml (long double __x, long double __y) noexcept (true); extern long double __dreml (long double __x, long double __y) noexcept (true);



extern long double significandl (long double __x) noexcept (true); extern long double __significandl (long double __x) noexcept (true);






extern long double copysignl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __copysignl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__));




extern long double nanl (const char *__tagb) noexcept (true); extern long double __nanl (const char *__tagb) noexcept (true);
# 213 "/usr/include/bits/mathcalls.h" 3 4
extern int isnanl (long double __value) noexcept (true)
  __attribute__ ((__const__));





extern long double j0l (long double) noexcept (true); extern long double __j0l (long double) noexcept (true);
extern long double j1l (long double) noexcept (true); extern long double __j1l (long double) noexcept (true);
extern long double jnl (int, long double) noexcept (true); extern long double __jnl (int, long double) noexcept (true);
extern long double y0l (long double) noexcept (true); extern long double __y0l (long double) noexcept (true);
extern long double y1l (long double) noexcept (true); extern long double __y1l (long double) noexcept (true);
extern long double ynl (int, long double) noexcept (true); extern long double __ynl (int, long double) noexcept (true);





 extern long double erfl (long double) noexcept (true); extern long double __erfl (long double) noexcept (true);
 extern long double erfcl (long double) noexcept (true); extern long double __erfcl (long double) noexcept (true);
extern long double lgammal (long double) noexcept (true); extern long double __lgammal (long double) noexcept (true);




extern long double tgammal (long double) noexcept (true); extern long double __tgammal (long double) noexcept (true);





extern long double gammal (long double) noexcept (true); extern long double __gammal (long double) noexcept (true);







extern long double lgammal_r (long double, int *__signgamp) noexcept (true); extern long double __lgammal_r (long double, int *__signgamp) noexcept (true);






extern long double rintl (long double __x) noexcept (true); extern long double __rintl (long double __x) noexcept (true);


extern long double nextafterl (long double __x, long double __y) noexcept (true); extern long double __nextafterl (long double __x, long double __y) noexcept (true);

extern long double nexttowardl (long double __x, long double __y) noexcept (true); extern long double __nexttowardl (long double __x, long double __y) noexcept (true);




extern long double nextdownl (long double __x) noexcept (true); extern long double __nextdownl (long double __x) noexcept (true);

extern long double nextupl (long double __x) noexcept (true); extern long double __nextupl (long double __x) noexcept (true);



extern long double remainderl (long double __x, long double __y) noexcept (true); extern long double __remainderl (long double __x, long double __y) noexcept (true);



extern long double scalbnl (long double __x, int __n) noexcept (true); extern long double __scalbnl (long double __x, int __n) noexcept (true);



extern int ilogbl (long double __x) noexcept (true); extern int __ilogbl (long double __x) noexcept (true);




extern long int llogbl (long double __x) noexcept (true); extern long int __llogbl (long double __x) noexcept (true);




extern long double scalblnl (long double __x, long int __n) noexcept (true); extern long double __scalblnl (long double __x, long int __n) noexcept (true);



extern long double nearbyintl (long double __x) noexcept (true); extern long double __nearbyintl (long double __x) noexcept (true);



extern long double roundl (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __roundl (long double __x) noexcept (true) __attribute__ ((__const__));



extern long double truncl (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __truncl (long double __x) noexcept (true) __attribute__ ((__const__));




extern long double remquol (long double __x, long double __y, int *__quo) noexcept (true); extern long double __remquol (long double __x, long double __y, int *__quo) noexcept (true);






extern long int lrintl (long double __x) noexcept (true); extern long int __lrintl (long double __x) noexcept (true);
__extension__
extern long long int llrintl (long double __x) noexcept (true); extern long long int __llrintl (long double __x) noexcept (true);



extern long int lroundl (long double __x) noexcept (true); extern long int __lroundl (long double __x) noexcept (true);
__extension__
extern long long int llroundl (long double __x) noexcept (true); extern long long int __llroundl (long double __x) noexcept (true);



extern long double fdiml (long double __x, long double __y) noexcept (true); extern long double __fdiml (long double __x, long double __y) noexcept (true);



extern long double fmaxl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fmaxl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__));


extern long double fminl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fminl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__));



extern long double fmal (long double __x, long double __y, long double __z) noexcept (true); extern long double __fmal (long double __x, long double __y, long double __z) noexcept (true);




extern long double roundevenl (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __roundevenl (long double __x) noexcept (true) __attribute__ ((__const__));



extern __intmax_t fromfpl (long double __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpl (long double __x, int __round, unsigned int __width) noexcept (true);




extern __uintmax_t ufromfpl (long double __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpl (long double __x, int __round, unsigned int __width) noexcept (true);





extern __intmax_t fromfpxl (long double __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxl (long double __x, int __round, unsigned int __width) noexcept (true);





extern __uintmax_t ufromfpxl (long double __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxl (long double __x, int __round, unsigned int __width) noexcept (true);



extern int canonicalizel (long double *__cx, const long double *__x) noexcept (true);






extern long double fmaxmagl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fmaxmagl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__));


extern long double fminmagl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fminmagl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__));




extern long double fmaximuml (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fmaximuml (long double __x, long double __y) noexcept (true) __attribute__ ((__const__));


extern long double fminimuml (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fminimuml (long double __x, long double __y) noexcept (true) __attribute__ ((__const__));


extern long double fmaximum_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fmaximum_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__));


extern long double fminimum_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fminimum_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__));


extern long double fmaximum_magl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fmaximum_magl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__));


extern long double fminimum_magl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fminimum_magl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__));


extern long double fmaximum_mag_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fmaximum_mag_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__));


extern long double fminimum_mag_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fminimum_mag_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__));




extern int totalorderl (const long double *__x, const long double *__y) noexcept (true)

     __attribute__ ((__pure__));


extern int totalordermagl (const long double *__x, const long double *__y) noexcept (true)

     __attribute__ ((__pure__));


extern long double getpayloadl (const long double *__x) noexcept (true); extern long double __getpayloadl (const long double *__x) noexcept (true);


extern int setpayloadl (long double *__x, long double __payload) noexcept (true);


extern int setpayloadsigl (long double *__x, long double __payload) noexcept (true);







extern long double scalbl (long double __x, long double __n) noexcept (true); extern long double __scalbl (long double __x, long double __n) noexcept (true);
# 400 "/usr/include/math.h" 2 3 4
# 450 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls.h" 1 3 4
# 53 "/usr/include/bits/mathcalls.h" 3 4
 extern _Float32 acosf32 (_Float32 __x) noexcept (true); extern _Float32 __acosf32 (_Float32 __x) noexcept (true);

 extern _Float32 asinf32 (_Float32 __x) noexcept (true); extern _Float32 __asinf32 (_Float32 __x) noexcept (true);

 extern _Float32 atanf32 (_Float32 __x) noexcept (true); extern _Float32 __atanf32 (_Float32 __x) noexcept (true);

 extern _Float32 atan2f32 (_Float32 __y, _Float32 __x) noexcept (true); extern _Float32 __atan2f32 (_Float32 __y, _Float32 __x) noexcept (true);


 extern _Float32 cosf32 (_Float32 __x) noexcept (true); extern _Float32 __cosf32 (_Float32 __x) noexcept (true);

 extern _Float32 sinf32 (_Float32 __x) noexcept (true); extern _Float32 __sinf32 (_Float32 __x) noexcept (true);

 extern _Float32 tanf32 (_Float32 __x) noexcept (true); extern _Float32 __tanf32 (_Float32 __x) noexcept (true);




 extern _Float32 coshf32 (_Float32 __x) noexcept (true); extern _Float32 __coshf32 (_Float32 __x) noexcept (true);

 extern _Float32 sinhf32 (_Float32 __x) noexcept (true); extern _Float32 __sinhf32 (_Float32 __x) noexcept (true);

 extern _Float32 tanhf32 (_Float32 __x) noexcept (true); extern _Float32 __tanhf32 (_Float32 __x) noexcept (true);



 extern void sincosf32 (_Float32 __x, _Float32 *__sinx, _Float32 *__cosx) noexcept (true); extern void __sincosf32 (_Float32 __x, _Float32 *__sinx, _Float32 *__cosx) noexcept (true);





 extern _Float32 acoshf32 (_Float32 __x) noexcept (true); extern _Float32 __acoshf32 (_Float32 __x) noexcept (true);

 extern _Float32 asinhf32 (_Float32 __x) noexcept (true); extern _Float32 __asinhf32 (_Float32 __x) noexcept (true);

 extern _Float32 atanhf32 (_Float32 __x) noexcept (true); extern _Float32 __atanhf32 (_Float32 __x) noexcept (true);





 extern _Float32 expf32 (_Float32 __x) noexcept (true); extern _Float32 __expf32 (_Float32 __x) noexcept (true);


extern _Float32 frexpf32 (_Float32 __x, int *__exponent) noexcept (true); extern _Float32 __frexpf32 (_Float32 __x, int *__exponent) noexcept (true);


extern _Float32 ldexpf32 (_Float32 __x, int __exponent) noexcept (true); extern _Float32 __ldexpf32 (_Float32 __x, int __exponent) noexcept (true);


 extern _Float32 logf32 (_Float32 __x) noexcept (true); extern _Float32 __logf32 (_Float32 __x) noexcept (true);


 extern _Float32 log10f32 (_Float32 __x) noexcept (true); extern _Float32 __log10f32 (_Float32 __x) noexcept (true);


extern _Float32 modff32 (_Float32 __x, _Float32 *__iptr) noexcept (true); extern _Float32 __modff32 (_Float32 __x, _Float32 *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2)));



 extern _Float32 exp10f32 (_Float32 __x) noexcept (true); extern _Float32 __exp10f32 (_Float32 __x) noexcept (true);




 extern _Float32 expm1f32 (_Float32 __x) noexcept (true); extern _Float32 __expm1f32 (_Float32 __x) noexcept (true);


 extern _Float32 log1pf32 (_Float32 __x) noexcept (true); extern _Float32 __log1pf32 (_Float32 __x) noexcept (true);


extern _Float32 logbf32 (_Float32 __x) noexcept (true); extern _Float32 __logbf32 (_Float32 __x) noexcept (true);




 extern _Float32 exp2f32 (_Float32 __x) noexcept (true); extern _Float32 __exp2f32 (_Float32 __x) noexcept (true);


 extern _Float32 log2f32 (_Float32 __x) noexcept (true); extern _Float32 __log2f32 (_Float32 __x) noexcept (true);






 extern _Float32 powf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __powf32 (_Float32 __x, _Float32 __y) noexcept (true);


extern _Float32 sqrtf32 (_Float32 __x) noexcept (true); extern _Float32 __sqrtf32 (_Float32 __x) noexcept (true);



 extern _Float32 hypotf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __hypotf32 (_Float32 __x, _Float32 __y) noexcept (true);




 extern _Float32 cbrtf32 (_Float32 __x) noexcept (true); extern _Float32 __cbrtf32 (_Float32 __x) noexcept (true);






extern _Float32 ceilf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); extern _Float32 __ceilf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__));


extern _Float32 fabsf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fabsf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__));


extern _Float32 floorf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); extern _Float32 __floorf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__));


extern _Float32 fmodf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __fmodf32 (_Float32 __x, _Float32 __y) noexcept (true);
# 198 "/usr/include/bits/mathcalls.h" 3 4
extern _Float32 copysignf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __copysignf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__));




extern _Float32 nanf32 (const char *__tagb) noexcept (true); extern _Float32 __nanf32 (const char *__tagb) noexcept (true);
# 220 "/usr/include/bits/mathcalls.h" 3 4
extern _Float32 j0f32 (_Float32) noexcept (true); extern _Float32 __j0f32 (_Float32) noexcept (true);
extern _Float32 j1f32 (_Float32) noexcept (true); extern _Float32 __j1f32 (_Float32) noexcept (true);
extern _Float32 jnf32 (int, _Float32) noexcept (true); extern _Float32 __jnf32 (int, _Float32) noexcept (true);
extern _Float32 y0f32 (_Float32) noexcept (true); extern _Float32 __y0f32 (_Float32) noexcept (true);
extern _Float32 y1f32 (_Float32) noexcept (true); extern _Float32 __y1f32 (_Float32) noexcept (true);
extern _Float32 ynf32 (int, _Float32) noexcept (true); extern _Float32 __ynf32 (int, _Float32) noexcept (true);





 extern _Float32 erff32 (_Float32) noexcept (true); extern _Float32 __erff32 (_Float32) noexcept (true);
 extern _Float32 erfcf32 (_Float32) noexcept (true); extern _Float32 __erfcf32 (_Float32) noexcept (true);
extern _Float32 lgammaf32 (_Float32) noexcept (true); extern _Float32 __lgammaf32 (_Float32) noexcept (true);




extern _Float32 tgammaf32 (_Float32) noexcept (true); extern _Float32 __tgammaf32 (_Float32) noexcept (true);
# 252 "/usr/include/bits/mathcalls.h" 3 4
extern _Float32 lgammaf32_r (_Float32, int *__signgamp) noexcept (true); extern _Float32 __lgammaf32_r (_Float32, int *__signgamp) noexcept (true);






extern _Float32 rintf32 (_Float32 __x) noexcept (true); extern _Float32 __rintf32 (_Float32 __x) noexcept (true);


extern _Float32 nextafterf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __nextafterf32 (_Float32 __x, _Float32 __y) noexcept (true);






extern _Float32 nextdownf32 (_Float32 __x) noexcept (true); extern _Float32 __nextdownf32 (_Float32 __x) noexcept (true);

extern _Float32 nextupf32 (_Float32 __x) noexcept (true); extern _Float32 __nextupf32 (_Float32 __x) noexcept (true);



extern _Float32 remainderf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __remainderf32 (_Float32 __x, _Float32 __y) noexcept (true);



extern _Float32 scalbnf32 (_Float32 __x, int __n) noexcept (true); extern _Float32 __scalbnf32 (_Float32 __x, int __n) noexcept (true);



extern int ilogbf32 (_Float32 __x) noexcept (true); extern int __ilogbf32 (_Float32 __x) noexcept (true);




extern long int llogbf32 (_Float32 __x) noexcept (true); extern long int __llogbf32 (_Float32 __x) noexcept (true);




extern _Float32 scalblnf32 (_Float32 __x, long int __n) noexcept (true); extern _Float32 __scalblnf32 (_Float32 __x, long int __n) noexcept (true);



extern _Float32 nearbyintf32 (_Float32 __x) noexcept (true); extern _Float32 __nearbyintf32 (_Float32 __x) noexcept (true);



extern _Float32 roundf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); extern _Float32 __roundf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__));



extern _Float32 truncf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); extern _Float32 __truncf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__));




extern _Float32 remquof32 (_Float32 __x, _Float32 __y, int *__quo) noexcept (true); extern _Float32 __remquof32 (_Float32 __x, _Float32 __y, int *__quo) noexcept (true);






extern long int lrintf32 (_Float32 __x) noexcept (true); extern long int __lrintf32 (_Float32 __x) noexcept (true);
__extension__
extern long long int llrintf32 (_Float32 __x) noexcept (true); extern long long int __llrintf32 (_Float32 __x) noexcept (true);



extern long int lroundf32 (_Float32 __x) noexcept (true); extern long int __lroundf32 (_Float32 __x) noexcept (true);
__extension__
extern long long int llroundf32 (_Float32 __x) noexcept (true); extern long long int __llroundf32 (_Float32 __x) noexcept (true);



extern _Float32 fdimf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __fdimf32 (_Float32 __x, _Float32 __y) noexcept (true);



extern _Float32 fmaxf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fmaxf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__));


extern _Float32 fminf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fminf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__));



extern _Float32 fmaf32 (_Float32 __x, _Float32 __y, _Float32 __z) noexcept (true); extern _Float32 __fmaf32 (_Float32 __x, _Float32 __y, _Float32 __z) noexcept (true);




extern _Float32 roundevenf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); extern _Float32 __roundevenf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__));



extern __intmax_t fromfpf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true);




extern __uintmax_t ufromfpf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true);





extern __intmax_t fromfpxf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true);





extern __uintmax_t ufromfpxf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true);



extern int canonicalizef32 (_Float32 *__cx, const _Float32 *__x) noexcept (true);






extern _Float32 fmaxmagf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fmaxmagf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__));


extern _Float32 fminmagf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fminmagf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__));




extern _Float32 fmaximumf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fmaximumf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__));


extern _Float32 fminimumf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fminimumf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__));


extern _Float32 fmaximum_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fmaximum_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__));


extern _Float32 fminimum_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fminimum_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__));


extern _Float32 fmaximum_magf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fmaximum_magf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__));


extern _Float32 fminimum_magf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fminimum_magf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__));


extern _Float32 fmaximum_mag_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fmaximum_mag_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__));


extern _Float32 fminimum_mag_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fminimum_mag_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__));




extern int totalorderf32 (const _Float32 *__x, const _Float32 *__y) noexcept (true)

     __attribute__ ((__pure__));


extern int totalordermagf32 (const _Float32 *__x, const _Float32 *__y) noexcept (true)

     __attribute__ ((__pure__));


extern _Float32 getpayloadf32 (const _Float32 *__x) noexcept (true); extern _Float32 __getpayloadf32 (const _Float32 *__x) noexcept (true);


extern int setpayloadf32 (_Float32 *__x, _Float32 __payload) noexcept (true);


extern int setpayloadsigf32 (_Float32 *__x, _Float32 __payload) noexcept (true);
# 451 "/usr/include/math.h" 2 3 4
# 467 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls.h" 1 3 4
# 53 "/usr/include/bits/mathcalls.h" 3 4
 extern _Float64 acosf64 (_Float64 __x) noexcept (true); extern _Float64 __acosf64 (_Float64 __x) noexcept (true);

 extern _Float64 asinf64 (_Float64 __x) noexcept (true); extern _Float64 __asinf64 (_Float64 __x) noexcept (true);

 extern _Float64 atanf64 (_Float64 __x) noexcept (true); extern _Float64 __atanf64 (_Float64 __x) noexcept (true);

 extern _Float64 atan2f64 (_Float64 __y, _Float64 __x) noexcept (true); extern _Float64 __atan2f64 (_Float64 __y, _Float64 __x) noexcept (true);


 extern _Float64 cosf64 (_Float64 __x) noexcept (true); extern _Float64 __cosf64 (_Float64 __x) noexcept (true);

 extern _Float64 sinf64 (_Float64 __x) noexcept (true); extern _Float64 __sinf64 (_Float64 __x) noexcept (true);

 extern _Float64 tanf64 (_Float64 __x) noexcept (true); extern _Float64 __tanf64 (_Float64 __x) noexcept (true);




 extern _Float64 coshf64 (_Float64 __x) noexcept (true); extern _Float64 __coshf64 (_Float64 __x) noexcept (true);

 extern _Float64 sinhf64 (_Float64 __x) noexcept (true); extern _Float64 __sinhf64 (_Float64 __x) noexcept (true);

 extern _Float64 tanhf64 (_Float64 __x) noexcept (true); extern _Float64 __tanhf64 (_Float64 __x) noexcept (true);



 extern void sincosf64 (_Float64 __x, _Float64 *__sinx, _Float64 *__cosx) noexcept (true); extern void __sincosf64 (_Float64 __x, _Float64 *__sinx, _Float64 *__cosx) noexcept (true);





 extern _Float64 acoshf64 (_Float64 __x) noexcept (true); extern _Float64 __acoshf64 (_Float64 __x) noexcept (true);

 extern _Float64 asinhf64 (_Float64 __x) noexcept (true); extern _Float64 __asinhf64 (_Float64 __x) noexcept (true);

 extern _Float64 atanhf64 (_Float64 __x) noexcept (true); extern _Float64 __atanhf64 (_Float64 __x) noexcept (true);





 extern _Float64 expf64 (_Float64 __x) noexcept (true); extern _Float64 __expf64 (_Float64 __x) noexcept (true);


extern _Float64 frexpf64 (_Float64 __x, int *__exponent) noexcept (true); extern _Float64 __frexpf64 (_Float64 __x, int *__exponent) noexcept (true);


extern _Float64 ldexpf64 (_Float64 __x, int __exponent) noexcept (true); extern _Float64 __ldexpf64 (_Float64 __x, int __exponent) noexcept (true);


 extern _Float64 logf64 (_Float64 __x) noexcept (true); extern _Float64 __logf64 (_Float64 __x) noexcept (true);


 extern _Float64 log10f64 (_Float64 __x) noexcept (true); extern _Float64 __log10f64 (_Float64 __x) noexcept (true);


extern _Float64 modff64 (_Float64 __x, _Float64 *__iptr) noexcept (true); extern _Float64 __modff64 (_Float64 __x, _Float64 *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2)));



 extern _Float64 exp10f64 (_Float64 __x) noexcept (true); extern _Float64 __exp10f64 (_Float64 __x) noexcept (true);




 extern _Float64 expm1f64 (_Float64 __x) noexcept (true); extern _Float64 __expm1f64 (_Float64 __x) noexcept (true);


 extern _Float64 log1pf64 (_Float64 __x) noexcept (true); extern _Float64 __log1pf64 (_Float64 __x) noexcept (true);


extern _Float64 logbf64 (_Float64 __x) noexcept (true); extern _Float64 __logbf64 (_Float64 __x) noexcept (true);




 extern _Float64 exp2f64 (_Float64 __x) noexcept (true); extern _Float64 __exp2f64 (_Float64 __x) noexcept (true);


 extern _Float64 log2f64 (_Float64 __x) noexcept (true); extern _Float64 __log2f64 (_Float64 __x) noexcept (true);






 extern _Float64 powf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __powf64 (_Float64 __x, _Float64 __y) noexcept (true);


extern _Float64 sqrtf64 (_Float64 __x) noexcept (true); extern _Float64 __sqrtf64 (_Float64 __x) noexcept (true);



 extern _Float64 hypotf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __hypotf64 (_Float64 __x, _Float64 __y) noexcept (true);




 extern _Float64 cbrtf64 (_Float64 __x) noexcept (true); extern _Float64 __cbrtf64 (_Float64 __x) noexcept (true);






extern _Float64 ceilf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); extern _Float64 __ceilf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__));


extern _Float64 fabsf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fabsf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__));


extern _Float64 floorf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); extern _Float64 __floorf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__));


extern _Float64 fmodf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __fmodf64 (_Float64 __x, _Float64 __y) noexcept (true);
# 198 "/usr/include/bits/mathcalls.h" 3 4
extern _Float64 copysignf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __copysignf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__));




extern _Float64 nanf64 (const char *__tagb) noexcept (true); extern _Float64 __nanf64 (const char *__tagb) noexcept (true);
# 220 "/usr/include/bits/mathcalls.h" 3 4
extern _Float64 j0f64 (_Float64) noexcept (true); extern _Float64 __j0f64 (_Float64) noexcept (true);
extern _Float64 j1f64 (_Float64) noexcept (true); extern _Float64 __j1f64 (_Float64) noexcept (true);
extern _Float64 jnf64 (int, _Float64) noexcept (true); extern _Float64 __jnf64 (int, _Float64) noexcept (true);
extern _Float64 y0f64 (_Float64) noexcept (true); extern _Float64 __y0f64 (_Float64) noexcept (true);
extern _Float64 y1f64 (_Float64) noexcept (true); extern _Float64 __y1f64 (_Float64) noexcept (true);
extern _Float64 ynf64 (int, _Float64) noexcept (true); extern _Float64 __ynf64 (int, _Float64) noexcept (true);





 extern _Float64 erff64 (_Float64) noexcept (true); extern _Float64 __erff64 (_Float64) noexcept (true);
 extern _Float64 erfcf64 (_Float64) noexcept (true); extern _Float64 __erfcf64 (_Float64) noexcept (true);
extern _Float64 lgammaf64 (_Float64) noexcept (true); extern _Float64 __lgammaf64 (_Float64) noexcept (true);




extern _Float64 tgammaf64 (_Float64) noexcept (true); extern _Float64 __tgammaf64 (_Float64) noexcept (true);
# 252 "/usr/include/bits/mathcalls.h" 3 4
extern _Float64 lgammaf64_r (_Float64, int *__signgamp) noexcept (true); extern _Float64 __lgammaf64_r (_Float64, int *__signgamp) noexcept (true);






extern _Float64 rintf64 (_Float64 __x) noexcept (true); extern _Float64 __rintf64 (_Float64 __x) noexcept (true);


extern _Float64 nextafterf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __nextafterf64 (_Float64 __x, _Float64 __y) noexcept (true);






extern _Float64 nextdownf64 (_Float64 __x) noexcept (true); extern _Float64 __nextdownf64 (_Float64 __x) noexcept (true);

extern _Float64 nextupf64 (_Float64 __x) noexcept (true); extern _Float64 __nextupf64 (_Float64 __x) noexcept (true);



extern _Float64 remainderf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __remainderf64 (_Float64 __x, _Float64 __y) noexcept (true);



extern _Float64 scalbnf64 (_Float64 __x, int __n) noexcept (true); extern _Float64 __scalbnf64 (_Float64 __x, int __n) noexcept (true);



extern int ilogbf64 (_Float64 __x) noexcept (true); extern int __ilogbf64 (_Float64 __x) noexcept (true);




extern long int llogbf64 (_Float64 __x) noexcept (true); extern long int __llogbf64 (_Float64 __x) noexcept (true);




extern _Float64 scalblnf64 (_Float64 __x, long int __n) noexcept (true); extern _Float64 __scalblnf64 (_Float64 __x, long int __n) noexcept (true);



extern _Float64 nearbyintf64 (_Float64 __x) noexcept (true); extern _Float64 __nearbyintf64 (_Float64 __x) noexcept (true);



extern _Float64 roundf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); extern _Float64 __roundf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__));



extern _Float64 truncf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); extern _Float64 __truncf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__));




extern _Float64 remquof64 (_Float64 __x, _Float64 __y, int *__quo) noexcept (true); extern _Float64 __remquof64 (_Float64 __x, _Float64 __y, int *__quo) noexcept (true);






extern long int lrintf64 (_Float64 __x) noexcept (true); extern long int __lrintf64 (_Float64 __x) noexcept (true);
__extension__
extern long long int llrintf64 (_Float64 __x) noexcept (true); extern long long int __llrintf64 (_Float64 __x) noexcept (true);



extern long int lroundf64 (_Float64 __x) noexcept (true); extern long int __lroundf64 (_Float64 __x) noexcept (true);
__extension__
extern long long int llroundf64 (_Float64 __x) noexcept (true); extern long long int __llroundf64 (_Float64 __x) noexcept (true);



extern _Float64 fdimf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __fdimf64 (_Float64 __x, _Float64 __y) noexcept (true);



extern _Float64 fmaxf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fmaxf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__));


extern _Float64 fminf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fminf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__));



extern _Float64 fmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) noexcept (true); extern _Float64 __fmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) noexcept (true);




extern _Float64 roundevenf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); extern _Float64 __roundevenf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__));



extern __intmax_t fromfpf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true);




extern __uintmax_t ufromfpf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true);





extern __intmax_t fromfpxf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true);





extern __uintmax_t ufromfpxf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true);



extern int canonicalizef64 (_Float64 *__cx, const _Float64 *__x) noexcept (true);






extern _Float64 fmaxmagf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fmaxmagf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__));


extern _Float64 fminmagf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fminmagf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__));




extern _Float64 fmaximumf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fmaximumf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__));


extern _Float64 fminimumf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fminimumf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__));


extern _Float64 fmaximum_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fmaximum_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__));


extern _Float64 fminimum_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fminimum_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__));


extern _Float64 fmaximum_magf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fmaximum_magf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__));


extern _Float64 fminimum_magf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fminimum_magf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__));


extern _Float64 fmaximum_mag_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fmaximum_mag_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__));


extern _Float64 fminimum_mag_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fminimum_mag_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__));




extern int totalorderf64 (const _Float64 *__x, const _Float64 *__y) noexcept (true)

     __attribute__ ((__pure__));


extern int totalordermagf64 (const _Float64 *__x, const _Float64 *__y) noexcept (true)

     __attribute__ ((__pure__));


extern _Float64 getpayloadf64 (const _Float64 *__x) noexcept (true); extern _Float64 __getpayloadf64 (const _Float64 *__x) noexcept (true);


extern int setpayloadf64 (_Float64 *__x, _Float64 __payload) noexcept (true);


extern int setpayloadsigf64 (_Float64 *__x, _Float64 __payload) noexcept (true);
# 468 "/usr/include/math.h" 2 3 4
# 501 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls.h" 1 3 4
# 53 "/usr/include/bits/mathcalls.h" 3 4
 extern _Float32x acosf32x (_Float32x __x) noexcept (true); extern _Float32x __acosf32x (_Float32x __x) noexcept (true);

 extern _Float32x asinf32x (_Float32x __x) noexcept (true); extern _Float32x __asinf32x (_Float32x __x) noexcept (true);

 extern _Float32x atanf32x (_Float32x __x) noexcept (true); extern _Float32x __atanf32x (_Float32x __x) noexcept (true);

 extern _Float32x atan2f32x (_Float32x __y, _Float32x __x) noexcept (true); extern _Float32x __atan2f32x (_Float32x __y, _Float32x __x) noexcept (true);


 extern _Float32x cosf32x (_Float32x __x) noexcept (true); extern _Float32x __cosf32x (_Float32x __x) noexcept (true);

 extern _Float32x sinf32x (_Float32x __x) noexcept (true); extern _Float32x __sinf32x (_Float32x __x) noexcept (true);

 extern _Float32x tanf32x (_Float32x __x) noexcept (true); extern _Float32x __tanf32x (_Float32x __x) noexcept (true);




 extern _Float32x coshf32x (_Float32x __x) noexcept (true); extern _Float32x __coshf32x (_Float32x __x) noexcept (true);

 extern _Float32x sinhf32x (_Float32x __x) noexcept (true); extern _Float32x __sinhf32x (_Float32x __x) noexcept (true);

 extern _Float32x tanhf32x (_Float32x __x) noexcept (true); extern _Float32x __tanhf32x (_Float32x __x) noexcept (true);



 extern void sincosf32x (_Float32x __x, _Float32x *__sinx, _Float32x *__cosx) noexcept (true); extern void __sincosf32x (_Float32x __x, _Float32x *__sinx, _Float32x *__cosx) noexcept (true);





 extern _Float32x acoshf32x (_Float32x __x) noexcept (true); extern _Float32x __acoshf32x (_Float32x __x) noexcept (true);

 extern _Float32x asinhf32x (_Float32x __x) noexcept (true); extern _Float32x __asinhf32x (_Float32x __x) noexcept (true);

 extern _Float32x atanhf32x (_Float32x __x) noexcept (true); extern _Float32x __atanhf32x (_Float32x __x) noexcept (true);





 extern _Float32x expf32x (_Float32x __x) noexcept (true); extern _Float32x __expf32x (_Float32x __x) noexcept (true);


extern _Float32x frexpf32x (_Float32x __x, int *__exponent) noexcept (true); extern _Float32x __frexpf32x (_Float32x __x, int *__exponent) noexcept (true);


extern _Float32x ldexpf32x (_Float32x __x, int __exponent) noexcept (true); extern _Float32x __ldexpf32x (_Float32x __x, int __exponent) noexcept (true);


 extern _Float32x logf32x (_Float32x __x) noexcept (true); extern _Float32x __logf32x (_Float32x __x) noexcept (true);


 extern _Float32x log10f32x (_Float32x __x) noexcept (true); extern _Float32x __log10f32x (_Float32x __x) noexcept (true);


extern _Float32x modff32x (_Float32x __x, _Float32x *__iptr) noexcept (true); extern _Float32x __modff32x (_Float32x __x, _Float32x *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2)));



 extern _Float32x exp10f32x (_Float32x __x) noexcept (true); extern _Float32x __exp10f32x (_Float32x __x) noexcept (true);




 extern _Float32x expm1f32x (_Float32x __x) noexcept (true); extern _Float32x __expm1f32x (_Float32x __x) noexcept (true);


 extern _Float32x log1pf32x (_Float32x __x) noexcept (true); extern _Float32x __log1pf32x (_Float32x __x) noexcept (true);


extern _Float32x logbf32x (_Float32x __x) noexcept (true); extern _Float32x __logbf32x (_Float32x __x) noexcept (true);




 extern _Float32x exp2f32x (_Float32x __x) noexcept (true); extern _Float32x __exp2f32x (_Float32x __x) noexcept (true);


 extern _Float32x log2f32x (_Float32x __x) noexcept (true); extern _Float32x __log2f32x (_Float32x __x) noexcept (true);






 extern _Float32x powf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __powf32x (_Float32x __x, _Float32x __y) noexcept (true);


extern _Float32x sqrtf32x (_Float32x __x) noexcept (true); extern _Float32x __sqrtf32x (_Float32x __x) noexcept (true);



 extern _Float32x hypotf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __hypotf32x (_Float32x __x, _Float32x __y) noexcept (true);




 extern _Float32x cbrtf32x (_Float32x __x) noexcept (true); extern _Float32x __cbrtf32x (_Float32x __x) noexcept (true);






extern _Float32x ceilf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); extern _Float32x __ceilf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__));


extern _Float32x fabsf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fabsf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__));


extern _Float32x floorf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); extern _Float32x __floorf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__));


extern _Float32x fmodf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __fmodf32x (_Float32x __x, _Float32x __y) noexcept (true);
# 198 "/usr/include/bits/mathcalls.h" 3 4
extern _Float32x copysignf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __copysignf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__));




extern _Float32x nanf32x (const char *__tagb) noexcept (true); extern _Float32x __nanf32x (const char *__tagb) noexcept (true);
# 220 "/usr/include/bits/mathcalls.h" 3 4
extern _Float32x j0f32x (_Float32x) noexcept (true); extern _Float32x __j0f32x (_Float32x) noexcept (true);
extern _Float32x j1f32x (_Float32x) noexcept (true); extern _Float32x __j1f32x (_Float32x) noexcept (true);
extern _Float32x jnf32x (int, _Float32x) noexcept (true); extern _Float32x __jnf32x (int, _Float32x) noexcept (true);
extern _Float32x y0f32x (_Float32x) noexcept (true); extern _Float32x __y0f32x (_Float32x) noexcept (true);
extern _Float32x y1f32x (_Float32x) noexcept (true); extern _Float32x __y1f32x (_Float32x) noexcept (true);
extern _Float32x ynf32x (int, _Float32x) noexcept (true); extern _Float32x __ynf32x (int, _Float32x) noexcept (true);





 extern _Float32x erff32x (_Float32x) noexcept (true); extern _Float32x __erff32x (_Float32x) noexcept (true);
 extern _Float32x erfcf32x (_Float32x) noexcept (true); extern _Float32x __erfcf32x (_Float32x) noexcept (true);
extern _Float32x lgammaf32x (_Float32x) noexcept (true); extern _Float32x __lgammaf32x (_Float32x) noexcept (true);




extern _Float32x tgammaf32x (_Float32x) noexcept (true); extern _Float32x __tgammaf32x (_Float32x) noexcept (true);
# 252 "/usr/include/bits/mathcalls.h" 3 4
extern _Float32x lgammaf32x_r (_Float32x, int *__signgamp) noexcept (true); extern _Float32x __lgammaf32x_r (_Float32x, int *__signgamp) noexcept (true);






extern _Float32x rintf32x (_Float32x __x) noexcept (true); extern _Float32x __rintf32x (_Float32x __x) noexcept (true);


extern _Float32x nextafterf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __nextafterf32x (_Float32x __x, _Float32x __y) noexcept (true);






extern _Float32x nextdownf32x (_Float32x __x) noexcept (true); extern _Float32x __nextdownf32x (_Float32x __x) noexcept (true);

extern _Float32x nextupf32x (_Float32x __x) noexcept (true); extern _Float32x __nextupf32x (_Float32x __x) noexcept (true);



extern _Float32x remainderf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __remainderf32x (_Float32x __x, _Float32x __y) noexcept (true);



extern _Float32x scalbnf32x (_Float32x __x, int __n) noexcept (true); extern _Float32x __scalbnf32x (_Float32x __x, int __n) noexcept (true);



extern int ilogbf32x (_Float32x __x) noexcept (true); extern int __ilogbf32x (_Float32x __x) noexcept (true);




extern long int llogbf32x (_Float32x __x) noexcept (true); extern long int __llogbf32x (_Float32x __x) noexcept (true);




extern _Float32x scalblnf32x (_Float32x __x, long int __n) noexcept (true); extern _Float32x __scalblnf32x (_Float32x __x, long int __n) noexcept (true);



extern _Float32x nearbyintf32x (_Float32x __x) noexcept (true); extern _Float32x __nearbyintf32x (_Float32x __x) noexcept (true);



extern _Float32x roundf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); extern _Float32x __roundf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__));



extern _Float32x truncf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); extern _Float32x __truncf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__));




extern _Float32x remquof32x (_Float32x __x, _Float32x __y, int *__quo) noexcept (true); extern _Float32x __remquof32x (_Float32x __x, _Float32x __y, int *__quo) noexcept (true);






extern long int lrintf32x (_Float32x __x) noexcept (true); extern long int __lrintf32x (_Float32x __x) noexcept (true);
__extension__
extern long long int llrintf32x (_Float32x __x) noexcept (true); extern long long int __llrintf32x (_Float32x __x) noexcept (true);



extern long int lroundf32x (_Float32x __x) noexcept (true); extern long int __lroundf32x (_Float32x __x) noexcept (true);
__extension__
extern long long int llroundf32x (_Float32x __x) noexcept (true); extern long long int __llroundf32x (_Float32x __x) noexcept (true);



extern _Float32x fdimf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __fdimf32x (_Float32x __x, _Float32x __y) noexcept (true);



extern _Float32x fmaxf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fmaxf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__));


extern _Float32x fminf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fminf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__));



extern _Float32x fmaf32x (_Float32x __x, _Float32x __y, _Float32x __z) noexcept (true); extern _Float32x __fmaf32x (_Float32x __x, _Float32x __y, _Float32x __z) noexcept (true);




extern _Float32x roundevenf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); extern _Float32x __roundevenf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__));



extern __intmax_t fromfpf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true);




extern __uintmax_t ufromfpf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true);





extern __intmax_t fromfpxf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true);





extern __uintmax_t ufromfpxf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true);



extern int canonicalizef32x (_Float32x *__cx, const _Float32x *__x) noexcept (true);






extern _Float32x fmaxmagf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fmaxmagf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__));


extern _Float32x fminmagf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fminmagf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__));




extern _Float32x fmaximumf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fmaximumf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__));


extern _Float32x fminimumf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fminimumf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__));


extern _Float32x fmaximum_numf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fmaximum_numf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__));


extern _Float32x fminimum_numf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fminimum_numf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__));


extern _Float32x fmaximum_magf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fmaximum_magf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__));


extern _Float32x fminimum_magf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fminimum_magf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__));


extern _Float32x fmaximum_mag_numf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fmaximum_mag_numf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__));


extern _Float32x fminimum_mag_numf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fminimum_mag_numf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__));




extern int totalorderf32x (const _Float32x *__x, const _Float32x *__y) noexcept (true)

     __attribute__ ((__pure__));


extern int totalordermagf32x (const _Float32x *__x, const _Float32x *__y) noexcept (true)

     __attribute__ ((__pure__));


extern _Float32x getpayloadf32x (const _Float32x *__x) noexcept (true); extern _Float32x __getpayloadf32x (const _Float32x *__x) noexcept (true);


extern int setpayloadf32x (_Float32x *__x, _Float32x __payload) noexcept (true);


extern int setpayloadsigf32x (_Float32x *__x, _Float32x __payload) noexcept (true);
# 502 "/usr/include/math.h" 2 3 4
# 518 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls.h" 1 3 4
# 53 "/usr/include/bits/mathcalls.h" 3 4
 extern _Float64x acosf64x (_Float64x __x) noexcept (true); extern _Float64x __acosf64x (_Float64x __x) noexcept (true);

 extern _Float64x asinf64x (_Float64x __x) noexcept (true); extern _Float64x __asinf64x (_Float64x __x) noexcept (true);

 extern _Float64x atanf64x (_Float64x __x) noexcept (true); extern _Float64x __atanf64x (_Float64x __x) noexcept (true);

 extern _Float64x atan2f64x (_Float64x __y, _Float64x __x) noexcept (true); extern _Float64x __atan2f64x (_Float64x __y, _Float64x __x) noexcept (true);


 extern _Float64x cosf64x (_Float64x __x) noexcept (true); extern _Float64x __cosf64x (_Float64x __x) noexcept (true);

 extern _Float64x sinf64x (_Float64x __x) noexcept (true); extern _Float64x __sinf64x (_Float64x __x) noexcept (true);

 extern _Float64x tanf64x (_Float64x __x) noexcept (true); extern _Float64x __tanf64x (_Float64x __x) noexcept (true);




 extern _Float64x coshf64x (_Float64x __x) noexcept (true); extern _Float64x __coshf64x (_Float64x __x) noexcept (true);

 extern _Float64x sinhf64x (_Float64x __x) noexcept (true); extern _Float64x __sinhf64x (_Float64x __x) noexcept (true);

 extern _Float64x tanhf64x (_Float64x __x) noexcept (true); extern _Float64x __tanhf64x (_Float64x __x) noexcept (true);



 extern void sincosf64x (_Float64x __x, _Float64x *__sinx, _Float64x *__cosx) noexcept (true); extern void __sincosf64x (_Float64x __x, _Float64x *__sinx, _Float64x *__cosx) noexcept (true);





 extern _Float64x acoshf64x (_Float64x __x) noexcept (true); extern _Float64x __acoshf64x (_Float64x __x) noexcept (true);

 extern _Float64x asinhf64x (_Float64x __x) noexcept (true); extern _Float64x __asinhf64x (_Float64x __x) noexcept (true);

 extern _Float64x atanhf64x (_Float64x __x) noexcept (true); extern _Float64x __atanhf64x (_Float64x __x) noexcept (true);





 extern _Float64x expf64x (_Float64x __x) noexcept (true); extern _Float64x __expf64x (_Float64x __x) noexcept (true);


extern _Float64x frexpf64x (_Float64x __x, int *__exponent) noexcept (true); extern _Float64x __frexpf64x (_Float64x __x, int *__exponent) noexcept (true);


extern _Float64x ldexpf64x (_Float64x __x, int __exponent) noexcept (true); extern _Float64x __ldexpf64x (_Float64x __x, int __exponent) noexcept (true);


 extern _Float64x logf64x (_Float64x __x) noexcept (true); extern _Float64x __logf64x (_Float64x __x) noexcept (true);


 extern _Float64x log10f64x (_Float64x __x) noexcept (true); extern _Float64x __log10f64x (_Float64x __x) noexcept (true);


extern _Float64x modff64x (_Float64x __x, _Float64x *__iptr) noexcept (true); extern _Float64x __modff64x (_Float64x __x, _Float64x *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2)));



 extern _Float64x exp10f64x (_Float64x __x) noexcept (true); extern _Float64x __exp10f64x (_Float64x __x) noexcept (true);




 extern _Float64x expm1f64x (_Float64x __x) noexcept (true); extern _Float64x __expm1f64x (_Float64x __x) noexcept (true);


 extern _Float64x log1pf64x (_Float64x __x) noexcept (true); extern _Float64x __log1pf64x (_Float64x __x) noexcept (true);


extern _Float64x logbf64x (_Float64x __x) noexcept (true); extern _Float64x __logbf64x (_Float64x __x) noexcept (true);




 extern _Float64x exp2f64x (_Float64x __x) noexcept (true); extern _Float64x __exp2f64x (_Float64x __x) noexcept (true);


 extern _Float64x log2f64x (_Float64x __x) noexcept (true); extern _Float64x __log2f64x (_Float64x __x) noexcept (true);






 extern _Float64x powf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __powf64x (_Float64x __x, _Float64x __y) noexcept (true);


extern _Float64x sqrtf64x (_Float64x __x) noexcept (true); extern _Float64x __sqrtf64x (_Float64x __x) noexcept (true);



 extern _Float64x hypotf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __hypotf64x (_Float64x __x, _Float64x __y) noexcept (true);




 extern _Float64x cbrtf64x (_Float64x __x) noexcept (true); extern _Float64x __cbrtf64x (_Float64x __x) noexcept (true);






extern _Float64x ceilf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); extern _Float64x __ceilf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__));


extern _Float64x fabsf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fabsf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__));


extern _Float64x floorf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); extern _Float64x __floorf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__));


extern _Float64x fmodf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __fmodf64x (_Float64x __x, _Float64x __y) noexcept (true);
# 198 "/usr/include/bits/mathcalls.h" 3 4
extern _Float64x copysignf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __copysignf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__));




extern _Float64x nanf64x (const char *__tagb) noexcept (true); extern _Float64x __nanf64x (const char *__tagb) noexcept (true);
# 220 "/usr/include/bits/mathcalls.h" 3 4
extern _Float64x j0f64x (_Float64x) noexcept (true); extern _Float64x __j0f64x (_Float64x) noexcept (true);
extern _Float64x j1f64x (_Float64x) noexcept (true); extern _Float64x __j1f64x (_Float64x) noexcept (true);
extern _Float64x jnf64x (int, _Float64x) noexcept (true); extern _Float64x __jnf64x (int, _Float64x) noexcept (true);
extern _Float64x y0f64x (_Float64x) noexcept (true); extern _Float64x __y0f64x (_Float64x) noexcept (true);
extern _Float64x y1f64x (_Float64x) noexcept (true); extern _Float64x __y1f64x (_Float64x) noexcept (true);
extern _Float64x ynf64x (int, _Float64x) noexcept (true); extern _Float64x __ynf64x (int, _Float64x) noexcept (true);





 extern _Float64x erff64x (_Float64x) noexcept (true); extern _Float64x __erff64x (_Float64x) noexcept (true);
 extern _Float64x erfcf64x (_Float64x) noexcept (true); extern _Float64x __erfcf64x (_Float64x) noexcept (true);
extern _Float64x lgammaf64x (_Float64x) noexcept (true); extern _Float64x __lgammaf64x (_Float64x) noexcept (true);




extern _Float64x tgammaf64x (_Float64x) noexcept (true); extern _Float64x __tgammaf64x (_Float64x) noexcept (true);
# 252 "/usr/include/bits/mathcalls.h" 3 4
extern _Float64x lgammaf64x_r (_Float64x, int *__signgamp) noexcept (true); extern _Float64x __lgammaf64x_r (_Float64x, int *__signgamp) noexcept (true);






extern _Float64x rintf64x (_Float64x __x) noexcept (true); extern _Float64x __rintf64x (_Float64x __x) noexcept (true);


extern _Float64x nextafterf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __nextafterf64x (_Float64x __x, _Float64x __y) noexcept (true);






extern _Float64x nextdownf64x (_Float64x __x) noexcept (true); extern _Float64x __nextdownf64x (_Float64x __x) noexcept (true);

extern _Float64x nextupf64x (_Float64x __x) noexcept (true); extern _Float64x __nextupf64x (_Float64x __x) noexcept (true);



extern _Float64x remainderf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __remainderf64x (_Float64x __x, _Float64x __y) noexcept (true);



extern _Float64x scalbnf64x (_Float64x __x, int __n) noexcept (true); extern _Float64x __scalbnf64x (_Float64x __x, int __n) noexcept (true);



extern int ilogbf64x (_Float64x __x) noexcept (true); extern int __ilogbf64x (_Float64x __x) noexcept (true);




extern long int llogbf64x (_Float64x __x) noexcept (true); extern long int __llogbf64x (_Float64x __x) noexcept (true);




extern _Float64x scalblnf64x (_Float64x __x, long int __n) noexcept (true); extern _Float64x __scalblnf64x (_Float64x __x, long int __n) noexcept (true);



extern _Float64x nearbyintf64x (_Float64x __x) noexcept (true); extern _Float64x __nearbyintf64x (_Float64x __x) noexcept (true);



extern _Float64x roundf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); extern _Float64x __roundf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__));



extern _Float64x truncf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); extern _Float64x __truncf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__));




extern _Float64x remquof64x (_Float64x __x, _Float64x __y, int *__quo) noexcept (true); extern _Float64x __remquof64x (_Float64x __x, _Float64x __y, int *__quo) noexcept (true);






extern long int lrintf64x (_Float64x __x) noexcept (true); extern long int __lrintf64x (_Float64x __x) noexcept (true);
__extension__
extern long long int llrintf64x (_Float64x __x) noexcept (true); extern long long int __llrintf64x (_Float64x __x) noexcept (true);



extern long int lroundf64x (_Float64x __x) noexcept (true); extern long int __lroundf64x (_Float64x __x) noexcept (true);
__extension__
extern long long int llroundf64x (_Float64x __x) noexcept (true); extern long long int __llroundf64x (_Float64x __x) noexcept (true);



extern _Float64x fdimf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __fdimf64x (_Float64x __x, _Float64x __y) noexcept (true);



extern _Float64x fmaxf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fmaxf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__));


extern _Float64x fminf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fminf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__));



extern _Float64x fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) noexcept (true); extern _Float64x __fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) noexcept (true);




extern _Float64x roundevenf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); extern _Float64x __roundevenf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__));



extern __intmax_t fromfpf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true);




extern __uintmax_t ufromfpf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true);





extern __intmax_t fromfpxf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true);





extern __uintmax_t ufromfpxf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true);



extern int canonicalizef64x (_Float64x *__cx, const _Float64x *__x) noexcept (true);






extern _Float64x fmaxmagf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fmaxmagf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__));


extern _Float64x fminmagf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fminmagf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__));




extern _Float64x fmaximumf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fmaximumf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__));


extern _Float64x fminimumf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fminimumf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__));


extern _Float64x fmaximum_numf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fmaximum_numf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__));


extern _Float64x fminimum_numf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fminimum_numf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__));


extern _Float64x fmaximum_magf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fmaximum_magf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__));


extern _Float64x fminimum_magf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fminimum_magf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__));


extern _Float64x fmaximum_mag_numf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fmaximum_mag_numf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__));


extern _Float64x fminimum_mag_numf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fminimum_mag_numf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__));




extern int totalorderf64x (const _Float64x *__x, const _Float64x *__y) noexcept (true)

     __attribute__ ((__pure__));


extern int totalordermagf64x (const _Float64x *__x, const _Float64x *__y) noexcept (true)

     __attribute__ ((__pure__));


extern _Float64x getpayloadf64x (const _Float64x *__x) noexcept (true); extern _Float64x __getpayloadf64x (const _Float64x *__x) noexcept (true);


extern int setpayloadf64x (_Float64x *__x, _Float64x __payload) noexcept (true);


extern int setpayloadsigf64x (_Float64x *__x, _Float64x __payload) noexcept (true);
# 519 "/usr/include/math.h" 2 3 4
# 566 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4
# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4
extern float fadd (double __x, double __y) noexcept (true);


extern float fdiv (double __x, double __y) noexcept (true);


extern float ffma (double __x, double __y, double __z) noexcept (true);


extern float fmul (double __x, double __y) noexcept (true);


extern float fsqrt (double __x) noexcept (true);


extern float fsub (double __x, double __y) noexcept (true);
# 567 "/usr/include/math.h" 2 3 4
# 587 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4
# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4
extern float faddl (long double __x, long double __y) noexcept (true);


extern float fdivl (long double __x, long double __y) noexcept (true);


extern float ffmal (long double __x, long double __y, long double __z) noexcept (true);


extern float fmull (long double __x, long double __y) noexcept (true);


extern float fsqrtl (long double __x) noexcept (true);


extern float fsubl (long double __x, long double __y) noexcept (true);
# 588 "/usr/include/math.h" 2 3 4
# 616 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4
# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4
extern double daddl (long double __x, long double __y) noexcept (true);


extern double ddivl (long double __x, long double __y) noexcept (true);


extern double dfmal (long double __x, long double __y, long double __z) noexcept (true);


extern double dmull (long double __x, long double __y) noexcept (true);


extern double dsqrtl (long double __x) noexcept (true);


extern double dsubl (long double __x, long double __y) noexcept (true);
# 617 "/usr/include/math.h" 2 3 4
# 697 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4
# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4
extern _Float32 f32addf32x (_Float32x __x, _Float32x __y) noexcept (true);


extern _Float32 f32divf32x (_Float32x __x, _Float32x __y) noexcept (true);


extern _Float32 f32fmaf32x (_Float32x __x, _Float32x __y, _Float32x __z) noexcept (true);


extern _Float32 f32mulf32x (_Float32x __x, _Float32x __y) noexcept (true);


extern _Float32 f32sqrtf32x (_Float32x __x) noexcept (true);


extern _Float32 f32subf32x (_Float32x __x, _Float32x __y) noexcept (true);
# 698 "/usr/include/math.h" 2 3 4
# 707 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4
# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4
extern _Float32 f32addf64 (_Float64 __x, _Float64 __y) noexcept (true);


extern _Float32 f32divf64 (_Float64 __x, _Float64 __y) noexcept (true);


extern _Float32 f32fmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) noexcept (true);


extern _Float32 f32mulf64 (_Float64 __x, _Float64 __y) noexcept (true);


extern _Float32 f32sqrtf64 (_Float64 __x) noexcept (true);


extern _Float32 f32subf64 (_Float64 __x, _Float64 __y) noexcept (true);
# 708 "/usr/include/math.h" 2 3 4
# 717 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4
# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4
extern _Float32 f32addf64x (_Float64x __x, _Float64x __y) noexcept (true);


extern _Float32 f32divf64x (_Float64x __x, _Float64x __y) noexcept (true);


extern _Float32 f32fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) noexcept (true);


extern _Float32 f32mulf64x (_Float64x __x, _Float64x __y) noexcept (true);


extern _Float32 f32sqrtf64x (_Float64x __x) noexcept (true);


extern _Float32 f32subf64x (_Float64x __x, _Float64x __y) noexcept (true);
# 718 "/usr/include/math.h" 2 3 4
# 747 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4
# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4
extern _Float32x f32xaddf64 (_Float64 __x, _Float64 __y) noexcept (true);


extern _Float32x f32xdivf64 (_Float64 __x, _Float64 __y) noexcept (true);


extern _Float32x f32xfmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) noexcept (true);


extern _Float32x f32xmulf64 (_Float64 __x, _Float64 __y) noexcept (true);


extern _Float32x f32xsqrtf64 (_Float64 __x) noexcept (true);


extern _Float32x f32xsubf64 (_Float64 __x, _Float64 __y) noexcept (true);
# 748 "/usr/include/math.h" 2 3 4
# 757 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4
# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4
extern _Float32x f32xaddf64x (_Float64x __x, _Float64x __y) noexcept (true);


extern _Float32x f32xdivf64x (_Float64x __x, _Float64x __y) noexcept (true);


extern _Float32x f32xfmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) noexcept (true);


extern _Float32x f32xmulf64x (_Float64x __x, _Float64x __y) noexcept (true);


extern _Float32x f32xsqrtf64x (_Float64x __x) noexcept (true);


extern _Float32x f32xsubf64x (_Float64x __x, _Float64x __y) noexcept (true);
# 758 "/usr/include/math.h" 2 3 4
# 787 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4
# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4
extern _Float64 f64addf64x (_Float64x __x, _Float64x __y) noexcept (true);


extern _Float64 f64divf64x (_Float64x __x, _Float64x __y) noexcept (true);


extern _Float64 f64fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) noexcept (true);


extern _Float64 f64mulf64x (_Float64x __x, _Float64x __y) noexcept (true);


extern _Float64 f64sqrtf64x (_Float64x __x) noexcept (true);


extern _Float64 f64subf64x (_Float64x __x, _Float64x __y) noexcept (true);
# 788 "/usr/include/math.h" 2 3 4
# 854 "/usr/include/math.h" 3 4
extern int signgam;
# 934 "/usr/include/math.h" 3 4
enum
  {
    FP_NAN =

      0,
    FP_INFINITE =

      1,
    FP_ZERO =

      2,
    FP_SUBNORMAL =

      3,
    FP_NORMAL =

      4
  };
# 1055 "/usr/include/math.h" 3 4
# 1 "/usr/include/bits/iscanonical.h" 1 3 4
# 23 "/usr/include/bits/iscanonical.h" 3 4
extern int __iscanonicall (long double __x)
     noexcept (true) __attribute__ ((__const__));
# 46 "/usr/include/bits/iscanonical.h" 3 4
extern "C++" {
inline int iscanonical (float __val) { return ((void) (__typeof (__val)) (__val), 1); }
inline int iscanonical (double __val) { return ((void) (__typeof (__val)) (__val), 1); }
inline int iscanonical (long double __val) { return __iscanonicall (__val); }



}
# 1056 "/usr/include/math.h" 2 3 4
# 1067 "/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);

}





}
# 1098 "/usr/include/math.h" 3 4
extern "C++" {
# 1129 "/usr/include/math.h" 3 4
template <class __T> inline bool
iszero (__T __val)
{
  return __val == 0;
}

}
# 1364 "/usr/include/math.h" 3 4
extern "C++" {
template<typename> struct __iseqsig_type;

template<> struct __iseqsig_type<float>
{
  static int __call (float __x, float __y) throw ()
  {
    return __iseqsigf (__x, __y);
  }
};

template<> struct __iseqsig_type<double>
{
  static int __call (double __x, double __y) throw ()
  {
    return __iseqsig (__x, __y);
  }
};

template<> struct __iseqsig_type<long double>
{
  static int __call (long double __x, long double __y) throw ()
  {

    return __iseqsigl (__x, __y);



  }
};
# 1455 "/usr/include/math.h" 3 4
template<typename _T1, typename _T2>
inline int
iseqsig (_T1 __x, _T2 __y) throw ()
{

  typedef decltype (((__x) + (__y) + 0.0f)) _T3;



  return __iseqsig_type<_T3>::__call (__x, __y);
}

}




}
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cmath" 2 3








# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 57 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cmath" 2 3
# 83 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    acos(_Tp __x)
    { return __builtin_acos(__x); }

  using ::asin;


  inline constexpr float
  asin(float __x)
  { return __builtin_asinf(__x); }

  inline constexpr long double
  asin(long double __x)
  { return __builtin_asinl(__x); }


  template<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    asin(_Tp __x)
    { return __builtin_asin(__x); }

  using ::atan;


  inline constexpr float
  atan(float __x)
  { return __builtin_atanf(__x); }

  inline constexpr long double
  atan(long double __x)
  { return __builtin_atanl(__x); }


  template<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    atan(_Tp __x)
    { return __builtin_atan(__x); }

  using ::atan2;


  inline constexpr float
  atan2(float __y, float __x)
  { return __builtin_atan2f(__y, __x); }

  inline constexpr long double
  atan2(long double __y, long double __x)
  { return __builtin_atan2l(__y, __x); }


  using ::ceil;


  inline constexpr float
  ceil(float __x)
  { return __builtin_ceilf(__x); }

  inline constexpr long double
  ceil(long double __x)
  { return __builtin_ceill(__x); }


  template<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    ceil(_Tp __x)
    { return __builtin_ceil(__x); }

  using ::cos;


  inline constexpr float
  cos(float __x)
  { return __builtin_cosf(__x); }

  inline constexpr long double
  cos(long double __x)
  { return __builtin_cosl(__x); }


  template<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    cos(_Tp __x)
    { return __builtin_cos(__x); }

  using ::cosh;


  inline constexpr float
  cosh(float __x)
  { return __builtin_coshf(__x); }

  inline constexpr long double
  cosh(long double __x)
  { return __builtin_coshl(__x); }


  template<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    cosh(_Tp __x)
    { return __builtin_cosh(__x); }

  using ::exp;


  inline constexpr float
  exp(float __x)
  { return __builtin_expf(__x); }

  inline constexpr long double
  exp(long double __x)
  { return __builtin_expl(__x); }


  template<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    exp(_Tp __x)
    { return __builtin_exp(__x); }

  using ::fabs;


  inline constexpr float
  fabs(float __x)
  { return __builtin_fabsf(__x); }

  inline constexpr long double
  fabs(long double __x)
  { return __builtin_fabsl(__x); }


  template<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    fabs(_Tp __x)
    { return __builtin_fabs(__x); }

  using ::floor;


  inline constexpr float
  floor(float __x)
  { return __builtin_floorf(__x); }

  inline constexpr long double
  floor(long double __x)
  { return __builtin_floorl(__x); }


  template<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    floor(_Tp __x)
    { return __builtin_floor(__x); }

  using ::fmod;


  inline constexpr float
  fmod(float __x, float __y)
  { return __builtin_fmodf(__x, __y); }

  inline constexpr long double
  fmod(long double __x, long double __y)
  { return __builtin_fmodl(__x, __y); }


  using ::frexp;


  inline float
  frexp(float __x, int* __exp)
  { return __builtin_frexpf(__x, __exp); }

  inline long double
  frexp(long double __x, int* __exp)
  { return __builtin_frexpl(__x, __exp); }


  template<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    frexp(_Tp __x, int* __exp)
    { return __builtin_frexp(__x, __exp); }

  using ::ldexp;


  inline constexpr float
  ldexp(float __x, int __exp)
  { return __builtin_ldexpf(__x, __exp); }

  inline constexpr long double
  ldexp(long double __x, int __exp)
  { return __builtin_ldexpl(__x, __exp); }


  template<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    ldexp(_Tp __x, int __exp)
    { return __builtin_ldexp(__x, __exp); }

  using ::log;


  inline constexpr float
  log(float __x)
  { return __builtin_logf(__x); }

  inline constexpr long double
  log(long double __x)
  { return __builtin_logl(__x); }


  template<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    log(_Tp __x)
    { return __builtin_log(__x); }

  using ::log10;


  inline constexpr float
  log10(float __x)
  { return __builtin_log10f(__x); }

  inline constexpr long double
  log10(long double __x)
  { return __builtin_log10l(__x); }


  template<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    log10(_Tp __x)
    { return __builtin_log10(__x); }

  using ::modf;


  inline float
  modf(float __x, float* __iptr)
  { return __builtin_modff(__x, __iptr); }

  inline long double
  modf(long double __x, long double* __iptr)
  { return __builtin_modfl(__x, __iptr); }


  using ::pow;


  inline constexpr float
  pow(float __x, float __y)
  { return __builtin_powf(__x, __y); }

  inline constexpr long double
  pow(long double __x, long double __y)
  { return __builtin_powl(__x, __y); }
# 400 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cmath" 3
  using ::sin;


  inline constexpr float
  sin(float __x)
  { return __builtin_sinf(__x); }

  inline constexpr long double
  sin(long double __x)
  { return __builtin_sinl(__x); }


  template<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    sin(_Tp __x)
    { return __builtin_sin(__x); }

  using ::sinh;


  inline constexpr float
  sinh(float __x)
  { return __builtin_sinhf(__x); }

  inline constexpr long double
  sinh(long double __x)
  { return __builtin_sinhl(__x); }


  template<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    sinh(_Tp __x)
    { return __builtin_sinh(__x); }

  using ::sqrt;


  inline constexpr float
  sqrt(float __x)
  { return __builtin_sqrtf(__x); }

  inline constexpr long double
  sqrt(long double __x)
  { return __builtin_sqrtl(__x); }


  template<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    sqrt(_Tp __x)
    { return __builtin_sqrt(__x); }

  using ::tan;


  inline constexpr float
  tan(float __x)
  { return __builtin_tanf(__x); }

  inline constexpr long double
  tan(long double __x)
  { return __builtin_tanl(__x); }


  template<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    tan(_Tp __x)
    { return __builtin_tan(__x); }

  using ::tanh;


  inline constexpr float
  tanh(float __x)
  { return __builtin_tanhf(__x); }

  inline constexpr long double
  tanh(long double __x)
  { return __builtin_tanhl(__x); }


  template<typename _Tp>
    inline constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    double>::__type
    tanh(_Tp __x)
    { return __builtin_tanh(__x); }
# 1053 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cmath" 3
  template<typename _Tp, typename _Up>
    inline constexpr
    typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
    atan2(_Tp __y, _Up __x)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return atan2(__type(__y), __type(__x));
    }

  template<typename _Tp, typename _Up>
    inline constexpr
    typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
    fmod(_Tp __x, _Up __y)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return fmod(__type(__x), __type(__y));
    }

  template<typename _Tp, typename _Up>
    inline constexpr
    typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
    pow(_Tp __x, _Up __y)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return pow(__type(__x), __type(__y));
    }
# 1100 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              int>::__type
    fpclassify(_Tp __x)
    { return __x != 0 ? 4 : 2; }



  constexpr bool
  isfinite(float __x)
  { return __builtin_isfinite(__x); }

  constexpr bool
  isfinite(double __x)
  { return __builtin_isfinite(__x); }

  constexpr bool
  isfinite(long double __x)
  { return __builtin_isfinite(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              bool>::__type
    isfinite(_Tp)
    { return true; }



  constexpr bool
  isinf(float __x)
  { return __builtin_isinf(__x); }





  constexpr bool
  isinf(double __x)
  { return __builtin_isinf(__x); }


  constexpr bool
  isinf(long double __x)
  { return __builtin_isinf(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              bool>::__type
    isinf(_Tp)
    { return false; }



  constexpr bool
  isnan(float __x)
  { return __builtin_isnan(__x); }





  constexpr bool
  isnan(double __x)
  { return __builtin_isnan(__x); }


  constexpr bool
  isnan(long double __x)
  { return __builtin_isnan(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              bool>::__type
    isnan(_Tp)
    { return false; }



  constexpr bool
  isnormal(float __x)
  { return __builtin_isnormal(__x); }

  constexpr bool
  isnormal(double __x)
  { return __builtin_isnormal(__x); }

  constexpr bool
  isnormal(long double __x)
  { return __builtin_isnormal(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              bool>::__type
    isnormal(_Tp __x)
    { return __x != 0 ? true : false; }




  constexpr bool
  signbit(float __x)
  { return __builtin_signbit(__x); }

  constexpr bool
  signbit(double __x)
  { return __builtin_signbit(__x); }

  constexpr bool
  signbit(long double __x)
  { return __builtin_signbit(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              bool>::__type
    signbit(_Tp __x)
    { return __x < 0 ? true : false; }



  constexpr bool
  isgreater(float __x, float __y)
  { return __builtin_isgreater(__x, __y); }

  constexpr bool
  isgreater(double __x, double __y)
  { return __builtin_isgreater(__x, __y); }

  constexpr bool
  isgreater(long double __x, long double __y)
  { return __builtin_isgreater(__x, __y); }



  template<typename _Tp, typename _Up>
    constexpr typename
    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
       && __is_arithmetic<_Up>::__value), bool>::__type
    isgreater(_Tp __x, _Up __y)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return __builtin_isgreater(__type(__x), __type(__y));
    }



  constexpr bool
  isgreaterequal(float __x, float __y)
  { return __builtin_isgreaterequal(__x, __y); }

  constexpr bool
  isgreaterequal(double __x, double __y)
  { return __builtin_isgreaterequal(__x, __y); }

  constexpr bool
  isgreaterequal(long double __x, long double __y)
  { return __builtin_isgreaterequal(__x, __y); }



  template<typename _Tp, typename _Up>
    constexpr typename
    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
       && __is_arithmetic<_Up>::__value), bool>::__type
    isgreaterequal(_Tp __x, _Up __y)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return __builtin_isgreaterequal(__type(__x), __type(__y));
    }



  constexpr bool
  isless(float __x, float __y)
  { return __builtin_isless(__x, __y); }

  constexpr bool
  isless(double __x, double __y)
  { return __builtin_isless(__x, __y); }

  constexpr bool
  isless(long double __x, long double __y)
  { return __builtin_isless(__x, __y); }



  template<typename _Tp, typename _Up>
    constexpr typename
    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
       && __is_arithmetic<_Up>::__value), bool>::__type
    isless(_Tp __x, _Up __y)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return __builtin_isless(__type(__x), __type(__y));
    }



  constexpr bool
  islessequal(float __x, float __y)
  { return __builtin_islessequal(__x, __y); }

  constexpr bool
  islessequal(double __x, double __y)
  { return __builtin_islessequal(__x, __y); }

  constexpr bool
  islessequal(long double __x, long double __y)
  { return __builtin_islessequal(__x, __y); }



  template<typename _Tp, typename _Up>
    constexpr typename
    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
       && __is_arithmetic<_Up>::__value), bool>::__type
    islessequal(_Tp __x, _Up __y)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return __builtin_islessequal(__type(__x), __type(__y));
    }



  constexpr bool
  islessgreater(float __x, float __y)
  { return __builtin_islessgreater(__x, __y); }

  constexpr bool
  islessgreater(double __x, double __y)
  { return __builtin_islessgreater(__x, __y); }

  constexpr bool
  islessgreater(long double __x, long double __y)
  { return __builtin_islessgreater(__x, __y); }



  template<typename _Tp, typename _Up>
    constexpr typename
    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
       && __is_arithmetic<_Up>::__value), bool>::__type
    islessgreater(_Tp __x, _Up __y)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return __builtin_islessgreater(__type(__x), __type(__y));
    }



  constexpr bool
  isunordered(float __x, float __y)
  { return __builtin_isunordered(__x, __y); }

  constexpr bool
  isunordered(double __x, double __y)
  { return __builtin_isunordered(__x, __y); }

  constexpr bool
  isunordered(long double __x, long double __y)
  { return __builtin_isunordered(__x, __y); }



  template<typename _Tp, typename _Up>
    constexpr typename
    __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
       && __is_arithmetic<_Up>::__value), bool>::__type
    isunordered(_Tp __x, _Up __y)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return __builtin_isunordered(__type(__x), __type(__y));
    }
# 1820 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cmath" 3
  using ::acosf;


  using ::acosl;



  using ::asinf;


  using ::asinl;



  using ::atanf;


  using ::atanl;



  using ::atan2f;


  using ::atan2l;



  using ::ceilf;


  using ::ceill;



  using ::cosf;


  using ::cosl;



  using ::coshf;


  using ::coshl;



  using ::expf;


  using ::expl;



  using ::fabsf;


  using ::fabsl;



  using ::floorf;


  using ::floorl;



  using ::fmodf;


  using ::fmodl;



  using ::frexpf;


  using ::frexpl;



  using ::ldexpf;


  using ::ldexpl;



  using ::logf;


  using ::logl;



  using ::log10f;


  using ::log10l;



  using ::modff;


  using ::modfl;



  using ::powf;


  using ::powl;



  using ::sinf;


  using ::sinl;



  using ::sinhf;


  using ::sinhl;



  using ::sqrtf;


  using ::sqrtl;



  using ::tanf;


  using ::tanl;



  using ::tanhf;


  using ::tanhl;
# 2085 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    acosh(_Tp __x)
    { return __builtin_acosh(__x); }



  constexpr float
  asinh(float __x)
  { return __builtin_asinhf(__x); }

  constexpr long double
  asinh(long double __x)
  { return __builtin_asinhl(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    asinh(_Tp __x)
    { return __builtin_asinh(__x); }



  constexpr float
  atanh(float __x)
  { return __builtin_atanhf(__x); }

  constexpr long double
  atanh(long double __x)
  { return __builtin_atanhl(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    atanh(_Tp __x)
    { return __builtin_atanh(__x); }



  constexpr float
  cbrt(float __x)
  { return __builtin_cbrtf(__x); }

  constexpr long double
  cbrt(long double __x)
  { return __builtin_cbrtl(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    cbrt(_Tp __x)
    { return __builtin_cbrt(__x); }



  constexpr float
  copysign(float __x, float __y)
  { return __builtin_copysignf(__x, __y); }

  constexpr long double
  copysign(long double __x, long double __y)
  { return __builtin_copysignl(__x, __y); }



  constexpr float
  erf(float __x)
  { return __builtin_erff(__x); }

  constexpr long double
  erf(long double __x)
  { return __builtin_erfl(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    erf(_Tp __x)
    { return __builtin_erf(__x); }



  constexpr float
  erfc(float __x)
  { return __builtin_erfcf(__x); }

  constexpr long double
  erfc(long double __x)
  { return __builtin_erfcl(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    erfc(_Tp __x)
    { return __builtin_erfc(__x); }



  constexpr float
  exp2(float __x)
  { return __builtin_exp2f(__x); }

  constexpr long double
  exp2(long double __x)
  { return __builtin_exp2l(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    exp2(_Tp __x)
    { return __builtin_exp2(__x); }



  constexpr float
  expm1(float __x)
  { return __builtin_expm1f(__x); }

  constexpr long double
  expm1(long double __x)
  { return __builtin_expm1l(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    expm1(_Tp __x)
    { return __builtin_expm1(__x); }



  constexpr float
  fdim(float __x, float __y)
  { return __builtin_fdimf(__x, __y); }

  constexpr long double
  fdim(long double __x, long double __y)
  { return __builtin_fdiml(__x, __y); }



  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); }



  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); }



  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); }



  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); }



  constexpr int
  ilogb(float __x)
  { return __builtin_ilogbf(__x); }

  constexpr int
  ilogb(long double __x)
  { return __builtin_ilogbl(__x); }



  template<typename _Tp>
    constexpr
    typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                    int>::__type
    ilogb(_Tp __x)
    { return __builtin_ilogb(__x); }



  constexpr float
  lgamma(float __x)
  { return __builtin_lgammaf(__x); }

  constexpr long double
  lgamma(long double __x)
  { return __builtin_lgammal(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    lgamma(_Tp __x)
    { return __builtin_lgamma(__x); }



  constexpr long long
  llrint(float __x)
  { return __builtin_llrintf(__x); }

  constexpr long long
  llrint(long double __x)
  { return __builtin_llrintl(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              long long>::__type
    llrint(_Tp __x)
    { return __builtin_llrint(__x); }



  constexpr long long
  llround(float __x)
  { return __builtin_llroundf(__x); }

  constexpr long long
  llround(long double __x)
  { return __builtin_llroundl(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              long long>::__type
    llround(_Tp __x)
    { return __builtin_llround(__x); }



  constexpr float
  log1p(float __x)
  { return __builtin_log1pf(__x); }

  constexpr long double
  log1p(long double __x)
  { return __builtin_log1pl(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    log1p(_Tp __x)
    { return __builtin_log1p(__x); }




  constexpr float
  log2(float __x)
  { return __builtin_log2f(__x); }

  constexpr long double
  log2(long double __x)
  { return __builtin_log2l(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    log2(_Tp __x)
    { return __builtin_log2(__x); }



  constexpr float
  logb(float __x)
  { return __builtin_logbf(__x); }

  constexpr long double
  logb(long double __x)
  { return __builtin_logbl(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    logb(_Tp __x)
    { return __builtin_logb(__x); }



  constexpr long
  lrint(float __x)
  { return __builtin_lrintf(__x); }

  constexpr long
  lrint(long double __x)
  { return __builtin_lrintl(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              long>::__type
    lrint(_Tp __x)
    { return __builtin_lrint(__x); }



  constexpr long
  lround(float __x)
  { return __builtin_lroundf(__x); }

  constexpr long
  lround(long double __x)
  { return __builtin_lroundl(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              long>::__type
    lround(_Tp __x)
    { return __builtin_lround(__x); }



  constexpr float
  nearbyint(float __x)
  { return __builtin_nearbyintf(__x); }

  constexpr long double
  nearbyint(long double __x)
  { return __builtin_nearbyintl(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    nearbyint(_Tp __x)
    { return __builtin_nearbyint(__x); }



  constexpr float
  nextafter(float __x, float __y)
  { return __builtin_nextafterf(__x, __y); }

  constexpr long double
  nextafter(long double __x, long double __y)
  { return __builtin_nextafterl(__x, __y); }



  constexpr float
  nexttoward(float __x, long double __y)
  { return __builtin_nexttowardf(__x, __y); }

  constexpr long double
  nexttoward(long double __x, long double __y)
  { return __builtin_nexttowardl(__x, __y); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    nexttoward(_Tp __x, long double __y)
    { return __builtin_nexttoward(__x, __y); }



  constexpr float
  remainder(float __x, float __y)
  { return __builtin_remainderf(__x, __y); }

  constexpr long double
  remainder(long double __x, long double __y)
  { return __builtin_remainderl(__x, __y); }



  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); }



  constexpr float
  rint(float __x)
  { return __builtin_rintf(__x); }

  constexpr long double
  rint(long double __x)
  { return __builtin_rintl(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    rint(_Tp __x)
    { return __builtin_rint(__x); }



  constexpr float
  round(float __x)
  { return __builtin_roundf(__x); }

  constexpr long double
  round(long double __x)
  { return __builtin_roundl(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    round(_Tp __x)
    { return __builtin_round(__x); }



  constexpr float
  scalbln(float __x, long __ex)
  { return __builtin_scalblnf(__x, __ex); }

  constexpr long double
  scalbln(long double __x, long __ex)
  { return __builtin_scalblnl(__x, __ex); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    scalbln(_Tp __x, long __ex)
    { return __builtin_scalbln(__x, __ex); }



  constexpr float
  scalbn(float __x, int __ex)
  { return __builtin_scalbnf(__x, __ex); }

  constexpr long double
  scalbn(long double __x, int __ex)
  { return __builtin_scalbnl(__x, __ex); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    scalbn(_Tp __x, int __ex)
    { return __builtin_scalbn(__x, __ex); }



  constexpr float
  tgamma(float __x)
  { return __builtin_tgammaf(__x); }

  constexpr long double
  tgamma(long double __x)
  { return __builtin_tgammal(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    tgamma(_Tp __x)
    { return __builtin_tgamma(__x); }



  constexpr float
  trunc(float __x)
  { return __builtin_truncf(__x); }

  constexpr long double
  trunc(long double __x)
  { return __builtin_truncl(__x); }



  template<typename _Tp>
    constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
                                              double>::__type
    trunc(_Tp __x)
    { return __builtin_trunc(__x); }
# 3674 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cmath" 3
  template<typename _Tp, typename _Up>
    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
    copysign(_Tp __x, _Up __y)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return copysign(__type(__x), __type(__y));
    }

  template<typename _Tp, typename _Up>
    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
    fdim(_Tp __x, _Up __y)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return fdim(__type(__x), __type(__y));
    }

  template<typename _Tp, typename _Up>
    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
    fmax(_Tp __x, _Up __y)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return fmax(__type(__x), __type(__y));
    }

  template<typename _Tp, typename _Up>
    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
    fmin(_Tp __x, _Up __y)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return fmin(__type(__x), __type(__y));
    }

  template<typename _Tp, typename _Up>
    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
    hypot(_Tp __x, _Up __y)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return hypot(__type(__x), __type(__y));
    }

  template<typename _Tp, typename _Up>
    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
    nextafter(_Tp __x, _Up __y)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return nextafter(__type(__x), __type(__y));
    }

  template<typename _Tp, typename _Up>
    constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
    remainder(_Tp __x, _Up __y)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return remainder(__type(__x), __type(__y));
    }

  template<typename _Tp, typename _Up>
    inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
    remquo(_Tp __x, _Up __y, int* __pquo)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
      return remquo(__type(__x), __type(__y), __pquo);
    }

  template<typename _Tp, typename _Up, typename _Vp>
    constexpr typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type
    fma(_Tp __x, _Up __y, _Vp __z)
    {
      typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type;
      return fma(__type(__x), __type(__y), __type(__z));
    }







  template<typename _Tp>
    inline _Tp
    __hypot3(_Tp __x, _Tp __y, _Tp __z)
    {
      __x = std::abs(__x);
      __y = std::abs(__y);
      __z = std::abs(__z);
      if (_Tp __a = __x < __y ? __y < __z ? __z : __y : __x < __z ? __z : __x)
 return __a * std::sqrt((__x / __a) * (__x / __a)
          + (__y / __a) * (__y / __a)
          + (__z / __a) * (__z / __a));
      else
 return {};
    }

  inline float
  hypot(float __x, float __y, float __z)
  { return std::__hypot3<float>(__x, __y, __z); }

  inline double
  hypot(double __x, double __y, double __z)
  { return std::__hypot3<double>(__x, __y, __z); }

  inline long double
  hypot(long double __x, long double __y, long double __z)
  { return std::__hypot3<long double>(__x, __y, __z); }

  template<typename _Tp, typename _Up, typename _Vp>
    __gnu_cxx::__promoted_t<_Tp, _Up, _Vp>
    hypot(_Tp __x, _Up __y, _Vp __z)
    {
      using __type = __gnu_cxx::__promoted_t<_Tp, _Up, _Vp>;
      return std::__hypot3<__type>(__x, __y, __z);
    }
# 3823 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cmath" 3
  template<typename _Fp>
    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); }

  template<typename _Tp, typename _Up, typename _Vp>
    constexpr __gnu_cxx::__promoted_t<_Tp, _Up, _Vp>
    lerp(_Tp __x, _Up __y, _Vp __z) noexcept
    {
      using __type = __gnu_cxx::__promoted_t<_Tp, _Up, _Vp>;
      return std::__lerp<__type>(__x, __y, __z);
    }
# 3895 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cmath" 3
}


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 1 3
# 37 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 38 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 2 3
# 47 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/gamma.tcc" 1 3
# 49 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/gamma.tcc" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/special_function_util.h" 1 3
# 39 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/special_function_util.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 50 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/special_function_util.h" 3
  namespace __detail
  {



    template<typename _Tp>
    struct __floating_point_constant
    {
      static const _Tp __value;
    };



    template<typename _Tp>
      struct __numeric_constants
      {

        static _Tp __pi() throw()
        { return static_cast<_Tp>(3.1415926535897932384626433832795029L); }

        static _Tp __pi_2() throw()
        { return static_cast<_Tp>(1.5707963267948966192313216916397514L); }

        static _Tp __pi_3() throw()
        { return static_cast<_Tp>(1.0471975511965977461542144610931676L); }

        static _Tp __pi_4() throw()
        { return static_cast<_Tp>(0.7853981633974483096156608458198757L); }

        static _Tp __1_pi() throw()
        { return static_cast<_Tp>(0.3183098861837906715377675267450287L); }

        static _Tp __2_sqrtpi() throw()
        { return static_cast<_Tp>(1.1283791670955125738961589031215452L); }

        static _Tp __sqrt2() throw()
        { return static_cast<_Tp>(1.4142135623730950488016887242096981L); }

        static _Tp __sqrt3() throw()
        { return static_cast<_Tp>(1.7320508075688772935274463415058723L); }

        static _Tp __sqrtpio2() throw()
        { return static_cast<_Tp>(1.2533141373155002512078826424055226L); }

        static _Tp __sqrt1_2() throw()
        { return static_cast<_Tp>(0.7071067811865475244008443621048490L); }

        static _Tp __lnpi() throw()
        { return static_cast<_Tp>(1.1447298858494001741434273513530587L); }

        static _Tp __gamma_e() throw()
        { return static_cast<_Tp>(0.5772156649015328606065120900824024L); }

        static _Tp __euler() throw()
        { return static_cast<_Tp>(2.7182818284590452353602874713526625L); }
      };
# 114 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/special_function_util.h" 3
    template<typename _Tp>
    inline bool __isnan(_Tp __x)
    { return std::isnan(__x); }
# 133 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/special_function_util.h" 3
  }





}
# 50 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/gamma.tcc" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{
# 65 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/gamma.tcc" 3
  namespace __detail
  {
# 76 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/gamma.tcc" 3
    template <typename _Tp>
    _Tp
    __bernoulli_series(unsigned int __n)
    {

      static const _Tp __num[28] = {
        _Tp(1UL), -_Tp(1UL) / _Tp(2UL),
        _Tp(1UL) / _Tp(6UL), _Tp(0UL),
        -_Tp(1UL) / _Tp(30UL), _Tp(0UL),
        _Tp(1UL) / _Tp(42UL), _Tp(0UL),
        -_Tp(1UL) / _Tp(30UL), _Tp(0UL),
        _Tp(5UL) / _Tp(66UL), _Tp(0UL),
        -_Tp(691UL) / _Tp(2730UL), _Tp(0UL),
        _Tp(7UL) / _Tp(6UL), _Tp(0UL),
        -_Tp(3617UL) / _Tp(510UL), _Tp(0UL),
        _Tp(43867UL) / _Tp(798UL), _Tp(0UL),
        -_Tp(174611) / _Tp(330UL), _Tp(0UL),
        _Tp(854513UL) / _Tp(138UL), _Tp(0UL),
        -_Tp(236364091UL) / _Tp(2730UL), _Tp(0UL),
        _Tp(8553103UL) / _Tp(6UL), _Tp(0UL)
      };

      if (__n == 0)
        return _Tp(1);

      if (__n == 1)
        return -_Tp(1) / _Tp(2);


      if (__n % 2 == 1)
        return _Tp(0);


      if (__n < 28)
        return __num[__n];


      _Tp __fact = _Tp(1);
      if ((__n / 2) % 2 == 0)
        __fact *= _Tp(-1);
      for (unsigned int __k = 1; __k <= __n; ++__k)
        __fact *= __k / (_Tp(2) * __numeric_constants<_Tp>::__pi());
      __fact *= _Tp(2);

      _Tp __sum = _Tp(0);
      for (unsigned int __i = 1; __i < 1000; ++__i)
        {
          _Tp __term = std::pow(_Tp(__i), -_Tp(__n));
          if (__term < std::numeric_limits<_Tp>::epsilon())
            break;
          __sum += __term;
        }

      return __fact * __sum;
    }
# 139 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/gamma.tcc" 3
    template<typename _Tp>
    inline _Tp
    __bernoulli(int __n)
    { return __bernoulli_series<_Tp>(__n); }
# 153 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/gamma.tcc" 3
    template<typename _Tp>
    _Tp
    __log_gamma_bernoulli(_Tp __x)
    {
      _Tp __lg = (__x - _Tp(0.5L)) * std::log(__x) - __x
               + _Tp(0.5L) * std::log(_Tp(2)
               * __numeric_constants<_Tp>::__pi());

      const _Tp __xx = __x * __x;
      _Tp __help = _Tp(1) / __x;
      for ( unsigned int __i = 1; __i < 20; ++__i )
        {
          const _Tp __2i = _Tp(2 * __i);
          __help /= __2i * (__2i - _Tp(1)) * __xx;
          __lg += __bernoulli<_Tp>(2 * __i) * __help;
        }

      return __lg;
    }
# 181 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/gamma.tcc" 3
    template<typename _Tp>
    _Tp
    __log_gamma_lanczos(_Tp __x)
    {
      const _Tp __xm1 = __x - _Tp(1);

      static const _Tp __lanczos_cheb_7[9] = {
       _Tp( 0.99999999999980993227684700473478L),
       _Tp( 676.520368121885098567009190444019L),
       _Tp(-1259.13921672240287047156078755283L),
       _Tp( 771.3234287776530788486528258894L),
       _Tp(-176.61502916214059906584551354L),
       _Tp( 12.507343278686904814458936853L),
       _Tp(-0.13857109526572011689554707L),
       _Tp( 9.984369578019570859563e-6L),
       _Tp( 1.50563273514931155834e-7L)
      };

      static const _Tp __LOGROOT2PI
          = _Tp(0.9189385332046727417803297364056176L);

      _Tp __sum = __lanczos_cheb_7[0];
      for(unsigned int __k = 1; __k < 9; ++__k)
        __sum += __lanczos_cheb_7[__k] / (__xm1 + __k);

      const _Tp __term1 = (__xm1 + _Tp(0.5L))
                        * std::log((__xm1 + _Tp(7.5L))
                       / __numeric_constants<_Tp>::__euler());
      const _Tp __term2 = __LOGROOT2PI + std::log(__sum);
      const _Tp __result = __term1 + (__term2 - _Tp(7));

      return __result;
    }
# 225 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/gamma.tcc" 3
    template<typename _Tp>
    _Tp
    __log_gamma(_Tp __x)
    {
      if (__x > _Tp(0.5L))
        return __log_gamma_lanczos(__x);
      else
        {
          const _Tp __sin_fact
                 = std::abs(std::sin(__numeric_constants<_Tp>::__pi() * __x));
          if (__sin_fact == _Tp(0))
            std::__throw_domain_error(("Argument is nonpositive integer " "in __log_gamma"));

          return __numeric_constants<_Tp>::__lnpi()
                     - std::log(__sin_fact)
                     - __log_gamma_lanczos(_Tp(1) - __x);
        }
    }
# 252 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/gamma.tcc" 3
    template<typename _Tp>
    _Tp
    __log_gamma_sign(_Tp __x)
    {
      if (__x > _Tp(0))
        return _Tp(1);
      else
        {
          const _Tp __sin_fact
                  = std::sin(__numeric_constants<_Tp>::__pi() * __x);
          if (__sin_fact > _Tp(0))
            return (1);
          else if (__sin_fact < _Tp(0))
            return -_Tp(1);
          else
            return _Tp(0);
        }
    }
# 283 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/gamma.tcc" 3
    template<typename _Tp>
    _Tp
    __log_bincoef(unsigned int __n, unsigned int __k)
    {

      static const _Tp __max_bincoeff
                      = std::numeric_limits<_Tp>::max_exponent10
                      * std::log(_Tp(10)) - _Tp(1);

      _Tp __coeff = ::std::lgamma(_Tp(1 + __n))
                  - ::std::lgamma(_Tp(1 + __k))
                  - ::std::lgamma(_Tp(1 + __n - __k));





    }
# 314 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/gamma.tcc" 3
    template<typename _Tp>
    _Tp
    __bincoef(unsigned int __n, unsigned int __k)
    {

      static const _Tp __max_bincoeff
                      = std::numeric_limits<_Tp>::max_exponent10
                      * std::log(_Tp(10)) - _Tp(1);

      const _Tp __log_coeff = __log_bincoef<_Tp>(__n, __k);
      if (__log_coeff > __max_bincoeff)
        return std::numeric_limits<_Tp>::quiet_NaN();
      else
        return std::exp(__log_coeff);
    }
# 337 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/gamma.tcc" 3
    template<typename _Tp>
    inline _Tp
    __gamma(_Tp __x)
    { return std::exp(__log_gamma(__x)); }
# 356 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/gamma.tcc" 3
    template<typename _Tp>
    _Tp
    __psi_series(_Tp __x)
    {
      _Tp __sum = -__numeric_constants<_Tp>::__gamma_e() - _Tp(1) / __x;
      const unsigned int __max_iter = 100000;
      for (unsigned int __k = 1; __k < __max_iter; ++__k)
        {
          const _Tp __term = __x / (__k * (__k + __x));
          __sum += __term;
          if (std::abs(__term / __sum) < std::numeric_limits<_Tp>::epsilon())
            break;
        }
      return __sum;
    }
# 386 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/gamma.tcc" 3
    template<typename _Tp>
    _Tp
    __psi_asymp(_Tp __x)
    {
      _Tp __sum = std::log(__x) - _Tp(0.5L) / __x;
      const _Tp __xx = __x * __x;
      _Tp __xp = __xx;
      const unsigned int __max_iter = 100;
      for (unsigned int __k = 1; __k < __max_iter; ++__k)
        {
          const _Tp __term = __bernoulli<_Tp>(2 * __k) / (2 * __k * __xp);
          __sum -= __term;
          if (std::abs(__term / __sum) < std::numeric_limits<_Tp>::epsilon())
            break;
          __xp *= __xx;
        }
      return __sum;
    }
# 417 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/gamma.tcc" 3
    template<typename _Tp>
    _Tp
    __psi(_Tp __x)
    {
      const int __n = static_cast<int>(__x + 0.5L);
      const _Tp __eps = _Tp(4) * std::numeric_limits<_Tp>::epsilon();
      if (__n <= 0 && std::abs(__x - _Tp(__n)) < __eps)
        return std::numeric_limits<_Tp>::quiet_NaN();
      else if (__x < _Tp(0))
        {
          const _Tp __pi = __numeric_constants<_Tp>::__pi();
          return __psi(_Tp(1) - __x)
               - __pi * std::cos(__pi * __x) / std::sin(__pi * __x);
        }
      else if (__x > _Tp(100))
        return __psi_asymp(__x);
      else
        return __psi_series(__x);
    }
# 446 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/gamma.tcc" 3
    template<typename _Tp>
    _Tp
    __psi(unsigned int __n, _Tp __x)
    {
      if (__x <= _Tp(0))
        std::__throw_domain_error(("Argument out of range " "in __psi"));

      else if (__n == 0)
        return __psi(__x);
      else
        {
          const _Tp __hzeta = __hurwitz_zeta(_Tp(__n + 1), __x);

          const _Tp __ln_nfact = ::std::lgamma(_Tp(__n + 1));



          _Tp __result = std::exp(__ln_nfact) * __hzeta;
          if (__n % 2 == 1)
            __result = -__result;
          return __result;
        }
    }
  }






}
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/bessel_function.tcc" 1 3
# 55 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/bessel_function.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 71 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/bessel_function.tcc" 3
  namespace __detail
  {
# 98 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/bessel_function.tcc" 3
    template <typename _Tp>
    void
    __gamma_temme(_Tp __mu,
                  _Tp & __gam1, _Tp & __gam2, _Tp & __gampl, _Tp & __gammi)
    {

      __gampl = _Tp(1) / ::std::tgamma(_Tp(1) + __mu);
      __gammi = _Tp(1) / ::std::tgamma(_Tp(1) - __mu);





      if (std::abs(__mu) < std::numeric_limits<_Tp>::epsilon())
        __gam1 = -_Tp(__numeric_constants<_Tp>::__gamma_e());
      else
        __gam1 = (__gammi - __gampl) / (_Tp(2) * __mu);

      __gam2 = (__gammi + __gampl) / (_Tp(2));

      return;
    }
# 136 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/bessel_function.tcc" 3
    template <typename _Tp>
    void
    __bessel_jn(_Tp __nu, _Tp __x,
                _Tp & __Jnu, _Tp & __Nnu, _Tp & __Jpnu, _Tp & __Npnu)
    {
      if (__x == _Tp(0))
        {
          if (__nu == _Tp(0))
            {
              __Jnu = _Tp(1);
              __Jpnu = _Tp(0);
            }
          else if (__nu == _Tp(1))
            {
              __Jnu = _Tp(0);
              __Jpnu = _Tp(0.5L);
            }
          else
            {
              __Jnu = _Tp(0);
              __Jpnu = _Tp(0);
            }
          __Nnu = -std::numeric_limits<_Tp>::infinity();
          __Npnu = std::numeric_limits<_Tp>::infinity();
          return;
        }

      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();




      const _Tp __fp_min = std::sqrt(std::numeric_limits<_Tp>::min());
      const int __max_iter = 15000;
      const _Tp __x_min = _Tp(2);

      const int __nl = (__x < __x_min
                    ? static_cast<int>(__nu + _Tp(0.5L))
                    : std::max(0, static_cast<int>(__nu - __x + _Tp(1.5L))));

      const _Tp __mu = __nu - __nl;
      const _Tp __mu2 = __mu * __mu;
      const _Tp __xi = _Tp(1) / __x;
      const _Tp __xi2 = _Tp(2) * __xi;
      _Tp __w = __xi2 / __numeric_constants<_Tp>::__pi();
      int __isign = 1;
      _Tp __h = __nu * __xi;
      if (__h < __fp_min)
        __h = __fp_min;
      _Tp __b = __xi2 * __nu;
      _Tp __d = _Tp(0);
      _Tp __c = __h;
      int __i;
      for (__i = 1; __i <= __max_iter; ++__i)
        {
          __b += __xi2;
          __d = __b - __d;
          if (std::abs(__d) < __fp_min)
            __d = __fp_min;
          __c = __b - _Tp(1) / __c;
          if (std::abs(__c) < __fp_min)
            __c = __fp_min;
          __d = _Tp(1) / __d;
          const _Tp __del = __c * __d;
          __h *= __del;
          if (__d < _Tp(0))
            __isign = -__isign;
          if (std::abs(__del - _Tp(1)) < __eps)
            break;
        }
      if (__i > __max_iter)
        std::__throw_runtime_error(("Argument x too large in __bessel_jn; " "try asymptotic expansion."));

      _Tp __Jnul = __isign * __fp_min;
      _Tp __Jpnul = __h * __Jnul;
      _Tp __Jnul1 = __Jnul;
      _Tp __Jpnu1 = __Jpnul;
      _Tp __fact = __nu * __xi;
      for ( int __l = __nl; __l >= 1; --__l )
        {
          const _Tp __Jnutemp = __fact * __Jnul + __Jpnul;
          __fact -= __xi;
          __Jpnul = __fact * __Jnutemp - __Jnul;
          __Jnul = __Jnutemp;
        }
      if (__Jnul == _Tp(0))
        __Jnul = __eps;
      _Tp __f= __Jpnul / __Jnul;
      _Tp __Nmu, __Nnu1, __Npmu, __Jmu;
      if (__x < __x_min)
        {
          const _Tp __x2 = __x / _Tp(2);
          const _Tp __pimu = __numeric_constants<_Tp>::__pi() * __mu;
          _Tp __fact = (std::abs(__pimu) < __eps
                      ? _Tp(1) : __pimu / std::sin(__pimu));
          _Tp __d = -std::log(__x2);
          _Tp __e = __mu * __d;
          _Tp __fact2 = (std::abs(__e) < __eps
                       ? _Tp(1) : std::sinh(__e) / __e);
          _Tp __gam1, __gam2, __gampl, __gammi;
          __gamma_temme(__mu, __gam1, __gam2, __gampl, __gammi);
          _Tp __ff = (_Tp(2) / __numeric_constants<_Tp>::__pi())
                   * __fact * (__gam1 * std::cosh(__e) + __gam2 * __fact2 * __d);
          __e = std::exp(__e);
          _Tp __p = __e / (__numeric_constants<_Tp>::__pi() * __gampl);
          _Tp __q = _Tp(1) / (__e * __numeric_constants<_Tp>::__pi() * __gammi);
          const _Tp __pimu2 = __pimu / _Tp(2);
          _Tp __fact3 = (std::abs(__pimu2) < __eps
                       ? _Tp(1) : std::sin(__pimu2) / __pimu2 );
          _Tp __r = __numeric_constants<_Tp>::__pi() * __pimu2 * __fact3 * __fact3;
          _Tp __c = _Tp(1);
          __d = -__x2 * __x2;
          _Tp __sum = __ff + __r * __q;
          _Tp __sum1 = __p;
          for (__i = 1; __i <= __max_iter; ++__i)
            {
              __ff = (__i * __ff + __p + __q) / (__i * __i - __mu2);
              __c *= __d / _Tp(__i);
              __p /= _Tp(__i) - __mu;
              __q /= _Tp(__i) + __mu;
              const _Tp __del = __c * (__ff + __r * __q);
              __sum += __del;
              const _Tp __del1 = __c * __p - __i * __del;
              __sum1 += __del1;
              if ( std::abs(__del) < __eps * (_Tp(1) + std::abs(__sum)) )
                break;
            }
          if ( __i > __max_iter )
            std::__throw_runtime_error(("Bessel y series failed to converge " "in __bessel_jn."));

          __Nmu = -__sum;
          __Nnu1 = -__sum1 * __xi2;
          __Npmu = __mu * __xi * __Nmu - __Nnu1;
          __Jmu = __w / (__Npmu - __f * __Nmu);
        }
      else
        {
          _Tp __a = _Tp(0.25L) - __mu2;
          _Tp __q = _Tp(1);
          _Tp __p = -__xi / _Tp(2);
          _Tp __br = _Tp(2) * __x;
          _Tp __bi = _Tp(2);
          _Tp __fact = __a * __xi / (__p * __p + __q * __q);
          _Tp __cr = __br + __q * __fact;
          _Tp __ci = __bi + __p * __fact;
          _Tp __den = __br * __br + __bi * __bi;
          _Tp __dr = __br / __den;
          _Tp __di = -__bi / __den;
          _Tp __dlr = __cr * __dr - __ci * __di;
          _Tp __dli = __cr * __di + __ci * __dr;
          _Tp __temp = __p * __dlr - __q * __dli;
          __q = __p * __dli + __q * __dlr;
          __p = __temp;
          int __i;
          for (__i = 2; __i <= __max_iter; ++__i)
            {
              __a += _Tp(2 * (__i - 1));
              __bi += _Tp(2);
              __dr = __a * __dr + __br;
              __di = __a * __di + __bi;
              if (std::abs(__dr) + std::abs(__di) < __fp_min)
                __dr = __fp_min;
              __fact = __a / (__cr * __cr + __ci * __ci);
              __cr = __br + __cr * __fact;
              __ci = __bi - __ci * __fact;
              if (std::abs(__cr) + std::abs(__ci) < __fp_min)
                __cr = __fp_min;
              __den = __dr * __dr + __di * __di;
              __dr /= __den;
              __di /= -__den;
              __dlr = __cr * __dr - __ci * __di;
              __dli = __cr * __di + __ci * __dr;
              __temp = __p * __dlr - __q * __dli;
              __q = __p * __dli + __q * __dlr;
              __p = __temp;
              if (std::abs(__dlr - _Tp(1)) + std::abs(__dli) < __eps)
                break;
          }
          if (__i > __max_iter)
            std::__throw_runtime_error(("Lentz's method failed " "in __bessel_jn."));

          const _Tp __gam = (__p - __f) / __q;
          __Jmu = std::sqrt(__w / ((__p - __f) * __gam + __q));

          __Jmu = ::std::copysign(__Jmu, __Jnul);




          __Nmu = __gam * __Jmu;
          __Npmu = (__p + __q / __gam) * __Nmu;
          __Nnu1 = __mu * __xi * __Nmu - __Npmu;
      }
      __fact = __Jmu / __Jnul;
      __Jnu = __fact * __Jnul1;
      __Jpnu = __fact * __Jpnu1;
      for (__i = 1; __i <= __nl; ++__i)
        {
          const _Tp __Nnutemp = (__mu + __i) * __xi2 * __Nnu1 - __Nmu;
          __Nmu = __Nnu1;
          __Nnu1 = __Nnutemp;
        }
      __Nnu = __Nmu;
      __Npnu = __nu * __xi * __Nmu - __Nnu1;

      return;
    }
# 361 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/bessel_function.tcc" 3
    template <typename _Tp>
    void
    __cyl_bessel_jn_asymp(_Tp __nu, _Tp __x, _Tp & __Jnu, _Tp & __Nnu)
    {
      const _Tp __mu = _Tp(4) * __nu * __nu;
      const _Tp __8x = _Tp(8) * __x;

      _Tp __P = _Tp(0);
      _Tp __Q = _Tp(0);

      _Tp __k = _Tp(0);
      _Tp __term = _Tp(1);

      int __epsP = 0;
      int __epsQ = 0;

      _Tp __eps = std::numeric_limits<_Tp>::epsilon();

      do
        {
          __term *= (__k == 0
                     ? _Tp(1)
                     : -(__mu - (2 * __k - 1) * (2 * __k - 1)) / (__k * __8x));

          __epsP = std::abs(__term) < __eps * std::abs(__P);
          __P += __term;

          __k++;

          __term *= (__mu - (2 * __k - 1) * (2 * __k - 1)) / (__k * __8x);
          __epsQ = std::abs(__term) < __eps * std::abs(__Q);
          __Q += __term;

          if (__epsP && __epsQ && __k > (__nu / 2.))
            break;

          __k++;
        }
      while (__k < 1000);

      const _Tp __chi = __x - (__nu + _Tp(0.5L))
                             * __numeric_constants<_Tp>::__pi_2();

      const _Tp __c = std::cos(__chi);
      const _Tp __s = std::sin(__chi);

      const _Tp __coef = std::sqrt(_Tp(2)
                             / (__numeric_constants<_Tp>::__pi() * __x));

      __Jnu = __coef * (__c * __P - __s * __Q);
      __Nnu = __coef * (__s * __P + __c * __Q);

      return;
    }
# 444 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/bessel_function.tcc" 3
    template <typename _Tp>
    _Tp
    __cyl_bessel_ij_series(_Tp __nu, _Tp __x, _Tp __sgn,
                           unsigned int __max_iter)
    {
      if (__x == _Tp(0))
 return __nu == _Tp(0) ? _Tp(1) : _Tp(0);

      const _Tp __x2 = __x / _Tp(2);
      _Tp __fact = __nu * std::log(__x2);

      __fact -= ::std::lgamma(__nu + _Tp(1));



      __fact = std::exp(__fact);
      const _Tp __xx4 = __sgn * __x2 * __x2;
      _Tp __Jn = _Tp(1);
      _Tp __term = _Tp(1);

      for (unsigned int __i = 1; __i < __max_iter; ++__i)
        {
          __term *= __xx4 / (_Tp(__i) * (__nu + _Tp(__i)));
          __Jn += __term;
          if (std::abs(__term / __Jn) < std::numeric_limits<_Tp>::epsilon())
            break;
        }

      return __fact * __Jn;
    }
# 490 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/bessel_function.tcc" 3
    template<typename _Tp>
    _Tp
    __cyl_bessel_j(_Tp __nu, _Tp __x)
    {
      if (__nu < _Tp(0) || __x < _Tp(0))
        std::__throw_domain_error(("Bad argument " "in __cyl_bessel_j."));

      else if (__isnan(__nu) || __isnan(__x))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else if (__x * __x < _Tp(10) * (__nu + _Tp(1)))
        return __cyl_bessel_ij_series(__nu, __x, -_Tp(1), 200);
      else if (__x > _Tp(1000))
        {
          _Tp __J_nu, __N_nu;
          __cyl_bessel_jn_asymp(__nu, __x, __J_nu, __N_nu);
          return __J_nu;
        }
      else
        {
          _Tp __J_nu, __N_nu, __Jp_nu, __Np_nu;
          __bessel_jn(__nu, __x, __J_nu, __N_nu, __Jp_nu, __Np_nu);
          return __J_nu;
        }
    }
# 532 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/bessel_function.tcc" 3
    template<typename _Tp>
    _Tp
    __cyl_neumann_n(_Tp __nu, _Tp __x)
    {
      if (__nu < _Tp(0) || __x < _Tp(0))
        std::__throw_domain_error(("Bad argument " "in __cyl_neumann_n."));

      else if (__isnan(__nu) || __isnan(__x))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else if (__x > _Tp(1000))
        {
          _Tp __J_nu, __N_nu;
          __cyl_bessel_jn_asymp(__nu, __x, __J_nu, __N_nu);
          return __N_nu;
        }
      else
        {
          _Tp __J_nu, __N_nu, __Jp_nu, __Np_nu;
          __bessel_jn(__nu, __x, __J_nu, __N_nu, __Jp_nu, __Np_nu);
          return __N_nu;
        }
    }
# 569 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/bessel_function.tcc" 3
    template <typename _Tp>
    void
    __sph_bessel_jn(unsigned int __n, _Tp __x,
                    _Tp & __j_n, _Tp & __n_n, _Tp & __jp_n, _Tp & __np_n)
    {
      const _Tp __nu = _Tp(__n) + _Tp(0.5L);

      _Tp __J_nu, __N_nu, __Jp_nu, __Np_nu;
      __bessel_jn(__nu, __x, __J_nu, __N_nu, __Jp_nu, __Np_nu);

      const _Tp __factor = __numeric_constants<_Tp>::__sqrtpio2()
                         / std::sqrt(__x);

      __j_n = __factor * __J_nu;
      __n_n = __factor * __N_nu;
      __jp_n = __factor * __Jp_nu - __j_n / (_Tp(2) * __x);
      __np_n = __factor * __Np_nu - __n_n / (_Tp(2) * __x);

      return;
    }
# 604 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/bessel_function.tcc" 3
    template <typename _Tp>
    _Tp
    __sph_bessel(unsigned int __n, _Tp __x)
    {
      if (__x < _Tp(0))
        std::__throw_domain_error(("Bad argument " "in __sph_bessel."));

      else if (__isnan(__x))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else if (__x == _Tp(0))
        {
          if (__n == 0)
            return _Tp(1);
          else
            return _Tp(0);
        }
      else
        {
          _Tp __j_n, __n_n, __jp_n, __np_n;
          __sph_bessel_jn(__n, __x, __j_n, __n_n, __jp_n, __np_n);
          return __j_n;
        }
    }
# 642 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/bessel_function.tcc" 3
    template <typename _Tp>
    _Tp
    __sph_neumann(unsigned int __n, _Tp __x)
    {
      if (__x < _Tp(0))
        std::__throw_domain_error(("Bad argument " "in __sph_neumann."));

      else if (__isnan(__x))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else if (__x == _Tp(0))
        return -std::numeric_limits<_Tp>::infinity();
      else
        {
          _Tp __j_n, __n_n, __jp_n, __np_n;
          __sph_bessel_jn(__n, __x, __j_n, __n_n, __jp_n, __np_n);
          return __n_n;
        }
    }
  }






}
# 49 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/beta_function.tcc" 1 3
# 49 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/beta_function.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 65 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/beta_function.tcc" 3
  namespace __detail
  {
# 79 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/beta_function.tcc" 3
    template<typename _Tp>
    _Tp
    __beta_gamma(_Tp __x, _Tp __y)
    {

      _Tp __bet;

      if (__x > __y)
        {
          __bet = ::std::tgamma(__x)
                / ::std::tgamma(__x + __y);
          __bet *= ::std::tgamma(__y);
        }
      else
        {
          __bet = ::std::tgamma(__y)
                / ::std::tgamma(__x + __y);
          __bet *= ::std::tgamma(__x);
        }
# 111 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/beta_function.tcc" 3
      return __bet;
    }
# 127 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/beta_function.tcc" 3
    template<typename _Tp>
    _Tp
    __beta_lgamma(_Tp __x, _Tp __y)
    {

      _Tp __bet = ::std::lgamma(__x)
                + ::std::lgamma(__y)
                - ::std::lgamma(__x + __y);





      __bet = std::exp(__bet);
      return __bet;
    }
# 158 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/beta_function.tcc" 3
    template<typename _Tp>
    _Tp
    __beta_product(_Tp __x, _Tp __y)
    {

      _Tp __bet = (__x + __y) / (__x * __y);

      unsigned int __max_iter = 1000000;
      for (unsigned int __k = 1; __k < __max_iter; ++__k)
        {
          _Tp __term = (_Tp(1) + (__x + __y) / __k)
                     / ((_Tp(1) + __x / __k) * (_Tp(1) + __y / __k));
          __bet *= __term;
        }

      return __bet;
    }
# 189 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/beta_function.tcc" 3
    template<typename _Tp>
    inline _Tp
    __beta(_Tp __x, _Tp __y)
    {
      if (__isnan(__x) || __isnan(__y))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else
        return __beta_lgamma(__x, __y);
    }
  }






}
# 50 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/ell_integral.tcc" 1 3
# 45 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/ell_integral.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 59 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/ell_integral.tcc" 3
  namespace __detail
  {
# 76 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/ell_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __ellint_rf(_Tp __x, _Tp __y, _Tp __z)
    {
      const _Tp __min = std::numeric_limits<_Tp>::min();
      const _Tp __lolim = _Tp(5) * __min;

      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);
        }
    }
# 153 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/ell_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __comp_ellint_1_series(_Tp __k)
    {

      const _Tp __kk = __k * __k;

      _Tp __term = __kk / _Tp(4);
      _Tp __sum = _Tp(1) + __term;

      const unsigned int __max_iter = 1000;
      for (unsigned int __i = 2; __i < __max_iter; ++__i)
        {
          __term *= (2 * __i - 1) * __kk / (2 * __i);
          if (__term < std::numeric_limits<_Tp>::epsilon())
            break;
          __sum += __term;
        }

      return __numeric_constants<_Tp>::__pi_2() * __sum;
    }
# 191 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/ell_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __comp_ellint_1(_Tp __k)
    {

      if (__isnan(__k))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else if (std::abs(__k) >= _Tp(1))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else
        return __ellint_rf(_Tp(0), _Tp(1) - __k * __k, _Tp(1));
    }
# 219 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/ell_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __ellint_1(_Tp __k, _Tp __phi)
    {

      if (__isnan(__k) || __isnan(__phi))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else if (std::abs(__k) > _Tp(1))
        std::__throw_domain_error(("Bad argument in __ellint_1."));
      else
        {

          const int __n = std::floor(__phi / __numeric_constants<_Tp>::__pi()
                                   + _Tp(0.5L));
          const _Tp __phi_red = __phi
                              - __n * __numeric_constants<_Tp>::__pi();

          const _Tp __s = std::sin(__phi_red);
          const _Tp __c = std::cos(__phi_red);

          const _Tp __F = __s
                        * __ellint_rf(__c * __c,
                                _Tp(1) - __k * __k * __s * __s, _Tp(1));

          if (__n == 0)
            return __F;
          else
            return __F + _Tp(2) * __n * __comp_ellint_1(__k);
        }
    }
# 266 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/ell_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __comp_ellint_2_series(_Tp __k)
    {

      const _Tp __kk = __k * __k;

      _Tp __term = __kk;
      _Tp __sum = __term;

      const unsigned int __max_iter = 1000;
      for (unsigned int __i = 2; __i < __max_iter; ++__i)
        {
          const _Tp __i2m = 2 * __i - 1;
          const _Tp __i2 = 2 * __i;
          __term *= __i2m * __i2m * __kk / (__i2 * __i2);
          if (__term < std::numeric_limits<_Tp>::epsilon())
            break;
          __sum += __term / __i2m;
        }

      return __numeric_constants<_Tp>::__pi_2() * (_Tp(1) - __sum);
    }
# 314 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/ell_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __ellint_rd(_Tp __x, _Tp __y, _Tp __z)
    {
      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
      const _Tp __errtol = std::pow(__eps / _Tp(8), _Tp(1) / _Tp(6));
      const _Tp __max = std::numeric_limits<_Tp>::max();
      const _Tp __lolim = _Tp(2) / std::pow(__max, _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));
        }
    }
# 399 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/ell_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __comp_ellint_2(_Tp __k)
    {

      if (__isnan(__k))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else if (std::abs(__k) == 1)
        return _Tp(1);
      else if (std::abs(__k) > _Tp(1))
        std::__throw_domain_error(("Bad argument in __comp_ellint_2."));
      else
        {
          const _Tp __kk = __k * __k;

          return __ellint_rf(_Tp(0), _Tp(1) - __kk, _Tp(1))
               - __kk * __ellint_rd(_Tp(0), _Tp(1) - __kk, _Tp(1)) / _Tp(3);
        }
    }
# 433 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/ell_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __ellint_2(_Tp __k, _Tp __phi)
    {

      if (__isnan(__k) || __isnan(__phi))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else if (std::abs(__k) > _Tp(1))
        std::__throw_domain_error(("Bad argument in __ellint_2."));
      else
        {

          const int __n = std::floor(__phi / __numeric_constants<_Tp>::__pi()
                                   + _Tp(0.5L));
          const _Tp __phi_red = __phi
                              - __n * __numeric_constants<_Tp>::__pi();

          const _Tp __kk = __k * __k;
          const _Tp __s = std::sin(__phi_red);
          const _Tp __ss = __s * __s;
          const _Tp __sss = __ss * __s;
          const _Tp __c = std::cos(__phi_red);
          const _Tp __cc = __c * __c;

          const _Tp __E = __s
                        * __ellint_rf(__cc, _Tp(1) - __kk * __ss, _Tp(1))
                        - __kk * __sss
                        * __ellint_rd(__cc, _Tp(1) - __kk * __ss, _Tp(1))
                        / _Tp(3);

          if (__n == 0)
            return __E;
          else
            return __E + _Tp(2) * __n * __comp_ellint_2(__k);
        }
    }
# 492 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/ell_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __ellint_rc(_Tp __x, _Tp __y)
    {
      const _Tp __min = std::numeric_limits<_Tp>::min();
      const _Tp __lolim = _Tp(5) * __min;

      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);
        }
    }
# 561 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/ell_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __ellint_rj(_Tp __x, _Tp __y, _Tp __z, _Tp __p)
    {
      const _Tp __min = std::numeric_limits<_Tp>::min();
      const _Tp __lolim = std::pow(_Tp(5) * __min, _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 __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));
        }
    }
# 661 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/ell_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __comp_ellint_3(_Tp __k, _Tp __nu)
    {

      if (__isnan(__k) || __isnan(__nu))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else if (__nu == _Tp(1))
        return std::numeric_limits<_Tp>::infinity();
      else if (std::abs(__k) > _Tp(1))
        std::__throw_domain_error(("Bad argument in __comp_ellint_3."));
      else
        {
          const _Tp __kk = __k * __k;

          return __ellint_rf(_Tp(0), _Tp(1) - __kk, _Tp(1))
               + __nu
               * __ellint_rj(_Tp(0), _Tp(1) - __kk, _Tp(1), _Tp(1) - __nu)
               / _Tp(3);
        }
    }
# 701 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/ell_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __ellint_3(_Tp __k, _Tp __nu, _Tp __phi)
    {

      if (__isnan(__k) || __isnan(__nu) || __isnan(__phi))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else if (std::abs(__k) > _Tp(1))
        std::__throw_domain_error(("Bad argument in __ellint_3."));
      else
        {

          const int __n = std::floor(__phi / __numeric_constants<_Tp>::__pi()
                                   + _Tp(0.5L));
          const _Tp __phi_red = __phi
                              - __n * __numeric_constants<_Tp>::__pi();

          const _Tp __kk = __k * __k;
          const _Tp __s = std::sin(__phi_red);
          const _Tp __ss = __s * __s;
          const _Tp __sss = __ss * __s;
          const _Tp __c = std::cos(__phi_red);
          const _Tp __cc = __c * __c;

          const _Tp __Pi = __s
                         * __ellint_rf(__cc, _Tp(1) - __kk * __ss, _Tp(1))
                         + __nu * __sss
                         * __ellint_rj(__cc, _Tp(1) - __kk * __ss, _Tp(1),
                                       _Tp(1) - __nu * __ss) / _Tp(3);

          if (__n == 0)
            return __Pi;
          else
            return __Pi + _Tp(2) * __n * __comp_ellint_3(__k, __nu);
        }
    }
  }





}
# 51 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/exp_integral.tcc" 1 3
# 50 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/exp_integral.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 64 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/exp_integral.tcc" 3
  namespace __detail
  {
    template<typename _Tp> _Tp __expint_E1(_Tp);
# 81 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/exp_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __expint_E1_series(_Tp __x)
    {
      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
      _Tp __term = _Tp(1);
      _Tp __esum = _Tp(0);
      _Tp __osum = _Tp(0);
      const unsigned int __max_iter = 1000;
      for (unsigned int __i = 1; __i < __max_iter; ++__i)
        {
          __term *= - __x / __i;
          if (std::abs(__term) < __eps)
            break;
          if (__term >= _Tp(0))
            __esum += __term / __i;
          else
            __osum += __term / __i;
        }

      return - __esum - __osum
             - __numeric_constants<_Tp>::__gamma_e() - std::log(__x);
    }
# 118 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/exp_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __expint_E1_asymp(_Tp __x)
    {
      _Tp __term = _Tp(1);
      _Tp __esum = _Tp(1);
      _Tp __osum = _Tp(0);
      const unsigned int __max_iter = 1000;
      for (unsigned int __i = 1; __i < __max_iter; ++__i)
        {
          _Tp __prev = __term;
          __term *= - __i / __x;
          if (std::abs(__term) > std::abs(__prev))
            break;
          if (__term >= _Tp(0))
            __esum += __term;
          else
            __osum += __term;
        }

      return std::exp(- __x) * (__esum + __osum) / __x;
    }
# 155 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/exp_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __expint_En_series(unsigned int __n, _Tp __x)
    {
      const unsigned int __max_iter = 1000;
      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
      const int __nm1 = __n - 1;
      _Tp __ans = (__nm1 != 0
                ? _Tp(1) / __nm1 : -std::log(__x)
                                   - __numeric_constants<_Tp>::__gamma_e());
      _Tp __fact = _Tp(1);
      for (int __i = 1; __i <= __max_iter; ++__i)
        {
          __fact *= -__x / _Tp(__i);
          _Tp __del;
          if ( __i != __nm1 )
            __del = -__fact / _Tp(__i - __nm1);
          else
            {
              _Tp __psi = -__numeric_constants<_Tp>::gamma_e();
              for (int __ii = 1; __ii <= __nm1; ++__ii)
                __psi += _Tp(1) / _Tp(__ii);
              __del = __fact * (__psi - std::log(__x));
            }
          __ans += __del;
          if (std::abs(__del) < __eps * std::abs(__ans))
            return __ans;
        }
      std::__throw_runtime_error(("Series summation failed " "in __expint_En_series."));

    }
# 201 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/exp_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __expint_En_cont_frac(unsigned int __n, _Tp __x)
    {
      const unsigned int __max_iter = 1000;
      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
      const _Tp __fp_min = std::numeric_limits<_Tp>::min();
      const int __nm1 = __n - 1;
      _Tp __b = __x + _Tp(__n);
      _Tp __c = _Tp(1) / __fp_min;
      _Tp __d = _Tp(1) / __b;
      _Tp __h = __d;
      for ( unsigned int __i = 1; __i <= __max_iter; ++__i )
        {
          _Tp __a = -_Tp(__i * (__nm1 + __i));
          __b += _Tp(2);
          __d = _Tp(1) / (__a * __d + __b);
          __c = __b + __a / __c;
          const _Tp __del = __c * __d;
          __h *= __del;
          if (std::abs(__del - _Tp(1)) < __eps)
            {
              const _Tp __ans = __h * std::exp(-__x);
              return __ans;
            }
        }
      std::__throw_runtime_error(("Continued fraction failed " "in __expint_En_cont_frac."));

    }
# 246 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/exp_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __expint_En_recursion(unsigned int __n, _Tp __x)
    {
      _Tp __En;
      _Tp __E1 = __expint_E1(__x);
      if (__x < _Tp(__n))
        {

          __En = __E1;
          for (unsigned int __j = 2; __j < __n; ++__j)
            __En = (std::exp(-__x) - __x * __En) / _Tp(__j - 1);
        }
      else
        {

          __En = _Tp(1);
          const int __N = __n + 20;
          _Tp __save = _Tp(0);
          for (int __j = __N; __j > 0; --__j)
            {
              __En = (std::exp(-__x) - __j * __En) / __x;
              if (__j == __n)
                __save = __En;
            }
            _Tp __norm = __En / __E1;
            __En /= __norm;
        }

      return __En;
    }
# 290 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/exp_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __expint_Ei_series(_Tp __x)
    {
      _Tp __term = _Tp(1);
      _Tp __sum = _Tp(0);
      const unsigned int __max_iter = 1000;
      for (unsigned int __i = 1; __i < __max_iter; ++__i)
        {
          __term *= __x / __i;
          __sum += __term / __i;
          if (__term < std::numeric_limits<_Tp>::epsilon() * __sum)
            break;
        }

      return __numeric_constants<_Tp>::__gamma_e() + __sum + std::log(__x);
    }
# 321 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/exp_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __expint_Ei_asymp(_Tp __x)
    {
      _Tp __term = _Tp(1);
      _Tp __sum = _Tp(1);
      const unsigned int __max_iter = 1000;
      for (unsigned int __i = 1; __i < __max_iter; ++__i)
        {
          _Tp __prev = __term;
          __term *= __i / __x;
          if (__term < std::numeric_limits<_Tp>::epsilon())
            break;
          if (__term >= __prev)
            break;
          __sum += __term;
        }

      return std::exp(__x) * __sum / __x;
    }
# 354 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/exp_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __expint_Ei(_Tp __x)
    {
      if (__x < _Tp(0))
        return -__expint_E1(-__x);
      else if (__x < -std::log(std::numeric_limits<_Tp>::epsilon()))
        return __expint_Ei_series(__x);
      else
        return __expint_Ei_asymp(__x);
    }
# 378 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/exp_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __expint_E1(_Tp __x)
    {
      if (__x < _Tp(0))
        return -__expint_Ei(-__x);
      else if (__x < _Tp(1))
        return __expint_E1_series(__x);
      else if (__x < _Tp(100))
        return __expint_En_cont_frac(1, __x);
      else
        return __expint_E1_asymp(__x);
    }
# 408 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/exp_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __expint_asymp(unsigned int __n, _Tp __x)
    {
      _Tp __term = _Tp(1);
      _Tp __sum = _Tp(1);
      for (unsigned int __i = 1; __i <= __n; ++__i)
        {
          _Tp __prev = __term;
          __term *= -(__n - __i + 1) / __x;
          if (std::abs(__term) > std::abs(__prev))
            break;
          __sum += __term;
        }

      return std::exp(-__x) * __sum / __x;
    }
# 442 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/exp_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __expint_large_n(unsigned int __n, _Tp __x)
    {
      const _Tp __xpn = __x + __n;
      const _Tp __xpn2 = __xpn * __xpn;
      _Tp __term = _Tp(1);
      _Tp __sum = _Tp(1);
      for (unsigned int __i = 1; __i <= __n; ++__i)
        {
          _Tp __prev = __term;
          __term *= (__n - 2 * (__i - 1) * __x) / __xpn2;
          if (std::abs(__term) < std::numeric_limits<_Tp>::epsilon())
            break;
          __sum += __term;
        }

      return std::exp(-__x) * __sum / __xpn;
    }
# 476 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/exp_integral.tcc" 3
    template<typename _Tp>
    _Tp
    __expint(unsigned int __n, _Tp __x)
    {

      if (__isnan(__x))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else if (__n <= 1 && __x == _Tp(0))
        return std::numeric_limits<_Tp>::infinity();
      else
        {
          _Tp __E0 = std::exp(__x) / __x;
          if (__n == 0)
            return __E0;

          _Tp __E1 = __expint_E1(__x);
          if (__n == 1)
            return __E1;

          if (__x == _Tp(0))
            return _Tp(1) / static_cast<_Tp>(__n - 1);

          _Tp __En = __expint_En_recursion(__n, __x);

          return __En;
        }
    }
# 516 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/exp_integral.tcc" 3
    template<typename _Tp>
    inline _Tp
    __expint(_Tp __x)
    {
      if (__isnan(__x))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else
        return __expint_Ei(__x);
    }
  }





}
# 52 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/hypergeometric.tcc" 1 3
# 44 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/hypergeometric.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 60 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/hypergeometric.tcc" 3
  namespace __detail
  {
# 83 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/hypergeometric.tcc" 3
    template<typename _Tp>
    _Tp
    __conf_hyperg_series(_Tp __a, _Tp __c, _Tp __x)
    {
      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();

      _Tp __term = _Tp(1);
      _Tp __Fac = _Tp(1);
      const unsigned int __max_iter = 100000;
      unsigned int __i;
      for (__i = 0; __i < __max_iter; ++__i)
        {
          __term *= (__a + _Tp(__i)) * __x
                  / ((__c + _Tp(__i)) * _Tp(1 + __i));
          if (std::abs(__term) < __eps)
            {
              break;
            }
          __Fac += __term;
        }
      if (__i == __max_iter)
        std::__throw_runtime_error(("Series failed to converge " "in __conf_hyperg_series."));


      return __Fac;
    }
# 120 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/hypergeometric.tcc" 3
    template<typename _Tp>
    _Tp
    __conf_hyperg_luke(_Tp __a, _Tp __c, _Tp __xin)
    {
      const _Tp __big = std::pow(std::numeric_limits<_Tp>::max(), _Tp(0.16L));
      const int __nmax = 20000;
      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
      const _Tp __x = -__xin;
      const _Tp __x3 = __x * __x * __x;
      const _Tp __t0 = __a / __c;
      const _Tp __t1 = (__a + _Tp(1)) / (_Tp(2) * __c);
      const _Tp __t2 = (__a + _Tp(2)) / (_Tp(2) * (__c + _Tp(1)));
      _Tp __F = _Tp(1);
      _Tp __prec;

      _Tp __Bnm3 = _Tp(1);
      _Tp __Bnm2 = _Tp(1) + __t1 * __x;
      _Tp __Bnm1 = _Tp(1) + __t2 * __x * (_Tp(1) + __t1 / _Tp(3) * __x);

      _Tp __Anm3 = _Tp(1);
      _Tp __Anm2 = __Bnm2 - __t0 * __x;
      _Tp __Anm1 = __Bnm1 - __t0 * (_Tp(1) + __t2 * __x) * __x
                 + __t0 * __t1 * (__c / (__c + _Tp(1))) * __x * __x;

      int __n = 3;
      while(1)
        {
          _Tp __npam1 = _Tp(__n - 1) + __a;
          _Tp __npcm1 = _Tp(__n - 1) + __c;
          _Tp __npam2 = _Tp(__n - 2) + __a;
          _Tp __npcm2 = _Tp(__n - 2) + __c;
          _Tp __tnm1 = _Tp(2 * __n - 1);
          _Tp __tnm3 = _Tp(2 * __n - 3);
          _Tp __tnm5 = _Tp(2 * __n - 5);
          _Tp __F1 = (_Tp(__n - 2) - __a) / (_Tp(2) * __tnm3 * __npcm1);
          _Tp __F2 = (_Tp(__n) + __a) * __npam1
                   / (_Tp(4) * __tnm1 * __tnm3 * __npcm2 * __npcm1);
          _Tp __F3 = -__npam2 * __npam1 * (_Tp(__n - 2) - __a)
                   / (_Tp(8) * __tnm3 * __tnm3 * __tnm5
                   * (_Tp(__n - 3) + __c) * __npcm2 * __npcm1);
          _Tp __E = -__npam1 * (_Tp(__n - 1) - __c)
                   / (_Tp(2) * __tnm3 * __npcm2 * __npcm1);

          _Tp __An = (_Tp(1) + __F1 * __x) * __Anm1
                   + (__E + __F2 * __x) * __x * __Anm2 + __F3 * __x3 * __Anm3;
          _Tp __Bn = (_Tp(1) + __F1 * __x) * __Bnm1
                   + (__E + __F2 * __x) * __x * __Bnm2 + __F3 * __x3 * __Bnm3;
          _Tp __r = __An / __Bn;

          __prec = std::abs((__F - __r) / __F);
          __F = __r;

          if (__prec < __eps || __n > __nmax)
            break;

          if (std::abs(__An) > __big || std::abs(__Bn) > __big)
            {
              __An /= __big;
              __Bn /= __big;
              __Anm1 /= __big;
              __Bnm1 /= __big;
              __Anm2 /= __big;
              __Bnm2 /= __big;
              __Anm3 /= __big;
              __Bnm3 /= __big;
            }
          else if (std::abs(__An) < _Tp(1) / __big
                || std::abs(__Bn) < _Tp(1) / __big)
            {
              __An *= __big;
              __Bn *= __big;
              __Anm1 *= __big;
              __Bnm1 *= __big;
              __Anm2 *= __big;
              __Bnm2 *= __big;
              __Anm3 *= __big;
              __Bnm3 *= __big;
            }

          ++__n;
          __Bnm3 = __Bnm2;
          __Bnm2 = __Bnm1;
          __Bnm1 = __Bn;
          __Anm3 = __Anm2;
          __Anm2 = __Anm1;
          __Anm1 = __An;
        }

      if (__n >= __nmax)
        std::__throw_runtime_error(("Iteration failed to converge " "in __conf_hyperg_luke."));


      return __F;
    }
# 227 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/hypergeometric.tcc" 3
    template<typename _Tp>
    _Tp
    __conf_hyperg(_Tp __a, _Tp __c, _Tp __x)
    {

      const _Tp __c_nint = ::std::nearbyint(__c);



      if (__isnan(__a) || __isnan(__c) || __isnan(__x))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else if (__c_nint == __c && __c_nint <= 0)
        return std::numeric_limits<_Tp>::infinity();
      else if (__a == _Tp(0))
        return _Tp(1);
      else if (__c == __a)
        return std::exp(__x);
      else if (__x < _Tp(0))
        return __conf_hyperg_luke(__a, __c, __x);
      else
        return __conf_hyperg_series(__a, __c, __x);
    }
# 271 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/hypergeometric.tcc" 3
    template<typename _Tp>
    _Tp
    __hyperg_series(_Tp __a, _Tp __b, _Tp __c, _Tp __x)
    {
      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();

      _Tp __term = _Tp(1);
      _Tp __Fabc = _Tp(1);
      const unsigned int __max_iter = 100000;
      unsigned int __i;
      for (__i = 0; __i < __max_iter; ++__i)
        {
          __term *= (__a + _Tp(__i)) * (__b + _Tp(__i)) * __x
                  / ((__c + _Tp(__i)) * _Tp(1 + __i));
          if (std::abs(__term) < __eps)
            {
              break;
            }
          __Fabc += __term;
        }
      if (__i == __max_iter)
        std::__throw_runtime_error(("Series failed to converge " "in __hyperg_series."));


      return __Fabc;
    }







    template<typename _Tp>
    _Tp
    __hyperg_luke(_Tp __a, _Tp __b, _Tp __c, _Tp __xin)
    {
      const _Tp __big = std::pow(std::numeric_limits<_Tp>::max(), _Tp(0.16L));
      const int __nmax = 20000;
      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
      const _Tp __x = -__xin;
      const _Tp __x3 = __x * __x * __x;
      const _Tp __t0 = __a * __b / __c;
      const _Tp __t1 = (__a + _Tp(1)) * (__b + _Tp(1)) / (_Tp(2) * __c);
      const _Tp __t2 = (__a + _Tp(2)) * (__b + _Tp(2))
                     / (_Tp(2) * (__c + _Tp(1)));

      _Tp __F = _Tp(1);

      _Tp __Bnm3 = _Tp(1);
      _Tp __Bnm2 = _Tp(1) + __t1 * __x;
      _Tp __Bnm1 = _Tp(1) + __t2 * __x * (_Tp(1) + __t1 / _Tp(3) * __x);

      _Tp __Anm3 = _Tp(1);
      _Tp __Anm2 = __Bnm2 - __t0 * __x;
      _Tp __Anm1 = __Bnm1 - __t0 * (_Tp(1) + __t2 * __x) * __x
                 + __t0 * __t1 * (__c / (__c + _Tp(1))) * __x * __x;

      int __n = 3;
      while (1)
        {
          const _Tp __npam1 = _Tp(__n - 1) + __a;
          const _Tp __npbm1 = _Tp(__n - 1) + __b;
          const _Tp __npcm1 = _Tp(__n - 1) + __c;
          const _Tp __npam2 = _Tp(__n - 2) + __a;
          const _Tp __npbm2 = _Tp(__n - 2) + __b;
          const _Tp __npcm2 = _Tp(__n - 2) + __c;
          const _Tp __tnm1 = _Tp(2 * __n - 1);
          const _Tp __tnm3 = _Tp(2 * __n - 3);
          const _Tp __tnm5 = _Tp(2 * __n - 5);
          const _Tp __n2 = __n * __n;
          const _Tp __F1 = (_Tp(3) * __n2 + (__a + __b - _Tp(6)) * __n
                         + _Tp(2) - __a * __b - _Tp(2) * (__a + __b))
                         / (_Tp(2) * __tnm3 * __npcm1);
          const _Tp __F2 = -(_Tp(3) * __n2 - (__a + __b + _Tp(6)) * __n
                         + _Tp(2) - __a * __b) * __npam1 * __npbm1
                         / (_Tp(4) * __tnm1 * __tnm3 * __npcm2 * __npcm1);
          const _Tp __F3 = (__npam2 * __npam1 * __npbm2 * __npbm1
                         * (_Tp(__n - 2) - __a) * (_Tp(__n - 2) - __b))
                         / (_Tp(8) * __tnm3 * __tnm3 * __tnm5
                         * (_Tp(__n - 3) + __c) * __npcm2 * __npcm1);
          const _Tp __E = -__npam1 * __npbm1 * (_Tp(__n - 1) - __c)
                         / (_Tp(2) * __tnm3 * __npcm2 * __npcm1);

          _Tp __An = (_Tp(1) + __F1 * __x) * __Anm1
                   + (__E + __F2 * __x) * __x * __Anm2 + __F3 * __x3 * __Anm3;
          _Tp __Bn = (_Tp(1) + __F1 * __x) * __Bnm1
                   + (__E + __F2 * __x) * __x * __Bnm2 + __F3 * __x3 * __Bnm3;
          const _Tp __r = __An / __Bn;

          const _Tp __prec = std::abs((__F - __r) / __F);
          __F = __r;

          if (__prec < __eps || __n > __nmax)
            break;

          if (std::abs(__An) > __big || std::abs(__Bn) > __big)
            {
              __An /= __big;
              __Bn /= __big;
              __Anm1 /= __big;
              __Bnm1 /= __big;
              __Anm2 /= __big;
              __Bnm2 /= __big;
              __Anm3 /= __big;
              __Bnm3 /= __big;
            }
          else if (std::abs(__An) < _Tp(1) / __big
                || std::abs(__Bn) < _Tp(1) / __big)
            {
              __An *= __big;
              __Bn *= __big;
              __Anm1 *= __big;
              __Bnm1 *= __big;
              __Anm2 *= __big;
              __Bnm2 *= __big;
              __Anm3 *= __big;
              __Bnm3 *= __big;
            }

          ++__n;
          __Bnm3 = __Bnm2;
          __Bnm2 = __Bnm1;
          __Bnm1 = __Bn;
          __Anm3 = __Anm2;
          __Anm2 = __Anm1;
          __Anm1 = __An;
        }

      if (__n >= __nmax)
        std::__throw_runtime_error(("Iteration failed to converge " "in __hyperg_luke."));


      return __F;
    }
# 438 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/hypergeometric.tcc" 3
    template<typename _Tp>
    _Tp
    __hyperg_reflect(_Tp __a, _Tp __b, _Tp __c, _Tp __x)
    {
      const _Tp __d = __c - __a - __b;
      const int __intd = std::floor(__d + _Tp(0.5L));
      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
      const _Tp __toler = _Tp(1000) * __eps;
      const _Tp __log_max = std::log(std::numeric_limits<_Tp>::max());
      const bool __d_integer = (std::abs(__d - __intd) < __toler);

      if (__d_integer)
        {
          const _Tp __ln_omx = std::log(_Tp(1) - __x);
          const _Tp __ad = std::abs(__d);
          _Tp __F1, __F2;

          _Tp __d1, __d2;
          if (__d >= _Tp(0))
            {
              __d1 = __d;
              __d2 = _Tp(0);
            }
          else
            {
              __d1 = _Tp(0);
              __d2 = __d;
            }

          const _Tp __lng_c = __log_gamma(__c);


          if (__ad < __eps)
            {

              __F1 = _Tp(0);
            }
          else
            {

              bool __ok_d1 = true;
              _Tp __lng_ad, __lng_ad1, __lng_bd1;
              try
                {
                  __lng_ad = __log_gamma(__ad);
                  __lng_ad1 = __log_gamma(__a + __d1);
                  __lng_bd1 = __log_gamma(__b + __d1);
                }
              catch(...)
                {
                  __ok_d1 = false;
                }

              if (__ok_d1)
                {



                  _Tp __sum1 = _Tp(1);
                  _Tp __term = _Tp(1);
                  _Tp __ln_pre1 = __lng_ad + __lng_c + __d2 * __ln_omx
                                - __lng_ad1 - __lng_bd1;



                  for (int __i = 1; __i < __ad; ++__i)
                    {
                      const int __j = __i - 1;
                      __term *= (__a + __d2 + __j) * (__b + __d2 + __j)
                              / (_Tp(1) + __d2 + __j) / __i * (_Tp(1) - __x);
                      __sum1 += __term;
                    }

                  if (__ln_pre1 > __log_max)
                    std::__throw_runtime_error(("Overflow of gamma functions" " in __hyperg_luke."));

                  else
                    __F1 = std::exp(__ln_pre1) * __sum1;
                }
              else
                {


                  __F1 = _Tp(0);
                }
            }


          bool __ok_d2 = true;
          _Tp __lng_ad2, __lng_bd2;
          try
            {
              __lng_ad2 = __log_gamma(__a + __d2);
              __lng_bd2 = __log_gamma(__b + __d2);
            }
          catch(...)
            {
              __ok_d2 = false;
            }

          if (__ok_d2)
            {


              const int __maxiter = 2000;
              const _Tp __psi_1 = -__numeric_constants<_Tp>::__gamma_e();
              const _Tp __psi_1pd = __psi(_Tp(1) + __ad);
              const _Tp __psi_apd1 = __psi(__a + __d1);
              const _Tp __psi_bpd1 = __psi(__b + __d1);

              _Tp __psi_term = __psi_1 + __psi_1pd - __psi_apd1
                             - __psi_bpd1 - __ln_omx;
              _Tp __fact = _Tp(1);
              _Tp __sum2 = __psi_term;
              _Tp __ln_pre2 = __lng_c + __d1 * __ln_omx
                            - __lng_ad2 - __lng_bd2;


              int __j;
              for (__j = 1; __j < __maxiter; ++__j)
                {


                  const _Tp __term1 = _Tp(1) / _Tp(__j)
                                    + _Tp(1) / (__ad + __j);
                  const _Tp __term2 = _Tp(1) / (__a + __d1 + _Tp(__j - 1))
                                    + _Tp(1) / (__b + __d1 + _Tp(__j - 1));
                  __psi_term += __term1 - __term2;
                  __fact *= (__a + __d1 + _Tp(__j - 1))
                          * (__b + __d1 + _Tp(__j - 1))
                          / ((__ad + __j) * __j) * (_Tp(1) - __x);
                  const _Tp __delta = __fact * __psi_term;
                  __sum2 += __delta;
                  if (std::abs(__delta) < __eps * std::abs(__sum2))
                    break;
                }
              if (__j == __maxiter)
                std::__throw_runtime_error(("Sum F2 failed to converge " "in __hyperg_reflect"));


              if (__sum2 == _Tp(0))
                __F2 = _Tp(0);
              else
                __F2 = std::exp(__ln_pre2) * __sum2;
            }
          else
            {


              __F2 = _Tp(0);
            }

          const _Tp __sgn_2 = (__intd % 2 == 1 ? -_Tp(1) : _Tp(1));
          const _Tp __F = __F1 + __sgn_2 * __F2;

          return __F;
        }
      else
        {




          bool __ok1 = true;
          _Tp __sgn_g1ca = _Tp(0), __ln_g1ca = _Tp(0);
          _Tp __sgn_g1cb = _Tp(0), __ln_g1cb = _Tp(0);
          try
            {
              __sgn_g1ca = __log_gamma_sign(__c - __a);
              __ln_g1ca = __log_gamma(__c - __a);
              __sgn_g1cb = __log_gamma_sign(__c - __b);
              __ln_g1cb = __log_gamma(__c - __b);
            }
          catch(...)
            {
              __ok1 = false;
            }

          bool __ok2 = true;
          _Tp __sgn_g2a = _Tp(0), __ln_g2a = _Tp(0);
          _Tp __sgn_g2b = _Tp(0), __ln_g2b = _Tp(0);
          try
            {
              __sgn_g2a = __log_gamma_sign(__a);
              __ln_g2a = __log_gamma(__a);
              __sgn_g2b = __log_gamma_sign(__b);
              __ln_g2b = __log_gamma(__b);
            }
          catch(...)
            {
              __ok2 = false;
            }

          const _Tp __sgn_gc = __log_gamma_sign(__c);
          const _Tp __ln_gc = __log_gamma(__c);
          const _Tp __sgn_gd = __log_gamma_sign(__d);
          const _Tp __ln_gd = __log_gamma(__d);
          const _Tp __sgn_gmd = __log_gamma_sign(-__d);
          const _Tp __ln_gmd = __log_gamma(-__d);

          const _Tp __sgn1 = __sgn_gc * __sgn_gd * __sgn_g1ca * __sgn_g1cb;
          const _Tp __sgn2 = __sgn_gc * __sgn_gmd * __sgn_g2a * __sgn_g2b;

          _Tp __pre1, __pre2;
          if (__ok1 && __ok2)
            {
              _Tp __ln_pre1 = __ln_gc + __ln_gd - __ln_g1ca - __ln_g1cb;
              _Tp __ln_pre2 = __ln_gc + __ln_gmd - __ln_g2a - __ln_g2b
                            + __d * std::log(_Tp(1) - __x);
              if (__ln_pre1 < __log_max && __ln_pre2 < __log_max)
                {
                  __pre1 = std::exp(__ln_pre1);
                  __pre2 = std::exp(__ln_pre2);
                  __pre1 *= __sgn1;
                  __pre2 *= __sgn2;
                }
              else
                {
                  std::__throw_runtime_error(("Overflow of gamma functions " "in __hyperg_reflect"));

                }
            }
          else if (__ok1 && !__ok2)
            {
              _Tp __ln_pre1 = __ln_gc + __ln_gd - __ln_g1ca - __ln_g1cb;
              if (__ln_pre1 < __log_max)
                {
                  __pre1 = std::exp(__ln_pre1);
                  __pre1 *= __sgn1;
                  __pre2 = _Tp(0);
                }
              else
                {
                  std::__throw_runtime_error(("Overflow of gamma functions " "in __hyperg_reflect"));

                }
            }
          else if (!__ok1 && __ok2)
            {
              _Tp __ln_pre2 = __ln_gc + __ln_gmd - __ln_g2a - __ln_g2b
                            + __d * std::log(_Tp(1) - __x);
              if (__ln_pre2 < __log_max)
                {
                  __pre1 = _Tp(0);
                  __pre2 = std::exp(__ln_pre2);
                  __pre2 *= __sgn2;
                }
              else
                {
                  std::__throw_runtime_error(("Overflow of gamma functions " "in __hyperg_reflect"));

                }
            }
          else
            {
              __pre1 = _Tp(0);
              __pre2 = _Tp(0);
              std::__throw_runtime_error(("Underflow of gamma functions " "in __hyperg_reflect"));

            }

          const _Tp __F1 = __hyperg_series(__a, __b, _Tp(1) - __d,
                                           _Tp(1) - __x);
          const _Tp __F2 = __hyperg_series(__c - __a, __c - __b, _Tp(1) + __d,
                                           _Tp(1) - __x);

          const _Tp __F = __pre1 * __F1 + __pre2 * __F2;

          return __F;
        }
    }
# 728 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/hypergeometric.tcc" 3
    template<typename _Tp>
    _Tp
    __hyperg(_Tp __a, _Tp __b, _Tp __c, _Tp __x)
    {

      const _Tp __a_nint = ::std::nearbyint(__a);
      const _Tp __b_nint = ::std::nearbyint(__b);
      const _Tp __c_nint = ::std::nearbyint(__c);





      const _Tp __toler = _Tp(1000) * std::numeric_limits<_Tp>::epsilon();
      if (std::abs(__x) >= _Tp(1))
        std::__throw_domain_error(("Argument outside unit circle " "in __hyperg."));

      else if (__isnan(__a) || __isnan(__b)
            || __isnan(__c) || __isnan(__x))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else if (__c_nint == __c && __c_nint <= _Tp(0))
        return std::numeric_limits<_Tp>::infinity();
      else if (std::abs(__c - __b) < __toler || std::abs(__c - __a) < __toler)
        return std::pow(_Tp(1) - __x, __c - __a - __b);
      else if (__a >= _Tp(0) && __b >= _Tp(0) && __c >= _Tp(0)
            && __x >= _Tp(0) && __x < _Tp(0.995L))
        return __hyperg_series(__a, __b, __c, __x);
      else if (std::abs(__a) < _Tp(10) && std::abs(__b) < _Tp(10))
        {


          if (__a < _Tp(0) && std::abs(__a - __a_nint) < __toler)
            return __hyperg_series(__a_nint, __b, __c, __x);
          else if (__b < _Tp(0) && std::abs(__b - __b_nint) < __toler)
            return __hyperg_series(__a, __b_nint, __c, __x);
          else if (__x < -_Tp(0.25L))
            return __hyperg_luke(__a, __b, __c, __x);
          else if (__x < _Tp(0.5L))
            return __hyperg_series(__a, __b, __c, __x);
          else
            if (std::abs(__c) > _Tp(10))
              return __hyperg_series(__a, __b, __c, __x);
            else
              return __hyperg_reflect(__a, __b, __c, __x);
        }
      else
        return __hyperg_luke(__a, __b, __c, __x);
    }
  }






}
# 53 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/legendre_function.tcc" 1 3
# 49 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/legendre_function.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 65 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/legendre_function.tcc" 3
  namespace __detail
  {
# 80 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/legendre_function.tcc" 3
    template<typename _Tp>
    _Tp
    __poly_legendre_p(unsigned int __l, _Tp __x)
    {

      if (__isnan(__x))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else if (__x == +_Tp(1))
        return +_Tp(1);
      else if (__x == -_Tp(1))
        return (__l % 2 == 1 ? -_Tp(1) : +_Tp(1));
      else
        {
          _Tp __p_lm2 = _Tp(1);
          if (__l == 0)
            return __p_lm2;

          _Tp __p_lm1 = __x;
          if (__l == 1)
            return __p_lm1;

          _Tp __p_l = 0;
          for (unsigned int __ll = 2; __ll <= __l; ++__ll)
            {


              __p_l = _Tp(2) * __x * __p_lm1 - __p_lm2
                    - (__x * __p_lm1 - __p_lm2) / _Tp(__ll);
              __p_lm2 = __p_lm1;
              __p_lm1 = __p_l;
            }

          return __p_l;
        }
    }
# 136 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/legendre_function.tcc" 3
    template<typename _Tp>
    _Tp
    __assoc_legendre_p(unsigned int __l, unsigned int __m, _Tp __x,
         _Tp __phase = _Tp(+1))
    {

      if (__m > __l)
        return _Tp(0);
      else if (__isnan(__x))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else if (__m == 0)
        return __poly_legendre_p(__l, __x);
      else
        {
          _Tp __p_mm = _Tp(1);
          if (__m > 0)
            {


              _Tp __root = std::sqrt(_Tp(1) - __x) * std::sqrt(_Tp(1) + __x);
              _Tp __fact = _Tp(1);
              for (unsigned int __i = 1; __i <= __m; ++__i)
                {
                  __p_mm *= __phase * __fact * __root;
                  __fact += _Tp(2);
                }
            }
          if (__l == __m)
            return __p_mm;

          _Tp __p_mp1m = _Tp(2 * __m + 1) * __x * __p_mm;
          if (__l == __m + 1)
            return __p_mp1m;

          _Tp __p_lm2m = __p_mm;
          _Tp __P_lm1m = __p_mp1m;
          _Tp __p_lm = _Tp(0);
          for (unsigned int __j = __m + 2; __j <= __l; ++__j)
            {
              __p_lm = (_Tp(2 * __j - 1) * __x * __P_lm1m
                      - _Tp(__j + __m - 1) * __p_lm2m) / _Tp(__j - __m);
              __p_lm2m = __P_lm1m;
              __P_lm1m = __p_lm;
            }

          return __p_lm;
        }
    }
# 214 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/legendre_function.tcc" 3
    template <typename _Tp>
    _Tp
    __sph_legendre(unsigned int __l, unsigned int __m, _Tp __theta)
    {
      if (__isnan(__theta))
        return std::numeric_limits<_Tp>::quiet_NaN();

      const _Tp __x = std::cos(__theta);

      if (__m > __l)
        return _Tp(0);
      else if (__m == 0)
        {
          _Tp __P = __poly_legendre_p(__l, __x);
          _Tp __fact = std::sqrt(_Tp(2 * __l + 1)
                     / (_Tp(4) * __numeric_constants<_Tp>::__pi()));
          __P *= __fact;
          return __P;
        }
      else if (__x == _Tp(1) || __x == -_Tp(1))
        {

          return _Tp(0);
        }
      else
        {





          const _Tp __sgn = ( __m % 2 == 1 ? -_Tp(1) : _Tp(1));
          const _Tp __y_mp1m_factor = __x * std::sqrt(_Tp(2 * __m + 3));

          const _Tp __lncirc = ::std::log1p(-__x * __x);





          const _Tp __lnpoch = ::std::lgamma(_Tp(__m + _Tp(0.5L)))
                             - ::std::lgamma(_Tp(__m));




          const _Tp __lnpre_val =
                    -_Tp(0.25L) * __numeric_constants<_Tp>::__lnpi()
                    + _Tp(0.5L) * (__lnpoch + __m * __lncirc);
          const _Tp __sr = std::sqrt((_Tp(2) + _Tp(1) / __m)
                         / (_Tp(4) * __numeric_constants<_Tp>::__pi()));
          _Tp __y_mm = __sgn * __sr * std::exp(__lnpre_val);
          _Tp __y_mp1m = __y_mp1m_factor * __y_mm;

          if (__l == __m)
            return __y_mm;
          else if (__l == __m + 1)
            return __y_mp1m;
          else
            {
              _Tp __y_lm = _Tp(0);


              for (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;
            }
        }
    }
  }






}
# 54 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/modified_bessel_func.tcc" 1 3
# 51 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/modified_bessel_func.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 65 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/modified_bessel_func.tcc" 3
  namespace __detail
  {
# 83 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/modified_bessel_func.tcc" 3
    template <typename _Tp>
    void
    __bessel_ik(_Tp __nu, _Tp __x,
                _Tp & __Inu, _Tp & __Knu, _Tp & __Ipnu, _Tp & __Kpnu)
    {
      if (__x == _Tp(0))
        {
          if (__nu == _Tp(0))
            {
              __Inu = _Tp(1);
              __Ipnu = _Tp(0);
            }
          else if (__nu == _Tp(1))
            {
              __Inu = _Tp(0);
              __Ipnu = _Tp(0.5L);
            }
          else
            {
              __Inu = _Tp(0);
              __Ipnu = _Tp(0);
            }
          __Knu = std::numeric_limits<_Tp>::infinity();
          __Kpnu = -std::numeric_limits<_Tp>::infinity();
          return;
        }

      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();
      const _Tp __fp_min = _Tp(10) * std::numeric_limits<_Tp>::epsilon();
      const int __max_iter = 15000;
      const _Tp __x_min = _Tp(2);

      const int __nl = static_cast<int>(__nu + _Tp(0.5L));

      const _Tp __mu = __nu - __nl;
      const _Tp __mu2 = __mu * __mu;
      const _Tp __xi = _Tp(1) / __x;
      const _Tp __xi2 = _Tp(2) * __xi;
      _Tp __h = __nu * __xi;
      if ( __h < __fp_min )
        __h = __fp_min;
      _Tp __b = __xi2 * __nu;
      _Tp __d = _Tp(0);
      _Tp __c = __h;
      int __i;
      for ( __i = 1; __i <= __max_iter; ++__i )
        {
          __b += __xi2;
          __d = _Tp(1) / (__b + __d);
          __c = __b + _Tp(1) / __c;
          const _Tp __del = __c * __d;
          __h *= __del;
          if (std::abs(__del - _Tp(1)) < __eps)
            break;
        }
      if (__i > __max_iter)
        std::__throw_runtime_error(("Argument x too large " "in __bessel_ik; " "try asymptotic expansion."));


      _Tp __Inul = __fp_min;
      _Tp __Ipnul = __h * __Inul;
      _Tp __Inul1 = __Inul;
      _Tp __Ipnu1 = __Ipnul;
      _Tp __fact = __nu * __xi;
      for (int __l = __nl; __l >= 1; --__l)
        {
          const _Tp __Inutemp = __fact * __Inul + __Ipnul;
          __fact -= __xi;
          __Ipnul = __fact * __Inutemp + __Inul;
          __Inul = __Inutemp;
        }
      _Tp __f = __Ipnul / __Inul;
      _Tp __Kmu, __Knu1;
      if (__x < __x_min)
        {
          const _Tp __x2 = __x / _Tp(2);
          const _Tp __pimu = __numeric_constants<_Tp>::__pi() * __mu;
          const _Tp __fact = (std::abs(__pimu) < __eps
                            ? _Tp(1) : __pimu / std::sin(__pimu));
          _Tp __d = -std::log(__x2);
          _Tp __e = __mu * __d;
          const _Tp __fact2 = (std::abs(__e) < __eps
                            ? _Tp(1) : std::sinh(__e) / __e);
          _Tp __gam1, __gam2, __gampl, __gammi;
          __gamma_temme(__mu, __gam1, __gam2, __gampl, __gammi);
          _Tp __ff = __fact
                   * (__gam1 * std::cosh(__e) + __gam2 * __fact2 * __d);
          _Tp __sum = __ff;
          __e = std::exp(__e);
          _Tp __p = __e / (_Tp(2) * __gampl);
          _Tp __q = _Tp(1) / (_Tp(2) * __e * __gammi);
          _Tp __c = _Tp(1);
          __d = __x2 * __x2;
          _Tp __sum1 = __p;
          int __i;
          for (__i = 1; __i <= __max_iter; ++__i)
            {
              __ff = (__i * __ff + __p + __q) / (__i * __i - __mu2);
              __c *= __d / __i;
              __p /= __i - __mu;
              __q /= __i + __mu;
              const _Tp __del = __c * __ff;
              __sum += __del;
              const _Tp __del1 = __c * (__p - __i * __ff);
              __sum1 += __del1;
              if (std::abs(__del) < __eps * std::abs(__sum))
                break;
            }
          if (__i > __max_iter)
            std::__throw_runtime_error(("Bessel k series failed to converge " "in __bessel_ik."));

          __Kmu = __sum;
          __Knu1 = __sum1 * __xi2;
        }
      else
        {
          _Tp __b = _Tp(2) * (_Tp(1) + __x);
          _Tp __d = _Tp(1) / __b;
          _Tp __delh = __d;
          _Tp __h = __delh;
          _Tp __q1 = _Tp(0);
          _Tp __q2 = _Tp(1);
          _Tp __a1 = _Tp(0.25L) - __mu2;
          _Tp __q = __c = __a1;
          _Tp __a = -__a1;
          _Tp __s = _Tp(1) + __q * __delh;
          int __i;
          for (__i = 2; __i <= __max_iter; ++__i)
            {
              __a -= 2 * (__i - 1);
              __c = -__a * __c / __i;
              const _Tp __qnew = (__q1 - __b * __q2) / __a;
              __q1 = __q2;
              __q2 = __qnew;
              __q += __c * __qnew;
              __b += _Tp(2);
              __d = _Tp(1) / (__b + __a * __d);
              __delh = (__b * __d - _Tp(1)) * __delh;
              __h += __delh;
              const _Tp __dels = __q * __delh;
              __s += __dels;
              if ( std::abs(__dels / __s) < __eps )
                break;
            }
          if (__i > __max_iter)
            std::__throw_runtime_error(("Steed's method failed " "in __bessel_ik."));

          __h = __a1 * __h;
          __Kmu = std::sqrt(__numeric_constants<_Tp>::__pi() / (_Tp(2) * __x))
                * std::exp(-__x) / __s;
          __Knu1 = __Kmu * (__mu + __x + _Tp(0.5L) - __h) * __xi;
        }

      _Tp __Kpmu = __mu * __xi * __Kmu - __Knu1;
      _Tp __Inumu = __xi / (__f * __Kmu - __Kpmu);
      __Inu = __Inumu * __Inul1 / __Inul;
      __Ipnu = __Inumu * __Ipnu1 / __Inul;
      for ( __i = 1; __i <= __nl; ++__i )
        {
          const _Tp __Knutemp = (__mu + __i) * __xi2 * __Knu1 + __Kmu;
          __Kmu = __Knu1;
          __Knu1 = __Knutemp;
        }
      __Knu = __Kmu;
      __Kpnu = __nu * __xi * __Kmu - __Knu1;

      return;
    }
# 267 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/modified_bessel_func.tcc" 3
    template<typename _Tp>
    _Tp
    __cyl_bessel_i(_Tp __nu, _Tp __x)
    {
      if (__nu < _Tp(0) || __x < _Tp(0))
        std::__throw_domain_error(("Bad argument " "in __cyl_bessel_i."));

      else if (__isnan(__nu) || __isnan(__x))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else if (__x * __x < _Tp(10) * (__nu + _Tp(1)))
        return __cyl_bessel_ij_series(__nu, __x, +_Tp(1), 200);
      else
        {
          _Tp __I_nu, __K_nu, __Ip_nu, __Kp_nu;
          __bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu);
          return __I_nu;
        }
    }
# 303 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/modified_bessel_func.tcc" 3
    template<typename _Tp>
    _Tp
    __cyl_bessel_k(_Tp __nu, _Tp __x)
    {
      if (__nu < _Tp(0) || __x < _Tp(0))
        std::__throw_domain_error(("Bad argument " "in __cyl_bessel_k."));

      else if (__isnan(__nu) || __isnan(__x))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else
        {
          _Tp __I_nu, __K_nu, __Ip_nu, __Kp_nu;
          __bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu);
          return __K_nu;
        }
    }
# 337 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/modified_bessel_func.tcc" 3
    template <typename _Tp>
    void
    __sph_bessel_ik(unsigned int __n, _Tp __x,
                    _Tp & __i_n, _Tp & __k_n, _Tp & __ip_n, _Tp & __kp_n)
    {
      const _Tp __nu = _Tp(__n) + _Tp(0.5L);

      _Tp __I_nu, __Ip_nu, __K_nu, __Kp_nu;
      __bessel_ik(__nu, __x, __I_nu, __K_nu, __Ip_nu, __Kp_nu);

      const _Tp __factor = __numeric_constants<_Tp>::__sqrtpio2()
                         / std::sqrt(__x);

      __i_n = __factor * __I_nu;
      __k_n = __factor * __K_nu;
      __ip_n = __factor * __Ip_nu - __i_n / (_Tp(2) * __x);
      __kp_n = __factor * __Kp_nu - __k_n / (_Tp(2) * __x);

      return;
    }
# 373 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/modified_bessel_func.tcc" 3
    template <typename _Tp>
    void
    __airy(_Tp __x, _Tp & __Ai, _Tp & __Bi, _Tp & __Aip, _Tp & __Bip)
    {
      const _Tp __absx = std::abs(__x);
      const _Tp __rootx = std::sqrt(__absx);
      const _Tp __z = _Tp(2) * __absx * __rootx / _Tp(3);
      const _Tp _S_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;
    }
  }





}
# 55 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/poly_hermite.tcc" 1 3
# 42 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/poly_hermite.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 56 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/poly_hermite.tcc" 3
  namespace __detail
  {
# 72 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/poly_hermite.tcc" 3
    template<typename _Tp>
    _Tp
    __poly_hermite_recursion(unsigned int __n, _Tp __x)
    {

      _Tp __H_0 = 1;
      if (__n == 0)
        return __H_0;


      _Tp __H_1 = 2 * __x;
      if (__n == 1)
        return __H_1;


      _Tp __H_n, __H_nm1, __H_nm2;
      unsigned int __i;
      for (__H_nm2 = __H_0, __H_nm1 = __H_1, __i = 2; __i <= __n; ++__i)
        {
          __H_n = 2 * (__x * __H_nm1 - (__i - 1) * __H_nm2);
          __H_nm2 = __H_nm1;
          __H_nm1 = __H_n;
        }

      return __H_n;
    }
# 114 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/poly_hermite.tcc" 3
    template<typename _Tp>
    inline _Tp
    __poly_hermite(unsigned int __n, _Tp __x)
    {
      if (__isnan(__x))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else
        return __poly_hermite_recursion(__n, __x);
    }
  }





}
# 56 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/poly_laguerre.tcc" 1 3
# 44 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/poly_laguerre.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 60 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/poly_laguerre.tcc" 3
  namespace __detail
  {
# 75 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/poly_laguerre.tcc" 3
    template<typename _Tpa, typename _Tp>
    _Tp
    __poly_laguerre_large_n(unsigned __n, _Tpa __alpha1, _Tp __x)
    {
      const _Tp __a = -_Tp(__n);
      const _Tp __b = _Tp(__alpha1) + _Tp(1);
      const _Tp __eta = _Tp(2) * __b - _Tp(4) * __a;
      const _Tp __cos2th = __x / __eta;
      const _Tp __sin2th = _Tp(1) - __cos2th;
      const _Tp __th = std::acos(std::sqrt(__cos2th));
      const _Tp __pre_h = __numeric_constants<_Tp>::__pi_2()
                        * __numeric_constants<_Tp>::__pi_2()
                        * __eta * __eta * __cos2th * __sin2th;


      const _Tp __lg_b = ::std::lgamma(_Tp(__n) + __b);
      const _Tp __lnfact = ::std::lgamma(_Tp(__n + 1));





      _Tp __pre_term1 = _Tp(0.5L) * (_Tp(1) - __b)
                      * std::log(_Tp(0.25L) * __x * __eta);
      _Tp __pre_term2 = _Tp(0.25L) * std::log(__pre_h);
      _Tp __lnpre = __lg_b - __lnfact + _Tp(0.5L) * __x
                      + __pre_term1 - __pre_term2;
      _Tp __ser_term1 = std::sin(__a * __numeric_constants<_Tp>::__pi());
      _Tp __ser_term2 = std::sin(_Tp(0.25L) * __eta
                              * (_Tp(2) * __th
                               - std::sin(_Tp(2) * __th))
                               + __numeric_constants<_Tp>::__pi_4());
      _Tp __ser = __ser_term1 + __ser_term2;

      return std::exp(__lnpre) * __ser;
    }
# 129 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/poly_laguerre.tcc" 3
    template<typename _Tpa, typename _Tp>
    _Tp
    __poly_laguerre_hyperg(unsigned int __n, _Tpa __alpha1, _Tp __x)
    {
      const _Tp __b = _Tp(__alpha1) + _Tp(1);
      const _Tp __mx = -__x;
      const _Tp __tc_sgn = (__x < _Tp(0) ? _Tp(1)
                         : ((__n % 2 == 1) ? -_Tp(1) : _Tp(1)));

      _Tp __tc = _Tp(1);
      const _Tp __ax = std::abs(__x);
      for (unsigned int __k = 1; __k <= __n; ++__k)
        __tc *= (__ax / __k);

      _Tp __term = __tc * __tc_sgn;
      _Tp __sum = __term;
      for (int __k = int(__n) - 1; __k >= 0; --__k)
        {
          __term *= ((__b + _Tp(__k)) / _Tp(int(__n) - __k))
                  * _Tp(__k + 1) / __mx;
          __sum += __term;
        }

      return __sum;
    }
# 185 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/poly_laguerre.tcc" 3
    template<typename _Tpa, typename _Tp>
    _Tp
    __poly_laguerre_recursion(unsigned int __n, _Tpa __alpha1, _Tp __x)
    {

      _Tp __l_0 = _Tp(1);
      if (__n == 0)
        return __l_0;


      _Tp __l_1 = -__x + _Tp(1) + _Tp(__alpha1);
      if (__n == 1)
        return __l_1;


      _Tp __l_n2 = __l_0;
      _Tp __l_n1 = __l_1;
      _Tp __l_n = _Tp(0);
      for (unsigned int __nn = 2; __nn <= __n; ++__nn)
        {
            __l_n = (_Tp(2 * __nn - 1) + _Tp(__alpha1) - __x)
                  * __l_n1 / _Tp(__nn)
                  - (_Tp(__nn - 1) + _Tp(__alpha1)) * __l_n2 / _Tp(__nn);
            __l_n2 = __l_n1;
            __l_n1 = __l_n;
        }

      return __l_n;
    }
# 244 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/poly_laguerre.tcc" 3
    template<typename _Tpa, typename _Tp>
    _Tp
    __poly_laguerre(unsigned int __n, _Tpa __alpha1, _Tp __x)
    {
      if (__x < _Tp(0))
        std::__throw_domain_error(("Negative argument " "in __poly_laguerre."));


      else if (__isnan(__x))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else if (__n == 0)
        return _Tp(1);
      else if (__n == 1)
        return _Tp(1) + _Tp(__alpha1) - __x;
      else if (__x == _Tp(0))
        {
          _Tp __prod = _Tp(__alpha1) + _Tp(1);
          for (unsigned int __k = 2; __k <= __n; ++__k)
            __prod *= (_Tp(__alpha1) + _Tp(__k)) / _Tp(__k);
          return __prod;
        }
      else if (__n > 10000000 && _Tp(__alpha1) > -_Tp(1)
            && __x < _Tp(2) * (_Tp(__alpha1) + _Tp(1)) + _Tp(4 * __n))
        return __poly_laguerre_large_n(__n, __alpha1, __x);
      else if (_Tp(__alpha1) >= _Tp(0)
           || (__x > _Tp(0) && _Tp(__alpha1) < -_Tp(__n + 1)))
        return __poly_laguerre_recursion(__n, __alpha1, __x);
      else
        return __poly_laguerre_hyperg(__n, __alpha1, __x);
    }
# 296 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/poly_laguerre.tcc" 3
    template<typename _Tp>
    inline _Tp
    __assoc_laguerre(unsigned int __n, unsigned int __m, _Tp __x)
    { return __poly_laguerre<unsigned int, _Tp>(__n, __m, __x); }
# 316 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/poly_laguerre.tcc" 3
    template<typename _Tp>
    inline _Tp
    __laguerre(unsigned int __n, _Tp __x)
    { return __poly_laguerre<unsigned int, _Tp>(__n, 0, __x); }
  }






}
# 57 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/riemann_zeta.tcc" 1 3
# 47 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/riemann_zeta.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 63 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/riemann_zeta.tcc" 3
  namespace __detail
  {
# 78 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/riemann_zeta.tcc" 3
    template<typename _Tp>
    _Tp
    __riemann_zeta_sum(_Tp __s)
    {

      if (__s < _Tp(1))
        std::__throw_domain_error(("Bad argument in zeta sum."));

      const unsigned int max_iter = 10000;
      _Tp __zeta = _Tp(0);
      for (unsigned int __k = 1; __k < max_iter; ++__k)
        {
          _Tp __term = std::pow(static_cast<_Tp>(__k), -__s);
          if (__term < std::numeric_limits<_Tp>::epsilon())
            {
              break;
            }
          __zeta += __term;
        }

      return __zeta;
    }
# 115 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/riemann_zeta.tcc" 3
    template<typename _Tp>
    _Tp
    __riemann_zeta_alt(_Tp __s)
    {
      _Tp __sgn = _Tp(1);
      _Tp __zeta = _Tp(0);
      for (unsigned int __i = 1; __i < 10000000; ++__i)
        {
          _Tp __term = __sgn / std::pow(__i, __s);
          if (std::abs(__term) < std::numeric_limits<_Tp>::epsilon())
            break;
          __zeta += __term;
          __sgn *= _Tp(-1);
        }
      __zeta /= _Tp(1) - std::pow(_Tp(2), _Tp(1) - __s);

      return __zeta;
    }
# 157 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/riemann_zeta.tcc" 3
    template<typename _Tp>
    _Tp
    __riemann_zeta_glob(_Tp __s)
    {
      _Tp __zeta = _Tp(0);

      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();

      const _Tp __max_bincoeff = std::numeric_limits<_Tp>::max_exponent10
                               * std::log(_Tp(10)) - _Tp(1);



      if (__s < _Tp(0))
        {

          if (::std::fmod(__s,_Tp(2)) == _Tp(0))
            return _Tp(0);
          else

            {
              _Tp __zeta = __riemann_zeta_glob(_Tp(1) - __s);
              __zeta *= std::pow(_Tp(2)
                     * __numeric_constants<_Tp>::__pi(), __s)
                     * std::sin(__numeric_constants<_Tp>::__pi_2() * __s)

                     * std::exp(::std::lgamma(_Tp(1) - __s))



                     / __numeric_constants<_Tp>::__pi();
              return __zeta;
            }
        }

      _Tp __num = _Tp(0.5L);
      const unsigned int __maxit = 10000;
      for (unsigned int __i = 0; __i < __maxit; ++__i)
        {
          bool __punt = false;
          _Tp __sgn = _Tp(1);
          _Tp __term = _Tp(0);
          for (unsigned int __j = 0; __j <= __i; ++__j)
            {

              _Tp __bincoeff = ::std::lgamma(_Tp(1 + __i))
                              - ::std::lgamma(_Tp(1 + __j))
                              - ::std::lgamma(_Tp(1 + __i - __j));





              if (__bincoeff > __max_bincoeff)
                {

                  __punt = true;
                  break;
                }
              __bincoeff = std::exp(__bincoeff);
              __term += __sgn * __bincoeff * std::pow(_Tp(1 + __j), -__s);
              __sgn *= _Tp(-1);
            }
          if (__punt)
            break;
          __term *= __num;
          __zeta += __term;
          if (std::abs(__term/__zeta) < __eps)
            break;
          __num *= _Tp(0.5L);
        }

      __zeta /= _Tp(1) - std::pow(_Tp(2), _Tp(1) - __s);

      return __zeta;
    }
# 252 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/riemann_zeta.tcc" 3
    template<typename _Tp>
    _Tp
    __riemann_zeta_product(_Tp __s)
    {
      static const _Tp __prime[] = {
        _Tp(2), _Tp(3), _Tp(5), _Tp(7), _Tp(11), _Tp(13), _Tp(17), _Tp(19),
        _Tp(23), _Tp(29), _Tp(31), _Tp(37), _Tp(41), _Tp(43), _Tp(47),
        _Tp(53), _Tp(59), _Tp(61), _Tp(67), _Tp(71), _Tp(73), _Tp(79),
        _Tp(83), _Tp(89), _Tp(97), _Tp(101), _Tp(103), _Tp(107), _Tp(109)
      };
      static const unsigned int __num_primes = sizeof(__prime) / sizeof(_Tp);

      _Tp __zeta = _Tp(1);
      for (unsigned int __i = 0; __i < __num_primes; ++__i)
        {
          const _Tp __fact = _Tp(1) - std::pow(__prime[__i], -__s);
          __zeta *= __fact;
          if (_Tp(1) - __fact < std::numeric_limits<_Tp>::epsilon())
            break;
        }

      __zeta = _Tp(1) / __zeta;

      return __zeta;
    }
# 293 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/riemann_zeta.tcc" 3
    template<typename _Tp>
    _Tp
    __riemann_zeta(_Tp __s)
    {
      if (__isnan(__s))
        return std::numeric_limits<_Tp>::quiet_NaN();
      else if (__s == _Tp(1))
        return std::numeric_limits<_Tp>::infinity();
      else if (__s < -_Tp(19))
        {
          _Tp __zeta = __riemann_zeta_product(_Tp(1) - __s);
          __zeta *= std::pow(_Tp(2) * __numeric_constants<_Tp>::__pi(), __s)
                 * std::sin(__numeric_constants<_Tp>::__pi_2() * __s)

                 * std::exp(::std::lgamma(_Tp(1) - __s))



                 / __numeric_constants<_Tp>::__pi();
          return __zeta;
        }
      else if (__s < _Tp(20))
        {

          bool __glob = true;
          if (__glob)
            return __riemann_zeta_glob(__s);
          else
            {
              if (__s > _Tp(1))
                return __riemann_zeta_sum(__s);
              else
                {
                  _Tp __zeta = std::pow(_Tp(2)
                                * __numeric_constants<_Tp>::__pi(), __s)
                         * std::sin(__numeric_constants<_Tp>::__pi_2() * __s)

                             * ::std::tgamma(_Tp(1) - __s)



                             * __riemann_zeta_sum(_Tp(1) - __s);
                  return __zeta;
                }
            }
        }
      else
        return __riemann_zeta_product(__s);
    }
# 365 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/riemann_zeta.tcc" 3
    template<typename _Tp>
    _Tp
    __hurwitz_zeta_glob(_Tp __a, _Tp __s)
    {
      _Tp __zeta = _Tp(0);

      const _Tp __eps = std::numeric_limits<_Tp>::epsilon();

      const _Tp __max_bincoeff = std::numeric_limits<_Tp>::max_exponent10
                               * std::log(_Tp(10)) - _Tp(1);

      const unsigned int __maxit = 10000;
      for (unsigned int __i = 0; __i < __maxit; ++__i)
        {
          bool __punt = false;
          _Tp __sgn = _Tp(1);
          _Tp __term = _Tp(0);
          for (unsigned int __j = 0; __j <= __i; ++__j)
            {

              _Tp __bincoeff = ::std::lgamma(_Tp(1 + __i))
                              - ::std::lgamma(_Tp(1 + __j))
                              - ::std::lgamma(_Tp(1 + __i - __j));





              if (__bincoeff > __max_bincoeff)
                {

                  __punt = true;
                  break;
                }
              __bincoeff = std::exp(__bincoeff);
              __term += __sgn * __bincoeff * std::pow(_Tp(__a + __j), -__s);
              __sgn *= _Tp(-1);
            }
          if (__punt)
            break;
          __term /= _Tp(__i + 1);
          if (std::abs(__term / __zeta) < __eps)
            break;
          __zeta += __term;
        }

      __zeta /= __s - _Tp(1);

      return __zeta;
    }
# 430 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/tr1/riemann_zeta.tcc" 3
    template<typename _Tp>
    inline _Tp
    __hurwitz_zeta(_Tp __a, _Tp __s)
    { return __hurwitz_zeta_glob(__a, __s); }
  }






}
# 58 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{
# 203 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 3
  inline float
  assoc_laguerref(unsigned int __n, unsigned int __m, float __x)
  { return __detail::__assoc_laguerre<float>(__n, __m, __x); }







  inline long double
  assoc_laguerrel(unsigned int __n, unsigned int __m, long double __x)
  { return __detail::__assoc_laguerre<long double>(__n, __m, __x); }
# 248 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 3
  template<typename _Tp>
    inline typename __gnu_cxx::__promote<_Tp>::__type
    assoc_laguerre(unsigned int __n, unsigned int __m, _Tp __x)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __detail::__assoc_laguerre<__type>(__n, __m, __x);
    }
# 264 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 3
  inline float
  assoc_legendref(unsigned int __l, unsigned int __m, float __x)
  { return __detail::__assoc_legendre_p<float>(__l, __m, __x); }






  inline long double
  assoc_legendrel(unsigned int __l, unsigned int __m, long double __x)
  { return __detail::__assoc_legendre_p<long double>(__l, __m, __x); }
# 294 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 3
  template<typename _Tp>
    inline typename __gnu_cxx::__promote<_Tp>::__type
    assoc_legendre(unsigned int __l, unsigned int __m, _Tp __x)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __detail::__assoc_legendre_p<__type>(__l, __m, __x);
    }
# 309 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 3
  inline float
  betaf(float __a, float __b)
  { return __detail::__beta<float>(__a, __b); }







  inline long double
  betal(long double __a, long double __b)
  { return __detail::__beta<long double>(__a, __b); }
# 339 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 3
  template<typename _Tpa, typename _Tpb>
    inline typename __gnu_cxx::__promote_2<_Tpa, _Tpb>::__type
    beta(_Tpa __a, _Tpb __b)
    {
      typedef typename __gnu_cxx::__promote_2<_Tpa, _Tpb>::__type __type;
      return __detail::__beta<__type>(__a, __b);
    }
# 355 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 3
  inline float
  comp_ellint_1f(float __k)
  { return __detail::__comp_ellint_1<float>(__k); }







  inline long double
  comp_ellint_1l(long double __k)
  { return __detail::__comp_ellint_1<long double>(__k); }
# 387 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 3
  template<typename _Tp>
    inline typename __gnu_cxx::__promote<_Tp>::__type
    comp_ellint_1(_Tp __k)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __detail::__comp_ellint_1<__type>(__k);
    }
# 403 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 3
  inline float
  comp_ellint_2f(float __k)
  { return __detail::__comp_ellint_2<float>(__k); }







  inline long double
  comp_ellint_2l(long double __k)
  { return __detail::__comp_ellint_2<long double>(__k); }
# 434 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 3
  template<typename _Tp>
    inline typename __gnu_cxx::__promote<_Tp>::__type
    comp_ellint_2(_Tp __k)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __detail::__comp_ellint_2<__type>(__k);
    }
# 450 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 3
  inline float
  comp_ellint_3f(float __k, float __nu)
  { return __detail::__comp_ellint_3<float>(__k, __nu); }







  inline long double
  comp_ellint_3l(long double __k, long double __nu)
  { return __detail::__comp_ellint_3<long double>(__k, __nu); }
# 485 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 3
  template<typename _Tp, typename _Tpn>
    inline typename __gnu_cxx::__promote_2<_Tp, _Tpn>::__type
    comp_ellint_3(_Tp __k, _Tpn __nu)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Tpn>::__type __type;
      return __detail::__comp_ellint_3<__type>(__k, __nu);
    }
# 501 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 3
  inline float
  cyl_bessel_if(float __nu, float __x)
  { return __detail::__cyl_bessel_i<float>(__nu, __x); }







  inline long double
  cyl_bessel_il(long double __nu, long double __x)
  { return __detail::__cyl_bessel_i<long double>(__nu, __x); }
# 531 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 3
  template<typename _Tpnu, typename _Tp>
    inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
    cyl_bessel_i(_Tpnu __nu, _Tp __x)
    {
      typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
      return __detail::__cyl_bessel_i<__type>(__nu, __x);
    }
# 547 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 3
  inline float
  cyl_bessel_jf(float __nu, float __x)
  { return __detail::__cyl_bessel_j<float>(__nu, __x); }







  inline long double
  cyl_bessel_jl(long double __nu, long double __x)
  { return __detail::__cyl_bessel_j<long double>(__nu, __x); }
# 577 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 3
  template<typename _Tpnu, typename _Tp>
    inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
    cyl_bessel_j(_Tpnu __nu, _Tp __x)
    {
      typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
      return __detail::__cyl_bessel_j<__type>(__nu, __x);
    }
# 593 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 3
  inline float
  cyl_bessel_kf(float __nu, float __x)
  { return __detail::__cyl_bessel_k<float>(__nu, __x); }







  inline long double
  cyl_bessel_kl(long double __nu, long double __x)
  { return __detail::__cyl_bessel_k<long double>(__nu, __x); }
# 629 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 3
  template<typename _Tpnu, typename _Tp>
    inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
    cyl_bessel_k(_Tpnu __nu, _Tp __x)
    {
      typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
      return __detail::__cyl_bessel_k<__type>(__nu, __x);
    }
# 645 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 3
  inline float
  cyl_neumannf(float __nu, float __x)
  { return __detail::__cyl_neumann_n<float>(__nu, __x); }







  inline long double
  cyl_neumannl(long double __nu, long double __x)
  { return __detail::__cyl_neumann_n<long double>(__nu, __x); }
# 677 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 3
  template<typename _Tpnu, typename _Tp>
    inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
    cyl_neumann(_Tpnu __nu, _Tp __x)
    {
      typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
      return __detail::__cyl_neumann_n<__type>(__nu, __x);
    }
# 693 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 3
  inline float
  ellint_1f(float __k, float __phi)
  { return __detail::__ellint_1<float>(__k, __phi); }







  inline long double
  ellint_1l(long double __k, long double __phi)
  { return __detail::__ellint_1<long double>(__k, __phi); }
# 725 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 3
  template<typename _Tp, typename _Tpp>
    inline typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type
    ellint_1(_Tp __k, _Tpp __phi)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type __type;
      return __detail::__ellint_1<__type>(__k, __phi);
    }
# 741 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 3
  inline float
  ellint_2f(float __k, float __phi)
  { return __detail::__ellint_2<float>(__k, __phi); }







  inline long double
  ellint_2l(long double __k, long double __phi)
  { return __detail::__ellint_2<long double>(__k, __phi); }
# 773 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 3
  template<typename _Tp, typename _Tpp>
    inline typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type
    ellint_2(_Tp __k, _Tpp __phi)
    {
      typedef typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type __type;
      return __detail::__ellint_2<__type>(__k, __phi);
    }
# 789 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 3
  inline float
  ellint_3f(float __k, float __nu, float __phi)
  { return __detail::__ellint_3<float>(__k, __nu, __phi); }







  inline long double
  ellint_3l(long double __k, long double __nu, long double __phi)
  { return __detail::__ellint_3<long double>(__k, __nu, __phi); }
# 826 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 3
  template<typename _Tp, typename _Tpn, typename _Tpp>
    inline typename __gnu_cxx::__promote_3<_Tp, _Tpn, _Tpp>::__type
    ellint_3(_Tp __k, _Tpn __nu, _Tpp __phi)
    {
      typedef typename __gnu_cxx::__promote_3<_Tp, _Tpn, _Tpp>::__type __type;
      return __detail::__ellint_3<__type>(__k, __nu, __phi);
    }
# 841 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 3
  inline float
  expintf(float __x)
  { return __detail::__expint<float>(__x); }







  inline long double
  expintl(long double __x)
  { return __detail::__expint<long double>(__x); }
# 866 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 3
  template<typename _Tp>
    inline typename __gnu_cxx::__promote<_Tp>::__type
    expint(_Tp __x)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __detail::__expint<__type>(__x);
    }
# 882 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 3
  inline float
  hermitef(unsigned int __n, float __x)
  { return __detail::__poly_hermite<float>(__n, __x); }







  inline long double
  hermitel(unsigned int __n, long double __x)
  { return __detail::__poly_hermite<long double>(__n, __x); }
# 914 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 3
  template<typename _Tp>
    inline typename __gnu_cxx::__promote<_Tp>::__type
    hermite(unsigned int __n, _Tp __x)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __detail::__poly_hermite<__type>(__n, __x);
    }
# 930 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 3
  inline float
  laguerref(unsigned int __n, float __x)
  { return __detail::__laguerre<float>(__n, __x); }







  inline long double
  laguerrel(unsigned int __n, long double __x)
  { return __detail::__laguerre<long double>(__n, __x); }
# 958 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 3
  template<typename _Tp>
    inline typename __gnu_cxx::__promote<_Tp>::__type
    laguerre(unsigned int __n, _Tp __x)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __detail::__laguerre<__type>(__n, __x);
    }
# 974 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 3
  inline float
  legendref(unsigned int __l, float __x)
  { return __detail::__poly_legendre_p<float>(__l, __x); }







  inline long double
  legendrel(unsigned int __l, long double __x)
  { return __detail::__poly_legendre_p<long double>(__l, __x); }
# 1003 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 3
  template<typename _Tp>
    inline typename __gnu_cxx::__promote<_Tp>::__type
    legendre(unsigned int __l, _Tp __x)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __detail::__poly_legendre_p<__type>(__l, __x);
    }
# 1019 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 3
  inline float
  riemann_zetaf(float __s)
  { return __detail::__riemann_zeta<float>(__s); }







  inline long double
  riemann_zetal(long double __s)
  { return __detail::__riemann_zeta<long double>(__s); }
# 1054 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 3
  template<typename _Tp>
    inline typename __gnu_cxx::__promote<_Tp>::__type
    riemann_zeta(_Tp __s)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __detail::__riemann_zeta<__type>(__s);
    }
# 1070 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 3
  inline float
  sph_besself(unsigned int __n, float __x)
  { return __detail::__sph_bessel<float>(__n, __x); }







  inline long double
  sph_bessell(unsigned int __n, long double __x)
  { return __detail::__sph_bessel<long double>(__n, __x); }
# 1098 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 3
  template<typename _Tp>
    inline typename __gnu_cxx::__promote<_Tp>::__type
    sph_bessel(unsigned int __n, _Tp __x)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __detail::__sph_bessel<__type>(__n, __x);
    }
# 1114 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 3
  inline float
  sph_legendref(unsigned int __l, unsigned int __m, float __theta)
  { return __detail::__sph_legendre<float>(__l, __m, __theta); }
# 1125 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 3
  inline long double
  sph_legendrel(unsigned int __l, unsigned int __m, long double __theta)
  { return __detail::__sph_legendre<long double>(__l, __m, __theta); }
# 1145 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 3
  template<typename _Tp>
    inline typename __gnu_cxx::__promote<_Tp>::__type
    sph_legendre(unsigned int __l, unsigned int __m, _Tp __theta)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __detail::__sph_legendre<__type>(__l, __m, __theta);
    }
# 1161 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 3
  inline float
  sph_neumannf(unsigned int __n, float __x)
  { return __detail::__sph_neumann<float>(__n, __x); }







  inline long double
  sph_neumannl(unsigned int __n, long double __x)
  { return __detail::__sph_neumann<long double>(__n, __x); }
# 1189 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 3
  template<typename _Tp>
    inline typename __gnu_cxx::__promote<_Tp>::__type
    sph_neumann(unsigned int __n, _Tp __x)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return __detail::__sph_neumann<__type>(__n, __x);
    }




}


namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
# 1216 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 3
  inline float
  airy_aif(float __x)
  {
    float __Ai, __Bi, __Aip, __Bip;
    std::__detail::__airy<float>(__x, __Ai, __Bi, __Aip, __Bip);
    return __Ai;
  }




  inline long double
  airy_ail(long double __x)
  {
    long double __Ai, __Bi, __Aip, __Bip;
    std::__detail::__airy<long double>(__x, __Ai, __Bi, __Aip, __Bip);
    return __Ai;
  }




  template<typename _Tp>
    inline typename __gnu_cxx::__promote<_Tp>::__type
    airy_ai(_Tp __x)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      __type __Ai, __Bi, __Aip, __Bip;
      std::__detail::__airy<__type>(__x, __Ai, __Bi, __Aip, __Bip);
      return __Ai;
    }




  inline float
  airy_bif(float __x)
  {
    float __Ai, __Bi, __Aip, __Bip;
    std::__detail::__airy<float>(__x, __Ai, __Bi, __Aip, __Bip);
    return __Bi;
  }




  inline long double
  airy_bil(long double __x)
  {
    long double __Ai, __Bi, __Aip, __Bip;
    std::__detail::__airy<long double>(__x, __Ai, __Bi, __Aip, __Bip);
    return __Bi;
  }




  template<typename _Tp>
    inline typename __gnu_cxx::__promote<_Tp>::__type
    airy_bi(_Tp __x)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      __type __Ai, __Bi, __Aip, __Bip;
      std::__detail::__airy<__type>(__x, __Ai, __Bi, __Aip, __Bip);
      return __Bi;
    }
# 1292 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 3
  inline float
  conf_hypergf(float __a, float __c, float __x)
  { return std::__detail::__conf_hyperg<float>(__a, __c, __x); }
# 1303 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 3
  inline long double
  conf_hypergl(long double __a, long double __c, long double __x)
  { return std::__detail::__conf_hyperg<long double>(__a, __c, __x); }
# 1323 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 3
  template<typename _Tpa, typename _Tpc, typename _Tp>
    inline typename __gnu_cxx::__promote_3<_Tpa, _Tpc, _Tp>::__type
    conf_hyperg(_Tpa __a, _Tpc __c, _Tp __x)
    {
      typedef typename __gnu_cxx::__promote_3<_Tpa, _Tpc, _Tp>::__type __type;
      return std::__detail::__conf_hyperg<__type>(__a, __c, __x);
    }
# 1340 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 3
  inline float
  hypergf(float __a, float __b, float __c, float __x)
  { return std::__detail::__hyperg<float>(__a, __b, __c, __x); }
# 1351 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 3
  inline long double
  hypergl(long double __a, long double __b, long double __c, long double __x)
  { return std::__detail::__hyperg<long double>(__a, __b, __c, __x); }
# 1372 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/specfun.h" 3
  template<typename _Tpa, typename _Tpb, typename _Tpc, typename _Tp>
    inline typename __gnu_cxx::__promote_4<_Tpa, _Tpb, _Tpc, _Tp>::__type
    hyperg(_Tpa __a, _Tpb __b, _Tpc __c, _Tp __x)
    {
      typedef typename __gnu_cxx::__promote_4<_Tpa, _Tpb, _Tpc, _Tp>
  ::__type __type;
      return std::__detail::__hyperg<__type>(__a, __b, __c, __x);
    }



}
# 3899 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cmath" 2 3


}
# 37 "/usr/include/fmt/format.h" 2 3 4

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 1 3 4
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 3


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 43 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 2 3
# 39 "/usr/include/fmt/format.h" 2 3 4
# 49 "/usr/include/fmt/format.h" 3 4
# 1 "/usr/include/fmt/core.h" 1 3 4
# 12 "/usr/include/fmt/core.h" 3 4
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdio" 1 3 4
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdio" 3
# 13 "/usr/include/fmt/core.h" 2 3 4
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 1 3 4
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 3


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 43 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 2 3
# 14 "/usr/include/fmt/core.h" 2 3 4
# 267 "/usr/include/fmt/core.h" 3 4
namespace fmt { inline namespace v10 {


template <bool B, typename T = void>
using enable_if_t = typename std::enable_if<B, T>::type;
template <bool B, typename T, typename F>
using conditional_t = typename std::conditional<B, T, F>::type;
template <bool B> using bool_constant = std::integral_constant<bool, B>;
template <typename T>
using remove_reference_t = typename std::remove_reference<T>::type;
template <typename T>
using remove_const_t = typename std::remove_const<T>::type;
template <typename T>
using remove_cvref_t = typename std::remove_cv<remove_reference_t<T>>::type;
template <typename T> struct type_identity {
  using type = T;
};
template <typename T> using type_identity_t = typename type_identity<T>::type;
template <typename T>
using underlying_t = typename std::underlying_type<T>::type;


template <typename T> struct is_contiguous : std::false_type {};
template <typename Char>
struct is_contiguous<std::basic_string<Char>> : std::true_type {};

struct monostate {
  constexpr monostate() {}
};
# 309 "/usr/include/fmt/core.h" 3 4
template <typename T, fmt::enable_if_t<(std::is_same<T, std::byte>::value), int> = 0>
inline auto format_as(T b) -> unsigned char {
  return static_cast<unsigned char>(b);
}


namespace detail {



template <typename... T> constexpr void ignore_unused(const T&...) {}

constexpr inline __attribute__((always_inline)) auto is_constant_evaluated(
    bool default_value = false) noexcept -> bool {
# 332 "/usr/include/fmt/core.h" 3 4
  ignore_unused(default_value);
  return std::is_constant_evaluated();



}


template <typename T> constexpr inline __attribute__((always_inline)) auto const_check(T value) -> T {
  return value;
}

[[noreturn]] __attribute__((visibility("default"))) void assert_fail(const char* file, int line,
                                      const char* message);
# 361 "/usr/include/fmt/core.h" 3 4
template <typename Char> using std_string_view = std::basic_string_view<Char>;
# 374 "/usr/include/fmt/core.h" 3 4
using int128_opt = __int128_t;
using uint128_opt = __uint128_t;
template <typename T> inline auto convert_for_visit(T value) -> T {
  return value;
}
# 390 "/usr/include/fmt/core.h" 3 4
template <typename Int>
constexpr auto to_unsigned(Int value) ->
    typename std::make_unsigned<Int>::type {
  ((std::is_unsigned<Int>::value || value >= 0) ? (void)0 : fmt::detail::assert_fail("/usr/include/fmt/core.h", 393, ("negative value")));
  return static_cast<typename std::make_unsigned<Int>::type>(value);
}

constexpr inline auto is_utf8() -> bool {
                                   constexpr unsigned char section[] = "\u00A7";


  using uchar = unsigned char;
  return !0 || (sizeof(section) == 3 && uchar(section[0]) == 0xC2 &&
                         uchar(section[1]) == 0xA7);
}
}
# 415 "/usr/include/fmt/core.h" 3 4
template <typename Char> class basic_string_view {
 private:
  const Char* data_;
  size_t size_;

 public:
  using value_type = Char;
  using iterator = const Char*;

  constexpr basic_string_view() noexcept : data_(nullptr), size_(0) {}


  constexpr basic_string_view(const Char* s, size_t count) noexcept
      : data_(s), size_(count) {}







  constexpr
  inline __attribute__((always_inline))
  basic_string_view(const Char* s)
      : data_(s),
        size_(detail::const_check(std::is_same<Char, char>::value &&
                                  !detail::is_constant_evaluated(true))
                  ? std::strlen(reinterpret_cast<const char*>(s))
                  : std::char_traits<Char>::length(s)) {}


  template <typename Traits, typename Alloc>
  constexpr basic_string_view(
      const std::basic_string<Char, Traits, Alloc>& s) noexcept
      : data_(s.data()), size_(s.size()) {}

  template <typename S, fmt::enable_if_t<(std::is_same< S, detail::std_string_view<Char>>::value), int> = 0>

  constexpr basic_string_view(S s) noexcept
      : data_(s.data()), size_(s.size()) {}


  constexpr auto data() const noexcept -> const Char* { return data_; }


  constexpr auto size() const noexcept -> size_t { return size_; }

  constexpr auto begin() const noexcept -> iterator { return data_; }
  constexpr auto end() const noexcept -> iterator { return data_ + size_; }

  constexpr auto operator[](size_t pos) const noexcept -> const Char& {
    return data_[pos];
  }

  constexpr void remove_prefix(size_t n) noexcept {
    data_ += n;
    size_ -= n;
  }

  constexpr auto starts_with(
      basic_string_view<Char> sv) const noexcept -> bool {
    return size_ >= sv.size_ &&
           std::char_traits<Char>::compare(data_, sv.data_, sv.size_) == 0;
  }
  constexpr auto starts_with(Char c) const noexcept -> bool {
    return size_ >= 1 && std::char_traits<Char>::eq(*data_, c);
  }
  constexpr auto starts_with(const Char* s) const -> bool {
    return starts_with(basic_string_view<Char>(s));
  }


  constexpr auto compare(basic_string_view other) const -> int {
    size_t str_size = size_ < other.size_ ? size_ : other.size_;
    int result = std::char_traits<Char>::compare(data_, other.data_, str_size);
    if (result == 0)
      result = size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1);
    return result;
  }

  constexpr friend auto operator==(basic_string_view lhs,
                                                   basic_string_view rhs)
      -> bool {
    return lhs.compare(rhs) == 0;
  }
  friend auto operator!=(basic_string_view lhs, basic_string_view rhs) -> bool {
    return lhs.compare(rhs) != 0;
  }
  friend auto operator<(basic_string_view lhs, basic_string_view rhs) -> bool {
    return lhs.compare(rhs) < 0;
  }
  friend auto operator<=(basic_string_view lhs, basic_string_view rhs) -> bool {
    return lhs.compare(rhs) <= 0;
  }
  friend auto operator>(basic_string_view lhs, basic_string_view rhs) -> bool {
    return lhs.compare(rhs) > 0;
  }
  friend auto operator>=(basic_string_view lhs, basic_string_view rhs) -> bool {
    return lhs.compare(rhs) >= 0;
  }
};


using string_view = basic_string_view<char>;



template <typename T> struct is_char : std::false_type {};
template <> struct is_char<char> : std::true_type {};

namespace detail {


struct compile_string {};

template <typename S>
struct is_compile_string : std::is_base_of<compile_string, S> {};

template <typename Char, fmt::enable_if_t<(is_char<Char>::value), int> = 0>
inline __attribute__((always_inline)) auto to_string_view(const Char* s) -> basic_string_view<Char> {
  return s;
}
template <typename Char, typename Traits, typename Alloc>
inline auto to_string_view(const std::basic_string<Char, Traits, Alloc>& s)
    -> basic_string_view<Char> {
  return s;
}
template <typename Char>
constexpr auto to_string_view(basic_string_view<Char> s)
    -> basic_string_view<Char> {
  return s;
}
template <typename Char,
          fmt::enable_if_t<(!std::is_empty<std_string_view<Char>>::value), int> = 0>
inline auto to_string_view(std_string_view<Char> s) -> basic_string_view<Char> {
  return s;
}
template <typename S, fmt::enable_if_t<(is_compile_string<S>::value), int> = 0>
constexpr auto to_string_view(const S& s)
    -> basic_string_view<typename S::char_type> {
  return basic_string_view<typename S::char_type>(s);
}
void to_string_view(...);





template <typename S>
struct is_string
    : std::is_class<decltype(detail::to_string_view(std::declval<S>()))> {};

template <typename S, typename = void> struct char_t_impl {};
template <typename S> struct char_t_impl<S, enable_if_t<is_string<S>::value>> {
  using result = decltype(to_string_view(std::declval<S>()));
  using type = typename result::value_type;
};

enum class type {
  none_type,

  int_type,
  uint_type,
  long_long_type,
  ulong_long_type,
  int128_type,
  uint128_type,
  bool_type,
  char_type,
  last_integer_type = char_type,

  float_type,
  double_type,
  long_double_type,
  last_numeric_type = long_double_type,
  cstring_type,
  string_type,
  pointer_type,
  custom_type
};


template <typename T, typename Char>
struct type_constant : std::integral_constant<type, type::custom_type> {};






template <typename Char> struct type_constant<int, Char> : std::integral_constant<type, type::int_type> {};
template <typename Char> struct type_constant<unsigned, Char> : std::integral_constant<type, type::uint_type> {};
template <typename Char> struct type_constant<long long, Char> : std::integral_constant<type, type::long_long_type> {};
template <typename Char> struct type_constant<unsigned long long, Char> : std::integral_constant<type, type::ulong_long_type> {};
template <typename Char> struct type_constant<int128_opt, Char> : std::integral_constant<type, type::int128_type> {};
template <typename Char> struct type_constant<uint128_opt, Char> : std::integral_constant<type, type::uint128_type> {};
template <typename Char> struct type_constant<bool, Char> : std::integral_constant<type, type::bool_type> {};
template <typename Char> struct type_constant<Char, Char> : std::integral_constant<type, type::char_type> {};
template <typename Char> struct type_constant<float, Char> : std::integral_constant<type, type::float_type> {};
template <typename Char> struct type_constant<double, Char> : std::integral_constant<type, type::double_type> {};
template <typename Char> struct type_constant<long double, Char> : std::integral_constant<type, type::long_double_type> {};
template <typename Char> struct type_constant<const Char*, Char> : std::integral_constant<type, type::cstring_type> {};
template <typename Char> struct type_constant<basic_string_view<Char>, Char> : std::integral_constant<type, type::string_type> {};
template <typename Char> struct type_constant<const void*, Char> : std::integral_constant<type, type::pointer_type> {};

constexpr auto is_integral_type(type t) -> bool {
  return t > type::none_type && t <= type::last_integer_type;
}
constexpr auto is_arithmetic_type(type t) -> bool {
  return t > type::none_type && t <= type::last_numeric_type;
}

constexpr auto set(type rhs) -> int { return 1 << static_cast<int>(rhs); }
constexpr auto in(type t, int set) -> bool {
  return ((set >> static_cast<int>(t)) & 1) != 0;
}


enum {
  sint_set =
      set(type::int_type) | set(type::long_long_type) | set(type::int128_type),
  uint_set = set(type::uint_type) | set(type::ulong_long_type) |
             set(type::uint128_type),
  bool_set = set(type::bool_type),
  char_set = set(type::char_type),
  float_set = set(type::float_type) | set(type::double_type) |
              set(type::long_double_type),
  string_set = set(type::string_type),
  cstring_set = set(type::cstring_type),
  pointer_set = set(type::pointer_type)
};


[[noreturn]] __attribute__((visibility("default"))) void throw_format_error(const char* message);

struct error_handler {
  constexpr error_handler() = default;


  [[noreturn]] void on_error(const char* message) {
    throw_format_error(message);
  }
};
}


using detail::throw_format_error;


template <typename S> using char_t = typename detail::char_t_impl<S>::type;
# 674 "/usr/include/fmt/core.h" 3 4
template <typename Char> class basic_format_parse_context {
 private:
  basic_string_view<Char> format_str_;
  int next_arg_id_;

  constexpr void do_check_arg_id(int id);

 public:
  using char_type = Char;
  using iterator = const Char*;

  explicit constexpr basic_format_parse_context(
      basic_string_view<Char> format_str, int next_arg_id = 0)
      : format_str_(format_str), next_arg_id_(next_arg_id) {}





  constexpr auto begin() const noexcept -> iterator {
    return format_str_.begin();
  }




  constexpr auto end() const noexcept -> iterator { return format_str_.end(); }


  constexpr void advance_to(iterator it) {
    format_str_.remove_prefix(detail::to_unsigned(it - begin()));
  }





  constexpr auto next_arg_id() -> int {
    if (next_arg_id_ < 0) {
      detail::throw_format_error(
          "cannot switch from manual to automatic argument indexing");
      return 0;
    }
    int id = next_arg_id_++;
    do_check_arg_id(id);
    return id;
  }





  constexpr void check_arg_id(int id) {
    if (next_arg_id_ > 0) {
      detail::throw_format_error(
          "cannot switch from automatic to manual argument indexing");
      return;
    }
    next_arg_id_ = -1;
    do_check_arg_id(id);
  }
  constexpr void check_arg_id(basic_string_view<Char>) {}
  constexpr void check_dynamic_spec(int arg_id);
};


using format_parse_context = basic_format_parse_context<char>;

namespace detail {

template <typename Char>
class compile_parse_context : public basic_format_parse_context<Char> {
 private:
  int num_args_;
  const type* types_;
  using base = basic_format_parse_context<Char>;

 public:
  explicit constexpr compile_parse_context(
      basic_string_view<Char> format_str, int num_args, const type* types,
      int next_arg_id = 0)
      : base(format_str, next_arg_id), num_args_(num_args), types_(types) {}

  constexpr auto num_args() const -> int { return num_args_; }
  constexpr auto arg_type(int id) const -> type { return types_[id]; }

  constexpr auto next_arg_id() -> int {
    int id = base::next_arg_id();
    if (id >= num_args_) throw_format_error("argument not found");
    return id;
  }

  constexpr void check_arg_id(int id) {
    base::check_arg_id(id);
    if (id >= num_args_) throw_format_error("argument not found");
  }
  using base::check_arg_id;

  constexpr void check_dynamic_spec(int arg_id) {
    detail::ignore_unused(arg_id);

    if (arg_id < num_args_ && types_ && !is_integral_type(types_[arg_id]))
      throw_format_error("width/precision is not integer");

  }
};


template <typename Container>
inline auto get_container(std::back_insert_iterator<Container> it)
    -> Container& {
  using base = std::back_insert_iterator<Container>;
  struct accessor : base {
    accessor(base b) : base(b) {}
    using base::container;
  };
  return *accessor(it).container;
}

template <typename Char, typename InputIt, typename OutputIt>
constexpr auto copy_str(InputIt begin, InputIt end, OutputIt out)
    -> OutputIt {
  while (begin != end) *out++ = static_cast<Char>(*begin++);
  return out;
}

template <typename Char, typename T, typename U,
          fmt::enable_if_t<(std::is_same<remove_const_t<T>, U>::value&& is_char<U>::value), int> = 0>

constexpr auto copy_str(T* begin, T* end, U* out) -> U* {
  if (is_constant_evaluated()) return copy_str<Char, T*, U*>(begin, end, out);
  auto size = to_unsigned(end - begin);
  if (size > 0) memcpy(out, begin, size * sizeof(U));
  return out + size;
}







template <typename T> class buffer {
 private:
  T* ptr_;
  size_t size_;
  size_t capacity_;

 protected:


  constexpr buffer(size_t sz) noexcept : size_(sz), capacity_(sz) {}

  constexpr buffer(T* p = nullptr, size_t sz = 0, size_t cap = 0) noexcept
      : ptr_(p), size_(sz), capacity_(cap) {}

  constexpr ~buffer() = default;
  buffer(buffer&&) = default;


  constexpr void set(T* buf_data, size_t buf_capacity) noexcept {
    ptr_ = buf_data;
    capacity_ = buf_capacity;
  }



  virtual constexpr void grow(size_t capacity) = 0;

 public:
  using value_type = T;
  using const_reference = const T&;

  buffer(const buffer&) = delete;
  void operator=(const buffer&) = delete;

  inline __attribute__((always_inline)) auto begin() noexcept -> T* { return ptr_; }
  inline __attribute__((always_inline)) auto end() noexcept -> T* { return ptr_ + size_; }

  inline __attribute__((always_inline)) auto begin() const noexcept -> const T* { return ptr_; }
  inline __attribute__((always_inline)) auto end() const noexcept -> const T* { return ptr_ + size_; }


  constexpr auto size() const noexcept -> size_t { return size_; }


  constexpr auto capacity() const noexcept -> size_t { return capacity_; }


  constexpr auto data() noexcept -> T* { return ptr_; }
  constexpr auto data() const noexcept -> const T* { return ptr_; }


  void clear() { size_ = 0; }



  constexpr void try_resize(size_t count) {
    try_reserve(count);
    size_ = count <= capacity_ ? count : capacity_;
  }





  constexpr void try_reserve(size_t new_capacity) {
    if (new_capacity > capacity_) grow(new_capacity);
  }

  constexpr void push_back(const T& value) {
    try_reserve(size_ + 1);
    ptr_[size_++] = value;
  }


  template <typename U> void append(const U* begin, const U* end);

  template <typename Idx> constexpr auto operator[](Idx index) -> T& {
    return ptr_[index];
  }
  template <typename Idx>
  constexpr auto operator[](Idx index) const -> const T& {
    return ptr_[index];
  }
};

struct buffer_traits {
  explicit buffer_traits(size_t) {}
  auto count() const -> size_t { return 0; }
  auto limit(size_t size) -> size_t { return size; }
};

class fixed_buffer_traits {
 private:
  size_t count_ = 0;
  size_t limit_;

 public:
  explicit fixed_buffer_traits(size_t limit) : limit_(limit) {}
  auto count() const -> size_t { return count_; }
  auto limit(size_t size) -> size_t {
    size_t n = limit_ > count_ ? limit_ - count_ : 0;
    count_ += size;
    return size < n ? size : n;
  }
};


template <typename OutputIt, typename T, typename Traits = buffer_traits>
class iterator_buffer final : public Traits, public buffer<T> {
 private:
  OutputIt out_;
  enum { buffer_size = 256 };
  T data_[buffer_size];

 protected:
  constexpr void grow(size_t) override {
    if (this->size() == buffer_size) flush();
  }

  void flush() {
    auto size = this->size();
    this->clear();
    out_ = copy_str<T>(data_, data_ + this->limit(size), out_);
  }

 public:
  explicit iterator_buffer(OutputIt out, size_t n = buffer_size)
      : Traits(n), buffer<T>(data_, 0, buffer_size), out_(out) {}
  iterator_buffer(iterator_buffer&& other)
      : Traits(other), buffer<T>(data_, 0, buffer_size), out_(other.out_) {}
  ~iterator_buffer() { flush(); }

  auto out() -> OutputIt {
    flush();
    return out_;
  }
  auto count() const -> size_t { return Traits::count() + this->size(); }
};

template <typename T>
class iterator_buffer<T*, T, fixed_buffer_traits> final
    : public fixed_buffer_traits,
      public buffer<T> {
 private:
  T* out_;
  enum { buffer_size = 256 };
  T data_[buffer_size];

 protected:
  constexpr void grow(size_t) override {
    if (this->size() == this->capacity()) flush();
  }

  void flush() {
    size_t n = this->limit(this->size());
    if (this->data() == out_) {
      out_ += n;
      this->set(data_, buffer_size);
    }
    this->clear();
  }

 public:
  explicit iterator_buffer(T* out, size_t n = buffer_size)
      : fixed_buffer_traits(n), buffer<T>(out, 0, n), out_(out) {}
  iterator_buffer(iterator_buffer&& other)
      : fixed_buffer_traits(other),
        buffer<T>(std::move(other)),
        out_(other.out_) {
    if (this->data() != out_) {
      this->set(data_, buffer_size);
      this->clear();
    }
  }
  ~iterator_buffer() { flush(); }

  auto out() -> T* {
    flush();
    return out_;
  }
  auto count() const -> size_t {
    return fixed_buffer_traits::count() + this->size();
  }
};

template <typename T> class iterator_buffer<T*, T> final : public buffer<T> {
 protected:
  constexpr void grow(size_t) override {}

 public:
  explicit iterator_buffer(T* out, size_t = 0) : buffer<T>(out, 0, ~size_t()) {}

  auto out() -> T* { return &*this->end(); }
};


template <typename Container>
class iterator_buffer<std::back_insert_iterator<Container>,
                      enable_if_t<is_contiguous<Container>::value,
                                  typename Container::value_type>>
    final : public buffer<typename Container::value_type> {
 private:
  Container& container_;

 protected:
  constexpr void grow(size_t capacity) override {
    container_.resize(capacity);
    this->set(&container_[0], capacity);
  }

 public:
  explicit iterator_buffer(Container& c)
      : buffer<typename Container::value_type>(c.size()), container_(c) {}
  explicit iterator_buffer(std::back_insert_iterator<Container> out, size_t = 0)
      : iterator_buffer(get_container(out)) {}

  auto out() -> std::back_insert_iterator<Container> {
    return std::back_inserter(container_);
  }
};


template <typename T = char> class counting_buffer final : public buffer<T> {
 private:
  enum { buffer_size = 256 };
  T data_[buffer_size];
  size_t count_ = 0;

 protected:
  constexpr void grow(size_t) override {
    if (this->size() != buffer_size) return;
    count_ += this->size();
    this->clear();
  }

 public:
  counting_buffer() : buffer<T>(data_, 0, buffer_size) {}

  auto count() -> size_t { return count_ + this->size(); }
};
}

template <typename Char>
constexpr void basic_format_parse_context<Char>::do_check_arg_id(int id) {


  if (detail::is_constant_evaluated() &&
      (!0 || 0 >= 1200)) {
    using context = detail::compile_parse_context<Char>;
    if (id >= static_cast<context*>(this)->num_args())
      detail::throw_format_error("argument not found");
  }
}

template <typename Char>
constexpr void basic_format_parse_context<Char>::check_dynamic_spec(
    int arg_id) {
  if (detail::is_constant_evaluated() &&
      (!0 || 0 >= 1200)) {
    using context = detail::compile_parse_context<Char>;
    static_cast<context*>(this)->check_dynamic_spec(arg_id);
  }
}

           template <typename Context> class basic_format_arg;
           template <typename Context> class basic_format_args;
           template <typename Context> class dynamic_format_arg_store;



template <typename T, typename Char = char, typename Enable = void>
struct formatter {

  formatter() = delete;
};



template <typename T, typename Context>
using has_formatter =
    std::is_constructible<typename Context::template formatter_type<T>>;



class appender : public std::back_insert_iterator<detail::buffer<char>> {
  using base = std::back_insert_iterator<detail::buffer<char>>;

 public:
  using std::back_insert_iterator<detail::buffer<char>>::back_insert_iterator;
  appender(base it) noexcept : base(it) {}
  using unchecked_type = appender;

  auto operator++() noexcept -> appender& { return *this; }
  auto operator++(int) noexcept -> appender { return *this; }
};

namespace detail {

template <typename Context, typename T>
constexpr auto has_const_formatter_impl(T*)
    -> decltype(typename Context::template formatter_type<T>().format(
                    std::declval<const T&>(), std::declval<Context&>()),
                true) {
  return true;
}
template <typename Context>
constexpr auto has_const_formatter_impl(...) -> bool {
  return false;
}
template <typename T, typename Context>
constexpr auto has_const_formatter() -> bool {
  return has_const_formatter_impl<Context>(static_cast<T*>(nullptr));
}

template <typename T>
using buffer_appender = conditional_t<std::is_same<T, char>::value, appender,
                                      std::back_insert_iterator<buffer<T>>>;


template <typename T, typename OutputIt>
auto get_buffer(OutputIt out) -> iterator_buffer<OutputIt, T> {
  return iterator_buffer<OutputIt, T>(out);
}
template <typename T, typename Buf,
          fmt::enable_if_t<(std::is_base_of<buffer<char>, Buf>::value), int> = 0>
auto get_buffer(std::back_insert_iterator<Buf> out) -> buffer<char>& {
  return get_container(out);
}

template <typename Buf, typename OutputIt>
inline __attribute__((always_inline)) auto get_iterator(Buf& buf, OutputIt) -> decltype(buf.out()) {
  return buf.out();
}
template <typename T, typename OutputIt>
auto get_iterator(buffer<T>&, OutputIt out) -> OutputIt {
  return out;
}

struct view {};

template <typename Char, typename T> struct named_arg : view {
  const Char* name;
  const T& value;
  named_arg(const Char* n, const T& v) : name(n), value(v) {}
};

template <typename Char> struct named_arg_info {
  const Char* name;
  int id;
};

template <typename T, typename Char, size_t NUM_ARGS, size_t NUM_NAMED_ARGS>
struct arg_data {


  T args_[1 + (NUM_ARGS != 0 ? NUM_ARGS : +1)];
  named_arg_info<Char> named_args_[NUM_NAMED_ARGS];

  template <typename... U>
  arg_data(const U&... init) : args_{T(named_args_, NUM_NAMED_ARGS), init...} {}
  arg_data(const arg_data& other) = delete;
  auto args() const -> const T* { return args_ + 1; }
  auto named_args() -> named_arg_info<Char>* { return named_args_; }
};

template <typename T, typename Char, size_t NUM_ARGS>
struct arg_data<T, Char, NUM_ARGS, 0> {

  T args_[NUM_ARGS != 0 ? NUM_ARGS : +1];

  template <typename... U>
  constexpr inline __attribute__((always_inline)) arg_data(const U&... init) : args_{init...} {}
  constexpr inline __attribute__((always_inline)) auto args() const -> const T* { return args_; }
  constexpr inline __attribute__((always_inline)) auto named_args() -> std::nullptr_t {
    return nullptr;
  }
};

template <typename Char>
inline void init_named_args(named_arg_info<Char>*, int, int) {}

template <typename T> struct is_named_arg : std::false_type {};
template <typename T> struct is_statically_named_arg : std::false_type {};

template <typename T, typename Char>
struct is_named_arg<named_arg<Char, T>> : std::true_type {};

template <typename Char, typename T, typename... Tail,
          fmt::enable_if_t<(!is_named_arg<T>::value), int> = 0>
void init_named_args(named_arg_info<Char>* named_args, int arg_count,
                     int named_arg_count, const T&, const Tail&... args) {
  init_named_args(named_args, arg_count + 1, named_arg_count, args...);
}

template <typename Char, typename T, typename... Tail,
          fmt::enable_if_t<(is_named_arg<T>::value), int> = 0>
void init_named_args(named_arg_info<Char>* named_args, int arg_count,
                     int named_arg_count, const T& arg, const Tail&... args) {
  named_args[named_arg_count++] = {arg.name, arg_count};
  init_named_args(named_args, arg_count + 1, named_arg_count, args...);
}

template <typename... Args>
constexpr inline __attribute__((always_inline)) void init_named_args(std::nullptr_t, int, int,
                                              const Args&...) {}

template <bool B = false> constexpr auto count() -> size_t { return B ? 1 : 0; }
template <bool B1, bool B2, bool... Tail> constexpr auto count() -> size_t {
  return (B1 ? 1 : 0) + count<B2, Tail...>();
}

template <typename... Args> constexpr auto count_named_args() -> size_t {
  return count<is_named_arg<Args>::value...>();
}

template <typename... Args>
constexpr auto count_statically_named_args() -> size_t {
  return count<is_statically_named_arg<Args>::value...>();
}

struct unformattable {};
struct unformattable_char : unformattable {};
struct unformattable_pointer : unformattable {};

template <typename Char> struct string_value {
  const Char* data;
  size_t size;
};

template <typename Char> struct named_arg_value {
  const named_arg_info<Char>* data;
  size_t size;
};

template <typename Context> struct custom_value {
  using parse_context = typename Context::parse_context_type;
  void* value;
  void (*format)(void* arg, parse_context& parse_ctx, Context& ctx);
};


template <typename Context> class value {
 public:
  using char_type = typename Context::char_type;

  union {
    monostate no_value;
    int int_value;
    unsigned uint_value;
    long long long_long_value;
    unsigned long long ulong_long_value;
    int128_opt int128_value;
    uint128_opt uint128_value;
    bool bool_value;
    char_type char_value;
    float float_value;
    double double_value;
    long double long_double_value;
    const void* pointer;
    string_value<char_type> string;
    custom_value<Context> custom;
    named_arg_value<char_type> named_args;
  };

  constexpr inline __attribute__((always_inline)) value() : no_value() {}
  constexpr inline __attribute__((always_inline)) value(int val) : int_value(val) {}
  constexpr inline __attribute__((always_inline)) value(unsigned val) : uint_value(val) {}
  constexpr inline __attribute__((always_inline)) value(long long val) : long_long_value(val) {}
  constexpr inline __attribute__((always_inline)) value(unsigned long long val) : ulong_long_value(val) {}
  inline __attribute__((always_inline)) value(int128_opt val) : int128_value(val) {}
  inline __attribute__((always_inline)) value(uint128_opt val) : uint128_value(val) {}
  constexpr inline __attribute__((always_inline)) value(float val) : float_value(val) {}
  constexpr inline __attribute__((always_inline)) value(double val) : double_value(val) {}
  inline __attribute__((always_inline)) value(long double val) : long_double_value(val) {}
  constexpr inline __attribute__((always_inline)) value(bool val) : bool_value(val) {}
  constexpr inline __attribute__((always_inline)) value(char_type val) : char_value(val) {}
  constexpr inline __attribute__((always_inline)) value(const char_type* val) {
    string.data = val;
    if (is_constant_evaluated()) string.size = {};
  }
  constexpr inline __attribute__((always_inline)) value(basic_string_view<char_type> val) {
    string.data = val.data();
    string.size = val.size();
  }
  inline __attribute__((always_inline)) value(const void* val) : pointer(val) {}
  inline __attribute__((always_inline)) value(const named_arg_info<char_type>* args, size_t size)
      : named_args{args, size} {}

  template <typename T> constexpr inline __attribute__((always_inline)) value(T& val) {
    using value_type = remove_const_t<T>;
    custom.value = const_cast<value_type*>(std::addressof(val));



    custom.format = format_custom_arg<
        value_type, typename Context::template formatter_type<value_type>>;
  }
  value(unformattable);
  value(unformattable_char);
  value(unformattable_pointer);

 private:

  template <typename T, typename Formatter>
  static void format_custom_arg(void* arg,
                                typename Context::parse_context_type& parse_ctx,
                                Context& ctx) {
    auto f = Formatter();
    parse_ctx.advance_to(f.parse(parse_ctx));
    using qualified_type =
        conditional_t<has_const_formatter<T, Context>(), const T, T>;

    ctx.advance_to(f.format(*static_cast<qualified_type*>(arg), ctx));
  }
};



enum { long_short = sizeof(long) == sizeof(int) };
using long_type = conditional_t<long_short, int, long long>;
using ulong_type = conditional_t<long_short, unsigned, unsigned long long>;

template <typename T> struct format_as_result {
  template <typename U,
            fmt::enable_if_t<(std::is_enum<U>::value || std::is_class<U>::value), int> = 0>
  static auto map(U*) -> remove_cvref_t<decltype(format_as(std::declval<U>()))>;
  static auto map(...) -> void;

  using type = decltype(map(static_cast<T*>(nullptr)));
};
template <typename T> using format_as_t = typename format_as_result<T>::type;

template <typename T>
struct has_format_as
    : bool_constant<!std::is_same<format_as_t<T>, void>::value> {};




template <typename Context> struct arg_mapper {
  using char_type = typename Context::char_type;

  constexpr inline __attribute__((always_inline)) auto map(signed char val) -> int { return val; }
  constexpr inline __attribute__((always_inline)) auto map(unsigned char val) -> unsigned {
    return val;
  }
  constexpr inline __attribute__((always_inline)) auto map(short val) -> int { return val; }
  constexpr inline __attribute__((always_inline)) auto map(unsigned short val) -> unsigned {
    return val;
  }
  constexpr inline __attribute__((always_inline)) auto map(int val) -> int { return val; }
  constexpr inline __attribute__((always_inline)) auto map(unsigned val) -> unsigned { return val; }
  constexpr inline __attribute__((always_inline)) auto map(long val) -> long_type { return val; }
  constexpr inline __attribute__((always_inline)) auto map(unsigned long val) -> ulong_type {
    return val;
  }
  constexpr inline __attribute__((always_inline)) auto map(long long val) -> long long { return val; }
  constexpr inline __attribute__((always_inline)) auto map(unsigned long long val)
      -> unsigned long long {
    return val;
  }
  constexpr inline __attribute__((always_inline)) auto map(int128_opt val) -> int128_opt {
    return val;
  }
  constexpr inline __attribute__((always_inline)) auto map(uint128_opt val) -> uint128_opt {
    return val;
  }
  constexpr inline __attribute__((always_inline)) auto map(bool val) -> bool { return val; }

  template <typename T, fmt::enable_if_t<(std::is_same<T, char>::value || std::is_same<T, char_type>::value), int> = 0>

  constexpr inline __attribute__((always_inline)) auto map(T val) -> char_type {
    return val;
  }
  template <typename T, enable_if_t<(std::is_same<T, wchar_t>::value ||

                                     std::is_same<T, char8_t>::value ||

                                     std::is_same<T, char16_t>::value ||
                                     std::is_same<T, char32_t>::value) &&
                                        !std::is_same<T, char_type>::value,
                                    int> = 0>
  constexpr inline __attribute__((always_inline)) auto map(T) -> unformattable_char {
    return {};
  }

  constexpr inline __attribute__((always_inline)) auto map(float val) -> float { return val; }
  constexpr inline __attribute__((always_inline)) auto map(double val) -> double { return val; }
  constexpr inline __attribute__((always_inline)) auto map(long double val) -> long double {
    return val;
  }

  constexpr inline __attribute__((always_inline)) auto map(char_type* val) -> const char_type* {
    return val;
  }
  constexpr inline __attribute__((always_inline)) auto map(const char_type* val) -> const char_type* {
    return val;
  }
  template <typename T,
            fmt::enable_if_t<(is_string<T>::value && !std::is_pointer<T>::value && std::is_same<char_type, char_t<T>>::value), int> = 0>

  constexpr inline __attribute__((always_inline)) auto map(const T& val)
      -> basic_string_view<char_type> {
    return to_string_view(val);
  }
  template <typename T,
            fmt::enable_if_t<(is_string<T>::value && !std::is_pointer<T>::value && !std::is_same<char_type, char_t<T>>::value), int> = 0>

  constexpr inline __attribute__((always_inline)) auto map(const T&) -> unformattable_char {
    return {};
  }

  constexpr inline __attribute__((always_inline)) auto map(void* val) -> const void* { return val; }
  constexpr inline __attribute__((always_inline)) auto map(const void* val) -> const void* {
    return val;
  }
  constexpr inline __attribute__((always_inline)) auto map(std::nullptr_t val) -> const void* {
    return val;
  }



  template <
      typename T,
      fmt::enable_if_t<(std::is_pointer<T>::value || std::is_member_pointer<T>::value || std::is_function<typename std::remove_pointer<T>::type>::value || (std::is_array<T>::value && !std::is_convertible<T, const char_type*>::value)), int> = 0>




  constexpr auto map(const T&) -> unformattable_pointer {
    return {};
  }

  template <typename T, std::size_t N,
            fmt::enable_if_t<(!std::is_same<T, wchar_t>::value), int> = 0>
  constexpr inline __attribute__((always_inline)) auto map(const T (&values)[N]) -> const T (&)[N] {
    return values;
  }


  template <typename T, typename U = format_as_t<T>,
            fmt::enable_if_t<(std::is_arithmetic<U>::value), int> = 0>
  constexpr inline __attribute__((always_inline)) auto map(const T& val)
      -> decltype( map(U())) {
    return map(format_as(val));
  }

  template <typename T, typename U = remove_const_t<T>>
  struct formattable : bool_constant<has_const_formatter<U, Context>() ||
                                     (has_formatter<U, Context>::value &&
                                      !std::is_const<T>::value)> {};

  template <typename T, fmt::enable_if_t<(formattable<T>::value), int> = 0>
  constexpr inline __attribute__((always_inline)) auto do_map(T& val) -> T& {
    return val;
  }
  template <typename T, fmt::enable_if_t<(!formattable<T>::value), int> = 0>
  constexpr inline __attribute__((always_inline)) auto do_map(T&) -> unformattable {
    return {};
  }

  template <typename T, typename U = remove_const_t<T>,
            fmt::enable_if_t<((std::is_class<U>::value || std::is_enum<U>::value || std::is_union<U>::value) && !is_string<U>::value && !is_char<U>::value && !is_named_arg<U>::value && !std::is_arithmetic<format_as_t<U>>::value), int> = 0>




  constexpr inline __attribute__((always_inline)) auto map(T& val)
      -> decltype( do_map(val)) {
    return do_map(val);
  }

  template <typename T, fmt::enable_if_t<(is_named_arg<T>::value), int> = 0>
  constexpr inline __attribute__((always_inline)) auto map(const T& named_arg)
      -> decltype( map(named_arg.value)) {
    return map(named_arg.value);
  }

  auto map(...) -> unformattable { return {}; }
};


template <typename T, typename Context>
using mapped_type_constant =
    type_constant<decltype(arg_mapper<Context>().map(std::declval<const T&>())),
                  typename Context::char_type>;

enum { packed_arg_bits = 4 };

enum { max_packed_args = 62 / packed_arg_bits };
enum : unsigned long long { is_unpacked_bit = 1ULL << 63 };
enum : unsigned long long { has_named_args_bit = 1ULL << 62 };

template <typename Char, typename InputIt>
auto copy_str(InputIt begin, InputIt end, appender out) -> appender {
  get_container(out).append(begin, end);
  return out;
}
template <typename Char, typename InputIt>
auto copy_str(InputIt begin, InputIt end,
              std::back_insert_iterator<std::string> out)
    -> std::back_insert_iterator<std::string> {
  get_container(out).append(begin, end);
  return out;
}

template <typename Char, typename R, typename OutputIt>
constexpr auto copy_str(R&& rng, OutputIt out) -> OutputIt {
  return detail::copy_str<Char>(rng.begin(), rng.end(), out);
}
# 1534 "/usr/include/fmt/core.h" 3 4
template <typename...> using void_t = void;


template <typename It, typename T, typename Enable = void>
struct is_output_iterator : std::false_type {};

template <typename It, typename T>
struct is_output_iterator<
    It, T,
    void_t<typename std::iterator_traits<It>::iterator_category,
           decltype(*std::declval<It>() = std::declval<T>())>>
    : std::true_type {};

template <typename It> struct is_back_insert_iterator : std::false_type {};
template <typename Container>
struct is_back_insert_iterator<std::back_insert_iterator<Container>>
    : std::true_type {};


class locale_ref {
 private:
  const void* locale_;

 public:
  constexpr inline __attribute__((always_inline)) locale_ref() : locale_(nullptr) {}
  template <typename Locale> explicit locale_ref(const Locale& loc);

  explicit operator bool() const noexcept { return locale_ != nullptr; }

  template <typename Locale> auto get() const -> Locale;
};

template <typename> constexpr auto encode_types() -> unsigned long long {
  return 0;
}

template <typename Context, typename Arg, typename... Args>
constexpr auto encode_types() -> unsigned long long {
  return static_cast<unsigned>(mapped_type_constant<Arg, Context>::value) |
         (encode_types<Context, Args...>() << packed_arg_bits);
}



template <typename T, typename Char> struct type_is_unformattable_for;


template <bool PACKED, typename Context, typename T, fmt::enable_if_t<(PACKED), int> = 0>
constexpr inline __attribute__((always_inline)) auto make_arg(T& val) -> value<Context> {
  using arg_type = remove_cvref_t<decltype(arg_mapper<Context>().map(val))>;

  constexpr bool formattable_char =
      !std::is_same<arg_type, unformattable_char>::value;
  static_assert(formattable_char, "Mixing character types is disallowed.");




  constexpr bool formattable_pointer =
      !std::is_same<arg_type, unformattable_pointer>::value;
  static_assert(formattable_pointer,
                "Formatting of non-void pointers is disallowed.");

  constexpr bool formattable = !std::is_same<arg_type, unformattable>::value;

  if constexpr (!formattable) {
    type_is_unformattable_for<T, typename Context::char_type> _;
  }

  static_assert(
      formattable,
      "Cannot format an argument. To make type T formattable provide a "
      "formatter<T> specialization: https://fmt.dev/latest/api.html#udt");
  return {arg_mapper<Context>().map(val)};
}

template <typename Context, typename T>
constexpr auto make_arg(T& val) -> basic_format_arg<Context> {
  auto arg = basic_format_arg<Context>();
  arg.type_ = mapped_type_constant<T, Context>::value;
  arg.value_ = make_arg<true, Context>(val);
  return arg;
}

template <bool PACKED, typename Context, typename T, fmt::enable_if_t<(!PACKED), int> = 0>
constexpr inline auto make_arg(T& val) -> basic_format_arg<Context> {
  return make_arg<Context>(val);
}
}




template <typename Context> class basic_format_arg {
 private:
  detail::value<Context> value_;
  detail::type type_;

  template <typename ContextType, typename T>
  friend constexpr auto detail::make_arg(T& value)
      -> basic_format_arg<ContextType>;

  template <typename Visitor, typename Ctx>
  friend constexpr auto visit_format_arg(Visitor&& vis,
                                             const basic_format_arg<Ctx>& arg)
      -> decltype(vis(0));

  friend class basic_format_args<Context>;
  friend class dynamic_format_arg_store<Context>;

  using char_type = typename Context::char_type;

  template <typename T, typename Char, size_t NUM_ARGS, size_t NUM_NAMED_ARGS>
  friend struct detail::arg_data;

  basic_format_arg(const detail::named_arg_info<char_type>* args, size_t size)
      : value_(args, size) {}

 public:
  class handle {
   public:
    explicit handle(detail::custom_value<Context> custom) : custom_(custom) {}

    void format(typename Context::parse_context_type& parse_ctx,
                Context& ctx) const {
      custom_.format(custom_.value, parse_ctx, ctx);
    }

   private:
    detail::custom_value<Context> custom_;
  };

  constexpr basic_format_arg() : type_(detail::type::none_type) {}

  constexpr explicit operator bool() const noexcept {
    return type_ != detail::type::none_type;
  }

  auto type() const -> detail::type { return type_; }

  auto is_integral() const -> bool { return detail::is_integral_type(type_); }
  auto is_arithmetic() const -> bool {
    return detail::is_arithmetic_type(type_);
  }

  inline __attribute__((always_inline)) auto format_custom(const char_type* parse_begin,
                                typename Context::parse_context_type& parse_ctx,
                                Context& ctx) -> bool {
    if (type_ != detail::type::custom_type) return false;
    parse_ctx.advance_to(parse_begin);
    value_.custom.format(value_.custom.value, parse_ctx, ctx);
    return true;
  }
};
# 1697 "/usr/include/fmt/core.h" 3 4
template <typename Visitor, typename Context>
constexpr inline __attribute__((always_inline)) auto visit_format_arg(
    Visitor&& vis, const basic_format_arg<Context>& arg) -> decltype(vis(0)) {
  switch (arg.type_) {
  case detail::type::none_type:
    break;
  case detail::type::int_type:
    return vis(arg.value_.int_value);
  case detail::type::uint_type:
    return vis(arg.value_.uint_value);
  case detail::type::long_long_type:
    return vis(arg.value_.long_long_value);
  case detail::type::ulong_long_type:
    return vis(arg.value_.ulong_long_value);
  case detail::type::int128_type:
    return vis(detail::convert_for_visit(arg.value_.int128_value));
  case detail::type::uint128_type:
    return vis(detail::convert_for_visit(arg.value_.uint128_value));
  case detail::type::bool_type:
    return vis(arg.value_.bool_value);
  case detail::type::char_type:
    return vis(arg.value_.char_value);
  case detail::type::float_type:
    return vis(arg.value_.float_value);
  case detail::type::double_type:
    return vis(arg.value_.double_value);
  case detail::type::long_double_type:
    return vis(arg.value_.long_double_value);
  case detail::type::cstring_type:
    return vis(arg.value_.string.data);
  case detail::type::string_type:
    using sv = basic_string_view<typename Context::char_type>;
    return vis(sv(arg.value_.string.data, arg.value_.string.size));
  case detail::type::pointer_type:
    return vis(arg.value_.pointer);
  case detail::type::custom_type:
    return vis(typename basic_format_arg<Context>::handle(arg.value_.custom));
  }
  return vis(monostate());
}


template <typename OutputIt, typename Char> class basic_format_context {
 private:
  OutputIt out_;
  basic_format_args<basic_format_context> args_;
  detail::locale_ref loc_;

 public:
  using iterator = OutputIt;
  using format_arg = basic_format_arg<basic_format_context>;
  using format_args = basic_format_args<basic_format_context>;
  using parse_context_type = basic_format_parse_context<Char>;
  template <typename T> using formatter_type = formatter<T, Char>;


  using char_type = Char;

  basic_format_context(basic_format_context&&) = default;
  basic_format_context(const basic_format_context&) = delete;
  void operator=(const basic_format_context&) = delete;




  constexpr basic_format_context(OutputIt out, format_args ctx_args,
                                 detail::locale_ref loc = {})
      : out_(out), args_(ctx_args), loc_(loc) {}

  constexpr auto arg(int id) const -> format_arg { return args_.get(id); }
  constexpr auto arg(basic_string_view<Char> name) -> format_arg {
    return args_.get(name);
  }
  constexpr auto arg_id(basic_string_view<Char> name) -> int {
    return args_.get_id(name);
  }
  auto args() const -> const format_args& { return args_; }


  constexpr auto error_handler() -> detail::error_handler { return {}; }
  void on_error(const char* message) { error_handler().on_error(message); }


  constexpr auto out() -> iterator { return out_; }


  void advance_to(iterator it) {
    if (!detail::is_back_insert_iterator<iterator>()) out_ = it;
  }

  constexpr auto locale() -> detail::locale_ref { return loc_; }
};

template <typename Char>
using buffer_context =
    basic_format_context<detail::buffer_appender<Char>, Char>;
using format_context = buffer_context<char>;

template <typename T, typename Char = char>
using is_formattable = bool_constant<!std::is_base_of<
    detail::unformattable, decltype(detail::arg_mapper<buffer_context<Char>>()
                                        .map(std::declval<T&>()))>::value>;
# 1807 "/usr/include/fmt/core.h" 3 4
template <typename Context, typename... Args>
class format_arg_store




{
 private:
  static const size_t num_args = sizeof...(Args);
  static constexpr size_t num_named_args = detail::count_named_args<Args...>();
  static const bool is_packed = num_args <= detail::max_packed_args;

  using value_type = conditional_t<is_packed, detail::value<Context>,
                                   basic_format_arg<Context>>;

  detail::arg_data<value_type, typename Context::char_type, num_args,
                   num_named_args>
      data_;

  friend class basic_format_args<Context>;

  static constexpr unsigned long long desc =
      (is_packed ? detail::encode_types<Context, Args...>()
                 : detail::is_unpacked_bit | num_args) |
      (num_named_args != 0
           ? static_cast<unsigned long long>(detail::has_named_args_bit)
           : 0);

 public:
  template <typename... T>
  constexpr inline __attribute__((always_inline)) format_arg_store(T&... args)
      :



        data_{detail::make_arg<is_packed, Context>(args)...} {
    if (detail::const_check(num_named_args != 0))
      detail::init_named_args(data_.named_args(), 0, 0, args...);
  }
};
# 1857 "/usr/include/fmt/core.h" 3 4
template <typename Context = format_context, typename... T>
constexpr auto make_format_args(T&... args)
    -> format_arg_store<Context, remove_cvref_t<T>...> {
  return {args...};
}
# 1874 "/usr/include/fmt/core.h" 3 4
template <typename Char, typename T>
inline auto arg(const Char* name, const T& arg) -> detail::named_arg<Char, T> {
  static_assert(!detail::is_named_arg<T>(), "nested named arguments");
  return {name, arg};
}
# 1891 "/usr/include/fmt/core.h" 3 4
template <typename Context> class basic_format_args {
 public:
  using size_type = int;
  using format_arg = basic_format_arg<Context>;

 private:




  unsigned long long desc_;
  union {





    const detail::value<Context>* values_;
    const format_arg* args_;
  };

  constexpr auto is_packed() const -> bool {
    return (desc_ & detail::is_unpacked_bit) == 0;
  }
  auto has_named_args() const -> bool {
    return (desc_ & detail::has_named_args_bit) != 0;
  }

  constexpr auto type(int index) const -> detail::type {
    int shift = index * detail::packed_arg_bits;
    unsigned int mask = (1 << detail::packed_arg_bits) - 1;
    return static_cast<detail::type>((desc_ >> shift) & mask);
  }

  constexpr inline __attribute__((always_inline)) basic_format_args(unsigned long long desc,
                                         const detail::value<Context>* values)
      : desc_(desc), values_(values) {}
  constexpr basic_format_args(unsigned long long desc, const format_arg* args)
      : desc_(desc), args_(args) {}

 public:
  constexpr basic_format_args() : desc_(0), args_(nullptr) {}






  template <typename... Args>
  constexpr inline __attribute__((always_inline)) basic_format_args(
      const format_arg_store<Context, Args...>& store)
      : basic_format_args(format_arg_store<Context, Args...>::desc,
                          store.data_.args()) {}







  constexpr inline __attribute__((always_inline)) basic_format_args(
      const dynamic_format_arg_store<Context>& store)
      : basic_format_args(store.get_types(), store.data()) {}






  constexpr basic_format_args(const format_arg* args, int count)
      : basic_format_args(detail::is_unpacked_bit | detail::to_unsigned(count),
                          args) {}


  constexpr auto get(int id) const -> format_arg {
    format_arg arg;
    if (!is_packed()) {
      if (id < max_size()) arg = args_[id];
      return arg;
    }
    if (id >= detail::max_packed_args) return arg;
    arg.type_ = type(id);
    if (arg.type_ == detail::type::none_type) return arg;
    arg.value_ = values_[id];
    return arg;
  }

  template <typename Char>
  auto get(basic_string_view<Char> name) const -> format_arg {
    int id = get_id(name);
    return id >= 0 ? get(id) : format_arg();
  }

  template <typename Char>
  auto get_id(basic_string_view<Char> name) const -> int {
    if (!has_named_args()) return -1;
    const auto& named_args =
        (is_packed() ? values_[-1] : args_[-1].value_).named_args;
    for (size_t i = 0; i < named_args.size; ++i) {
      if (named_args.data[i].name == name) return named_args.data[i].id;
    }
    return -1;
  }

  auto max_size() const -> int {
    unsigned long long max_packed = detail::max_packed_args;
    return static_cast<int>(is_packed() ? max_packed
                                        : desc_ & ~detail::is_unpacked_bit);
  }
};




           using format_args = basic_format_args<format_context>;
# 2016 "/usr/include/fmt/core.h" 3 4
namespace align {
enum type : unsigned char{none, left, right, center,
                                                  numeric};
}
using align_t = align::type;
namespace sign {
enum type : unsigned char{none, minus, plus, space};
}
using sign_t = sign::type;

namespace detail {


template <typename Char> struct fill_t {
 private:
  enum { max_size = 4 };
  Char data_[max_size] = {Char(' '), Char(0), Char(0), Char(0)};
  unsigned char size_ = 1;

 public:
  constexpr void operator=(basic_string_view<Char> s) {
    auto size = s.size();
    ((size <= max_size) ? (void)0 : fmt::detail::assert_fail("/usr/include/fmt/core.h", 2038, ("invalid fill")));
    for (size_t i = 0; i < size; ++i) data_[i] = s[i];
    size_ = static_cast<unsigned char>(size);
  }

  constexpr auto size() const -> size_t { return size_; }
  constexpr auto data() const -> const Char* { return data_; }

  constexpr auto operator[](size_t index) -> Char& { return data_[index]; }
  constexpr auto operator[](size_t index) const -> const Char& {
    return data_[index];
  }
};
}

enum class presentation_type : unsigned char {
  none,
  dec,
  oct,
  hex_lower,
  hex_upper,
  bin_lower,
  bin_upper,
  hexfloat_lower,
  hexfloat_upper,
  exp_lower,
  exp_upper,
  fixed_lower,
  fixed_upper,
  general_lower,
  general_upper,
  chr,
  string,
  pointer,
  debug
};


template <typename Char = char> struct format_specs {
  int width;
  int precision;
  presentation_type type;
  align_t align : 4;
  sign_t sign : 3;
  bool alt : 1;
  bool localized : 1;
  detail::fill_t<Char> fill;

  constexpr format_specs()
      : width(0),
        precision(-1),
        type(presentation_type::none),
        align(align::none),
        sign(sign::none),
        alt(false),
        localized(false) {}
};

namespace detail {

enum class arg_id_kind { none, index, name };


template <typename Char> struct arg_ref {
  constexpr arg_ref() : kind(arg_id_kind::none), val() {}

  constexpr explicit arg_ref(int index)
      : kind(arg_id_kind::index), val(index) {}
  constexpr explicit arg_ref(basic_string_view<Char> name)
      : kind(arg_id_kind::name), val(name) {}

  constexpr auto operator=(int idx) -> arg_ref& {
    kind = arg_id_kind::index;
    val.index = idx;
    return *this;
  }

  arg_id_kind kind;
  union value {
    constexpr value(int idx = 0) : index(idx) {}
    constexpr value(basic_string_view<Char> n) : name(n) {}

    int index;
    basic_string_view<Char> name;
  } val;
};




template <typename Char = char>
struct dynamic_format_specs : format_specs<Char> {
  arg_ref<Char> width_ref;
  arg_ref<Char> precision_ref;
};


template <typename Char, fmt::enable_if_t<(std::is_integral<Char>::value), int> = 0>
constexpr auto to_ascii(Char c) -> char {
  return c <= 0xff ? static_cast<char>(c) : '\0';
}
template <typename Char, fmt::enable_if_t<(std::is_enum<Char>::value), int> = 0>
constexpr auto to_ascii(Char c) -> char {
  return c <= 0xff ? static_cast<char>(c) : '\0';
}


template <typename Char>
constexpr auto code_point_length(const Char* begin) -> int {
  if (const_check(sizeof(Char) != 1)) return 1;
  auto c = static_cast<unsigned char>(*begin);
  return static_cast<int>((0x3a55000000000000ull >> (2 * (c >> 3))) & 0x3) + 1;
}


template <bool IS_CONSTEXPR, typename T, typename Ptr = const T*>
constexpr auto find(Ptr first, Ptr last, T value, Ptr& out) -> bool {
  for (out = first; out != last; ++out) {
    if (*out == value) return true;
  }
  return false;
}

template <>
inline auto find<false, char>(const char* first, const char* last, char value,
                              const char*& out) -> bool {
  out = static_cast<const char*>(
      std::memchr(first, value, to_unsigned(last - first)));
  return out != nullptr;
}



template <typename Char>
constexpr auto parse_nonnegative_int(const Char*& begin, const Char* end,
                                         int error_value) noexcept -> int {
  ((begin != end && '0' <= *begin && *begin <= '9') ? (void)0 : fmt::detail::assert_fail("/usr/include/fmt/core.h", 2174, ("")));
  unsigned value = 0, prev = 0;
  auto p = begin;
  do {
    prev = value;
    value = value * 10 + unsigned(*p - '0');
    ++p;
  } while (p != end && '0' <= *p && *p <= '9');
  auto num_digits = p - begin;
  begin = p;
  if (num_digits <= std::numeric_limits<int>::digits10)
    return static_cast<int>(value);

  const unsigned max = to_unsigned((std::numeric_limits<int>::max)());
  return num_digits == std::numeric_limits<int>::digits10 + 1 &&
                 prev * 10ull + unsigned(p[-1] - '0') <= max
             ? static_cast<int>(value)
             : error_value;
}

constexpr inline auto parse_align(char c) -> align_t {
  switch (c) {
  case '<':
    return align::left;
  case '>':
    return align::right;
  case '^':
    return align::center;
  }
  return align::none;
}

template <typename Char> constexpr auto is_name_start(Char c) -> bool {
  return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || c == '_';
}

template <typename Char, typename Handler>
constexpr auto do_parse_arg_id(const Char* begin, const Char* end,
                                   Handler&& handler) -> const Char* {
  Char c = *begin;
  if (c >= '0' && c <= '9') {
    int index = 0;
    constexpr int max = (std::numeric_limits<int>::max)();
    if (c != '0')
      index = parse_nonnegative_int(begin, end, max);
    else
      ++begin;
    if (begin == end || (*begin != '}' && *begin != ':'))
      throw_format_error("invalid format string");
    else
      handler.on_index(index);
    return begin;
  }
  if (!is_name_start(c)) {
    throw_format_error("invalid format string");
    return begin;
  }
  auto it = begin;
  do {
    ++it;
  } while (it != end && (is_name_start(*it) || ('0' <= *it && *it <= '9')));
  handler.on_name({begin, to_unsigned(it - begin)});
  return it;
}

template <typename Char, typename Handler>
constexpr inline __attribute__((always_inline)) auto parse_arg_id(const Char* begin, const Char* end,
                                           Handler&& handler) -> const Char* {
  ((begin != end) ? (void)0 : fmt::detail::assert_fail("/usr/include/fmt/core.h", 2242, ("")));
  Char c = *begin;
  if (c != '}' && c != ':') return do_parse_arg_id(begin, end, handler);
  handler.on_auto();
  return begin;
}

template <typename Char> struct dynamic_spec_id_handler {
  basic_format_parse_context<Char>& ctx;
  arg_ref<Char>& ref;

  constexpr void on_auto() {
    int id = ctx.next_arg_id();
    ref = arg_ref<Char>(id);
    ctx.check_dynamic_spec(id);
  }
  constexpr void on_index(int id) {
    ref = arg_ref<Char>(id);
    ctx.check_arg_id(id);
    ctx.check_dynamic_spec(id);
  }
  constexpr void on_name(basic_string_view<Char> id) {
    ref = arg_ref<Char>(id);
    ctx.check_arg_id(id);
  }
};


template <typename Char>
constexpr auto parse_dynamic_spec(const Char* begin, const Char* end,
                                      int& value, arg_ref<Char>& ref,
                                      basic_format_parse_context<Char>& ctx)
    -> const Char* {
  ((begin != end) ? (void)0 : fmt::detail::assert_fail("/usr/include/fmt/core.h", 2275, ("")));
  if ('0' <= *begin && *begin <= '9') {
    int val = parse_nonnegative_int(begin, end, -1);
    if (val != -1)
      value = val;
    else
      throw_format_error("number is too big");
  } else if (*begin == '{') {
    ++begin;
    auto handler = dynamic_spec_id_handler<Char>{ctx, ref};
    if (begin != end) begin = parse_arg_id(begin, end, handler);
    if (begin != end && *begin == '}') return ++begin;
    throw_format_error("invalid format string");
  }
  return begin;
}

template <typename Char>
constexpr auto parse_precision(const Char* begin, const Char* end,
                                   int& value, arg_ref<Char>& ref,
                                   basic_format_parse_context<Char>& ctx)
    -> const Char* {
  ++begin;
  if (begin == end || *begin == '}') {
    throw_format_error("invalid precision");
    return begin;
  }
  return parse_dynamic_spec(begin, end, value, ref, ctx);
}

enum class state { start, align, sign, hash, zero, width, precision, locale };


template <typename Char>
constexpr inline __attribute__((always_inline)) auto parse_format_specs(
    const Char* begin, const Char* end, dynamic_format_specs<Char>& specs,
    basic_format_parse_context<Char>& ctx, type arg_type) -> const Char* {
  auto c = '\0';
  if (end - begin > 1) {
    auto next = to_ascii(begin[1]);
    c = parse_align(next) == align::none ? to_ascii(*begin) : '\0';
  } else {
    if (begin == end) return begin;
    c = to_ascii(*begin);
  }

  struct {
    state current_state = state::start;
    constexpr void operator()(state s, bool valid = true) {
      if (current_state >= s || !valid)
        throw_format_error("invalid format specifier");
      current_state = s;
    }
  } enter_state;

  using pres = presentation_type;
  constexpr auto integral_set = sint_set | uint_set | bool_set | char_set;
  struct {
    const Char*& begin;
    dynamic_format_specs<Char>& specs;
    type arg_type;

    constexpr auto operator()(pres pres_type, int set) -> const Char* {
      if (!in(arg_type, set)) {
        if (arg_type == type::none_type) return begin;
        throw_format_error("invalid format specifier");
      }
      specs.type = pres_type;
      return begin + 1;
    }
  } parse_presentation_type{begin, specs, arg_type};

  for (;;) {
    switch (c) {
    case '<':
    case '>':
    case '^':
      enter_state(state::align);
      specs.align = parse_align(c);
      ++begin;
      break;
    case '+':
    case '-':
    case ' ':
      if (arg_type == type::none_type) return begin;
      enter_state(state::sign, in(arg_type, sint_set | float_set));
      switch (c) {
      case '+':
        specs.sign = sign::plus;
        break;
      case '-':
        specs.sign = sign::minus;
        break;
      case ' ':
        specs.sign = sign::space;
        break;
      }
      ++begin;
      break;
    case '#':
      if (arg_type == type::none_type) return begin;
      enter_state(state::hash, is_arithmetic_type(arg_type));
      specs.alt = true;
      ++begin;
      break;
    case '0':
      enter_state(state::zero);
      if (!is_arithmetic_type(arg_type)) {
        if (arg_type == type::none_type) return begin;
        throw_format_error("format specifier requires numeric argument");
      }
      if (specs.align == align::none) {

        specs.align = align::numeric;
        specs.fill[0] = Char('0');
      }
      ++begin;
      break;
    case '1':
    case '2':
    case '3':
    case '4':
    case '5':
    case '6':
    case '7':
    case '8':
    case '9':
    case '{':
      enter_state(state::width);
      begin = parse_dynamic_spec(begin, end, specs.width, specs.width_ref, ctx);
      break;
    case '.':
      if (arg_type == type::none_type) return begin;
      enter_state(state::precision,
                  in(arg_type, float_set | string_set | cstring_set));
      begin = parse_precision(begin, end, specs.precision, specs.precision_ref,
                              ctx);
      break;
    case 'L':
      if (arg_type == type::none_type) return begin;
      enter_state(state::locale, is_arithmetic_type(arg_type));
      specs.localized = true;
      ++begin;
      break;
    case 'd':
      return parse_presentation_type(pres::dec, integral_set);
    case 'o':
      return parse_presentation_type(pres::oct, integral_set);
    case 'x':
      return parse_presentation_type(pres::hex_lower, integral_set);
    case 'X':
      return parse_presentation_type(pres::hex_upper, integral_set);
    case 'b':
      return parse_presentation_type(pres::bin_lower, integral_set);
    case 'B':
      return parse_presentation_type(pres::bin_upper, integral_set);
    case 'a':
      return parse_presentation_type(pres::hexfloat_lower, float_set);
    case 'A':
      return parse_presentation_type(pres::hexfloat_upper, float_set);
    case 'e':
      return parse_presentation_type(pres::exp_lower, float_set);
    case 'E':
      return parse_presentation_type(pres::exp_upper, float_set);
    case 'f':
      return parse_presentation_type(pres::fixed_lower, float_set);
    case 'F':
      return parse_presentation_type(pres::fixed_upper, float_set);
    case 'g':
      return parse_presentation_type(pres::general_lower, float_set);
    case 'G':
      return parse_presentation_type(pres::general_upper, float_set);
    case 'c':
      if (arg_type == type::bool_type)
        throw_format_error("invalid format specifier");
      return parse_presentation_type(pres::chr, integral_set);
    case 's':
      return parse_presentation_type(pres::string,
                                     bool_set | string_set | cstring_set);
    case 'p':
      return parse_presentation_type(pres::pointer, pointer_set | cstring_set);
    case '?':
      return parse_presentation_type(pres::debug,
                                     char_set | string_set | cstring_set);
    case '}':
      return begin;
    default: {
      if (*begin == '}') return begin;

      auto fill_end = begin + code_point_length(begin);
      if (end - fill_end <= 0) {
        throw_format_error("invalid format specifier");
        return begin;
      }
      if (*begin == '{') {
        throw_format_error("invalid fill character '{'");
        return begin;
      }
      auto align = parse_align(to_ascii(*fill_end));
      enter_state(state::align, align != align::none);
      specs.fill = {begin, to_unsigned(fill_end - begin)};
      specs.align = align;
      begin = fill_end + 1;
    }
    }
    if (begin == end) return begin;
    c = to_ascii(*begin);
  }
}

template <typename Char, typename Handler>
constexpr auto parse_replacement_field(const Char* begin, const Char* end,
                                           Handler&& handler) -> const Char* {
  struct id_adapter {
    Handler& handler;
    int arg_id;

    constexpr void on_auto() { arg_id = handler.on_arg_id(); }
    constexpr void on_index(int id) { arg_id = handler.on_arg_id(id); }
    constexpr void on_name(basic_string_view<Char> id) {
      arg_id = handler.on_arg_id(id);
    }
  };

  ++begin;
  if (begin == end) return handler.on_error("invalid format string"), end;
  if (*begin == '}') {
    handler.on_replacement_field(handler.on_arg_id(), begin);
  } else if (*begin == '{') {
    handler.on_text(begin, begin + 1);
  } else {
    auto adapter = id_adapter{handler, 0};
    begin = parse_arg_id(begin, end, adapter);
    Char c = begin != end ? *begin : Char();
    if (c == '}') {
      handler.on_replacement_field(adapter.arg_id, begin);
    } else if (c == ':') {
      begin = handler.on_format_specs(adapter.arg_id, begin + 1, end);
      if (begin == end || *begin != '}')
        return handler.on_error("unknown format specifier"), end;
    } else {
      return handler.on_error("missing '}' in format string"), end;
    }
  }
  return begin + 1;
}

template <bool IS_CONSTEXPR, typename Char, typename Handler>
constexpr inline __attribute__((always_inline)) void parse_format_string(
    basic_string_view<Char> format_str, Handler&& handler) {
  auto begin = format_str.data();
  auto end = begin + format_str.size();
  if (end - begin < 32) {

    const Char* p = begin;
    while (p != end) {
      auto c = *p++;
      if (c == '{') {
        handler.on_text(begin, p - 1);
        begin = p = parse_replacement_field(p - 1, end, handler);
      } else if (c == '}') {
        if (p == end || *p != '}')
          return handler.on_error("unmatched '}' in format string");
        handler.on_text(begin, p);
        begin = ++p;
      }
    }
    handler.on_text(begin, end);
    return;
  }
  struct writer {
    constexpr void operator()(const Char* from, const Char* to) {
      if (from == to) return;
      for (;;) {
        const Char* p = nullptr;
        if (!find<IS_CONSTEXPR>(from, to, Char('}'), p))
          return handler_.on_text(from, to);
        ++p;
        if (p == to || *p != '}')
          return handler_.on_error("unmatched '}' in format string");
        handler_.on_text(from, p);
        from = p + 1;
      }
    }
    Handler& handler_;
  } write = {handler};
  while (begin != end) {


    const Char* p = begin;
    if (*begin != '{' && !find<IS_CONSTEXPR>(begin + 1, end, Char('{'), p))
      return write(begin, end);
    write(begin, p);
    begin = parse_replacement_field(p, end, handler);
  }
}

template <typename T, bool = is_named_arg<T>::value> struct strip_named_arg {
  using type = T;
};
template <typename T> struct strip_named_arg<T, true> {
  using type = remove_cvref_t<decltype(T::value)>;
};

template <typename T, typename ParseContext>
constexpr auto parse_format_specs(ParseContext& ctx)
    -> decltype(ctx.begin()) {
  using char_type = typename ParseContext::char_type;
  using context = buffer_context<char_type>;
  using mapped_type = conditional_t<
      mapped_type_constant<T, context>::value != type::custom_type,
      decltype(arg_mapper<context>().map(std::declval<const T&>())),
      typename strip_named_arg<T>::type>;

  if constexpr (std::is_default_constructible<
                    formatter<mapped_type, char_type>>::value) {
    return formatter<mapped_type, char_type>().parse(ctx);
  } else {
    type_is_unformattable_for<T, char_type> _;
    return ctx.begin();
  }



}


template <typename Char>
constexpr auto check_char_specs(const format_specs<Char>& specs) -> bool {
  if (specs.type != presentation_type::none &&
      specs.type != presentation_type::chr &&
      specs.type != presentation_type::debug) {
    return false;
  }
  if (specs.align == align::numeric || specs.sign != sign::none || specs.alt)
    throw_format_error("invalid format specifier for char");
  return true;
}
# 2627 "/usr/include/fmt/core.h" 3 4
template <typename... Args, typename Char>
constexpr auto get_arg_index_by_name(basic_string_view<Char> name) -> int {




  (void)name;
  return -1;
}

template <typename Char, typename... Args> class format_string_checker {
 private:
  using parse_context_type = compile_parse_context<Char>;
  static constexpr int num_args = sizeof...(Args);





  using parse_func = const Char* (*)(parse_context_type&);

  type types_[num_args > 0 ? static_cast<size_t>(num_args) : 1];
  parse_context_type context_;
  parse_func parse_funcs_[num_args > 0 ? static_cast<size_t>(num_args) : 1];

 public:
  explicit constexpr format_string_checker(basic_string_view<Char> fmt)
      : types_{mapped_type_constant<Args, buffer_context<Char>>::value...},
        context_(fmt, num_args, types_),
        parse_funcs_{&parse_format_specs<Args, parse_context_type>...} {}

  constexpr void on_text(const Char*, const Char*) {}

  constexpr auto on_arg_id() -> int { return context_.next_arg_id(); }
  constexpr auto on_arg_id(int id) -> int {
    return context_.check_arg_id(id), id;
  }
  constexpr auto on_arg_id(basic_string_view<Char> id) -> int {





    (void)id;
    on_error("compile-time checks for named arguments require C++20 support");
    return 0;

  }

  constexpr void on_replacement_field(int id, const Char* begin) {
    on_format_specs(id, begin, begin);
  }

  constexpr auto on_format_specs(int id, const Char* begin, const Char*)
      -> const Char* {
    context_.advance_to(begin);

    return id >= 0 && id < num_args ? parse_funcs_[id](context_) : begin;
  }

  constexpr void on_error(const char* message) {
    throw_format_error(message);
  }
};


template <typename..., typename S, fmt::enable_if_t<(!is_compile_string<S>::value), int> = 0>
inline __attribute__((always_inline)) void check_format_string(const S&) {





}
template <typename... Args, typename S,
          fmt::enable_if_t<(is_compile_string<S>::value), int> = 0>
void check_format_string(S format_str) {
  using char_t = typename S::char_type;
  constexpr auto s = basic_string_view<char_t>(format_str);
  using checker = format_string_checker<char_t, remove_cvref_t<Args>...>;
  constexpr bool error = (parse_format_string<true>(s, checker(s)), true);
  ignore_unused(error);
}

template <typename Char = char> struct vformat_args {
  using type = basic_format_args<
      basic_format_context<std::back_insert_iterator<buffer<Char>>, Char>>;
};
template <> struct vformat_args<char> {
  using type = format_args;
};


template <typename Char>
void vformat_to(buffer<Char>& buf, basic_string_view<Char> fmt,
                typename vformat_args<Char>::type args, locale_ref loc = {});

__attribute__((visibility("default"))) void vprint_mojibake(std::FILE*, string_view, format_args);

inline void vprint_mojibake(std::FILE*, string_view, format_args) {}

}




template <typename T, typename Char>
struct formatter<T, Char,
                 enable_if_t<detail::type_constant<T, Char>::value !=
                             detail::type::custom_type>> {
 private:
  detail::dynamic_format_specs<Char> specs_;

 public:
  template <typename ParseContext>
  constexpr auto parse(ParseContext& ctx) -> const Char* {
    auto type = detail::type_constant<T, Char>::value;
    auto end =
        detail::parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx, type);
    if (type == detail::type::char_type) detail::check_char_specs(specs_);
    return end;
  }

  template <detail::type U = detail::type_constant<T, Char>::value,
            fmt::enable_if_t<(U == detail::type::string_type || U == detail::type::cstring_type || U == detail::type::char_type), int> = 0>


  constexpr void set_debug_format(bool set = true) {
    specs_.type = set ? presentation_type::debug : presentation_type::none;
  }

  template <typename FormatContext>
  constexpr auto format(const T& val, FormatContext& ctx) const
      -> decltype(ctx.out());
};

template <typename Char = char> struct runtime_format_string {
  basic_string_view<Char> str;
};


template <typename Char, typename... Args> class basic_format_string {
 private:
  basic_string_view<Char> str_;

 public:
  template <typename S,
            fmt::enable_if_t<(std::is_convertible<const S&, basic_string_view<Char>>::value), int> = 0>

  consteval inline __attribute__((always_inline)) basic_format_string(const S& s) : str_(s) {
    static_assert(
        detail::count<
            (std::is_base_of<detail::view, remove_reference_t<Args>>::value &&
             std::is_reference<Args>::value)...>() == 0,
        "passing views as lvalues is disallowed");

    if constexpr (detail::count_named_args<Args...>() ==
                  detail::count_statically_named_args<Args...>()) {
      using checker =
          detail::format_string_checker<Char, remove_cvref_t<Args>...>;
      detail::parse_format_string<true>(str_, checker(s));
    }



  }
  basic_format_string(runtime_format_string<Char> fmt) : str_(fmt.str) {}

  inline __attribute__((always_inline)) operator basic_string_view<Char>() const { return str_; }
  inline __attribute__((always_inline)) auto get() const -> basic_string_view<Char> { return str_; }
};






template <typename... Args>
using format_string = basic_format_string<char, type_identity_t<Args>...>;
# 2816 "/usr/include/fmt/core.h" 3 4
inline auto runtime(string_view s) -> runtime_format_string<> { return {{s}}; }


__attribute__((visibility("default"))) auto vformat(string_view fmt, format_args args) -> std::string;
# 2832 "/usr/include/fmt/core.h" 3 4
template <typename... T>
[[nodiscard]] inline __attribute__((always_inline)) auto format(format_string<T...> fmt, T&&... args)
    -> std::string {
  return vformat(fmt, fmt::make_format_args(args...));
}


template <typename OutputIt,
          fmt::enable_if_t<(detail::is_output_iterator<OutputIt, char>::value), int> = 0>
auto vformat_to(OutputIt out, string_view fmt, format_args args) -> OutputIt {
  auto&& buf = detail::get_buffer<char>(out);
  detail::vformat_to(buf, fmt, args, {});
  return detail::get_iterator(buf, out);
}
# 2859 "/usr/include/fmt/core.h" 3 4
template <typename OutputIt, typename... T,
          fmt::enable_if_t<(detail::is_output_iterator<OutputIt, char>::value), int> = 0>
inline __attribute__((always_inline)) auto format_to(OutputIt out, format_string<T...> fmt, T&&... args)
    -> OutputIt {
  return vformat_to(out, fmt, fmt::make_format_args(args...));
}

template <typename OutputIt> struct format_to_n_result {

  OutputIt out;

  size_t size;
};

template <typename OutputIt, typename... T,
          fmt::enable_if_t<(detail::is_output_iterator<OutputIt, char>::value), int> = 0>
auto vformat_to_n(OutputIt out, size_t n, string_view fmt, format_args args)
    -> format_to_n_result<OutputIt> {
  using traits = detail::fixed_buffer_traits;
  auto buf = detail::iterator_buffer<OutputIt, char, traits>(out, n);
  detail::vformat_to(buf, fmt, args, {});
  return {buf.out(), buf.count()};
}
# 2891 "/usr/include/fmt/core.h" 3 4
template <typename OutputIt, typename... T,
          fmt::enable_if_t<(detail::is_output_iterator<OutputIt, char>::value), int> = 0>
inline __attribute__((always_inline)) auto format_to_n(OutputIt out, size_t n, format_string<T...> fmt,
                            T&&... args) -> format_to_n_result<OutputIt> {
  return vformat_to_n(out, n, fmt, fmt::make_format_args(args...));
}


template <typename... T>
[[nodiscard]] inline __attribute__((always_inline)) auto formatted_size(format_string<T...> fmt,
                                             T&&... args) -> size_t {
  auto buf = detail::counting_buffer<>();
  detail::vformat_to<char>(buf, fmt, fmt::make_format_args(args...), {});
  return buf.count();
}

__attribute__((visibility("default"))) void vprint(string_view fmt, format_args args);
__attribute__((visibility("default"))) void vprint(std::FILE* f, string_view fmt, format_args args);
# 2920 "/usr/include/fmt/core.h" 3 4
template <typename... T>
inline __attribute__((always_inline)) void print(format_string<T...> fmt, T&&... args) {
  const auto& vargs = fmt::make_format_args(args...);
  return detail::is_utf8() ? vprint(fmt, vargs)
                           : detail::vprint_mojibake(stdout, fmt, vargs);
}
# 2937 "/usr/include/fmt/core.h" 3 4
template <typename... T>
inline __attribute__((always_inline)) void print(std::FILE* f, format_string<T...> fmt, T&&... args) {
  const auto& vargs = fmt::make_format_args(args...);
  return detail::is_utf8() ? vprint(f, fmt, vargs)
                           : detail::vprint_mojibake(f, fmt, vargs);
}





template <typename... T>
inline __attribute__((always_inline)) void println(std::FILE* f, format_string<T...> fmt, T&&... args) {
  return fmt::print(f, "{}\n", fmt::format(fmt, std::forward<T>(args)...));
}





template <typename... T>
inline __attribute__((always_inline)) void println(format_string<T...> fmt, T&&... args) {
  return fmt::println(stdout, fmt, std::forward<T>(args)...);
}



} }
# 50 "/usr/include/fmt/format.h" 2 3 4
# 279 "/usr/include/fmt/format.h" 3 4
namespace fmt { inline namespace v10 {
namespace detail {

constexpr inline void abort_fuzzing_if(bool condition) {
  ignore_unused(condition);



}

template <typename CharT, CharT... C> struct string_literal {
  static constexpr CharT value[sizeof...(C)] = {C...};
  constexpr operator basic_string_view<CharT>() const {
    return {value, sizeof...(C)};
  }
};







template <typename To, typename From, fmt::enable_if_t<(sizeof(To) == sizeof(From)), int> = 0>
constexpr auto bit_cast(const From& from) -> To {

  if (is_constant_evaluated()) return std::bit_cast<To>(from);

  auto to = To();

  std::memcpy(static_cast<void*>(&to), &from, sizeof(to));
  return to;
}

inline auto is_big_endian() -> bool {





  return 1234 == 4321;






}

class uint128_fallback {
 private:
  uint64_t lo_, hi_;

 public:
  constexpr uint128_fallback(uint64_t hi, uint64_t lo) : lo_(lo), hi_(hi) {}
  constexpr uint128_fallback(uint64_t value = 0) : lo_(value), hi_(0) {}

  constexpr auto high() const noexcept -> uint64_t { return hi_; }
  constexpr auto low() const noexcept -> uint64_t { return lo_; }

  template <typename T, fmt::enable_if_t<(std::is_integral<T>::value), int> = 0>
  constexpr explicit operator T() const {
    return static_cast<T>(lo_);
  }

  friend constexpr auto operator==(const uint128_fallback& lhs,
                                   const uint128_fallback& rhs) -> bool {
    return lhs.hi_ == rhs.hi_ && lhs.lo_ == rhs.lo_;
  }
  friend constexpr auto operator!=(const uint128_fallback& lhs,
                                   const uint128_fallback& rhs) -> bool {
    return !(lhs == rhs);
  }
  friend constexpr auto operator>(const uint128_fallback& lhs,
                                  const uint128_fallback& rhs) -> bool {
    return lhs.hi_ != rhs.hi_ ? lhs.hi_ > rhs.hi_ : lhs.lo_ > rhs.lo_;
  }
  friend constexpr auto operator|(const uint128_fallback& lhs,
                                  const uint128_fallback& rhs)
      -> uint128_fallback {
    return {lhs.hi_ | rhs.hi_, lhs.lo_ | rhs.lo_};
  }
  friend constexpr auto operator&(const uint128_fallback& lhs,
                                  const uint128_fallback& rhs)
      -> uint128_fallback {
    return {lhs.hi_ & rhs.hi_, lhs.lo_ & rhs.lo_};
  }
  friend constexpr auto operator~(const uint128_fallback& n)
      -> uint128_fallback {
    return {~n.hi_, ~n.lo_};
  }
  friend auto operator+(const uint128_fallback& lhs,
                        const uint128_fallback& rhs) -> uint128_fallback {
    auto result = uint128_fallback(lhs);
    result += rhs;
    return result;
  }
  friend auto operator*(const uint128_fallback& lhs, uint32_t rhs)
      -> uint128_fallback {
    ((lhs.hi_ == 0) ? (void)0 : fmt::detail::assert_fail("/usr/include/fmt/format.h", 378, ("")));
    uint64_t hi = (lhs.lo_ >> 32) * rhs;
    uint64_t lo = (lhs.lo_ & ~uint32_t()) * rhs;
    uint64_t new_lo = (hi << 32) + lo;
    return {(hi >> 32) + (new_lo < lo ? 1 : 0), new_lo};
  }
  friend auto operator-(const uint128_fallback& lhs, uint64_t rhs)
      -> uint128_fallback {
    return {lhs.hi_ - (lhs.lo_ < rhs ? 1 : 0), lhs.lo_ - rhs};
  }
  constexpr auto operator>>(int shift) const -> uint128_fallback {
    if (shift == 64) return {0, hi_};
    if (shift > 64) return uint128_fallback(0, hi_) >> (shift - 64);
    return {hi_ >> shift, (hi_ << (64 - shift)) | (lo_ >> shift)};
  }
  constexpr auto operator<<(int shift) const -> uint128_fallback {
    if (shift == 64) return {lo_, 0};
    if (shift > 64) return uint128_fallback(lo_, 0) << (shift - 64);
    return {hi_ << shift | (lo_ >> (64 - shift)), (lo_ << shift)};
  }
  constexpr auto operator>>=(int shift) -> uint128_fallback& {
    return *this = *this >> shift;
  }
  constexpr void operator+=(uint128_fallback n) {
    uint64_t new_lo = lo_ + n.lo_;
    uint64_t new_hi = hi_ + n.hi_ + (new_lo < lo_ ? 1 : 0);
    ((new_hi >= hi_) ? (void)0 : fmt::detail::assert_fail("/usr/include/fmt/format.h", 404, ("")));
    lo_ = new_lo;
    hi_ = new_hi;
  }
  constexpr void operator&=(uint128_fallback n) {
    lo_ &= n.lo_;
    hi_ &= n.hi_;
  }

  constexpr auto operator+=(uint64_t n) noexcept -> uint128_fallback& {
    if (is_constant_evaluated()) {
      lo_ += n;
      hi_ += (lo_ < n ? 1 : 0);
      return *this;
    }

    unsigned long long carry;
    lo_ = __builtin_addcll(lo_, n, 0, &carry);
    hi_ += carry;
# 435 "/usr/include/fmt/format.h" 3 4
    return *this;
  }
};

using uint128_t = conditional_t<1, uint128_opt, uint128_fallback>;


using uintptr_t = ::uintptr_t;






template <typename T> constexpr auto max_value() -> T {
  return (std::numeric_limits<T>::max)();
}
template <typename T> constexpr auto num_bits() -> int {
  return std::numeric_limits<T>::digits;
}

template <> constexpr auto num_bits<int128_opt>() -> int { return 128; }
template <> constexpr auto num_bits<uint128_t>() -> int { return 128; }



template <typename To, typename From, fmt::enable_if_t<(sizeof(To) > sizeof(From)), int> = 0>
inline auto bit_cast(const From& from) -> To {
  constexpr auto size = static_cast<int>(sizeof(From) / sizeof(unsigned));
  struct data_t {
    unsigned value[static_cast<unsigned>(size)];
  } data = bit_cast<data_t>(from);
  auto result = To();
  if (const_check(is_big_endian())) {
    for (int i = 0; i < size; ++i)
      result = (result << num_bits<unsigned>()) | data.value[i];
  } else {
    for (int i = size - 1; i >= 0; --i)
      result = (result << num_bits<unsigned>()) | data.value[i];
  }
  return result;
}

template <typename UInt>
constexpr inline auto countl_zero_fallback(UInt n) -> int {
  int lz = 0;
  constexpr UInt msb_mask = static_cast<UInt>(1) << (num_bits<UInt>() - 1);
  for (; (n & msb_mask) == 0; n <<= 1) lz++;
  return lz;
}

constexpr inline auto countl_zero(uint32_t n) -> int {

  if (!is_constant_evaluated()) return __builtin_clz(n);

  return countl_zero_fallback(n);
}

constexpr inline auto countl_zero(uint64_t n) -> int {

  if (!is_constant_evaluated()) return __builtin_clzll(n);

  return countl_zero_fallback(n);
}

inline __attribute__((always_inline)) void assume(bool condition) {
  (void)condition;

  __builtin_assume(condition);



}


template <typename T>
using iterator_t = decltype(std::begin(std::declval<T&>()));
template <typename T> using sentinel_t = decltype(std::end(std::declval<T&>()));


template <typename Char>
inline auto get_data(std::basic_string<Char>& s) -> Char* {
  return &s[0];
}
template <typename Container>
inline auto get_data(Container& c) -> typename Container::value_type* {
  return c.data();
}



template <typename Container, fmt::enable_if_t<(is_contiguous<Container>::value), int> = 0>

__attribute__((no_sanitize("undefined")))

inline auto
reserve(std::back_insert_iterator<Container> it, size_t n) ->
    typename Container::value_type* {
  Container& c = get_container(it);
  size_t size = c.size();
  c.resize(size + n);
  return get_data(c) + size;
}

template <typename T>
inline auto reserve(buffer_appender<T> it, size_t n) -> buffer_appender<T> {
  buffer<T>& buf = get_container(it);
  buf.try_reserve(buf.size() + n);
  return it;
}

template <typename Iterator>
constexpr auto reserve(Iterator& it, size_t) -> Iterator& {
  return it;
}

template <typename OutputIt>
using reserve_iterator =
    remove_reference_t<decltype(reserve(std::declval<OutputIt&>(), 0))>;

template <typename T, typename OutputIt>
constexpr auto to_pointer(OutputIt, size_t) -> T* {
  return nullptr;
}
template <typename T> auto to_pointer(buffer_appender<T> it, size_t n) -> T* {
  buffer<T>& buf = get_container(it);
  auto size = buf.size();
  if (buf.capacity() < size + n) return nullptr;
  buf.try_resize(size + n);
  return buf.data() + size;
}

template <typename Container, fmt::enable_if_t<(is_contiguous<Container>::value), int> = 0>
inline auto base_iterator(std::back_insert_iterator<Container> it,
                          typename Container::value_type*)
    -> std::back_insert_iterator<Container> {
  return it;
}

template <typename Iterator>
constexpr auto base_iterator(Iterator, Iterator it) -> Iterator {
  return it;
}



template <typename OutputIt, typename Size, typename T>
constexpr auto fill_n(OutputIt out, Size count, const T& value)
    -> OutputIt {
  for (Size i = 0; i < count; ++i) *out++ = value;
  return out;
}
template <typename T, typename Size>
constexpr auto fill_n(T* out, Size count, char value) -> T* {
  if (is_constant_evaluated()) {
    return fill_n<T*, Size, T>(out, count, value);
  }
  std::memset(out, value, to_unsigned(count));
  return out + count;
}


using char8_type = char8_t;




template <typename OutChar, typename InputIt, typename OutputIt>
constexpr __attribute__((noinline)) auto copy_str_noinline(InputIt begin, InputIt end,
                                                  OutputIt out) -> OutputIt {
  return copy_str<OutChar>(begin, end, out);
}
# 625 "/usr/include/fmt/format.h" 3 4
constexpr inline auto utf8_decode(const char* s, uint32_t* c, int* e)
    -> const char* {
  constexpr const int masks[] = {0x00, 0x7f, 0x1f, 0x0f, 0x07};
  constexpr const uint32_t mins[] = {4194304, 0, 128, 2048, 65536};
  constexpr const int shiftc[] = {0, 18, 12, 6, 0};
  constexpr const int shifte[] = {0, 6, 4, 2, 0};

  int len = "\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\0\0\0\0\0\0\0\0\2\2\2\2\3\3\4"
      [static_cast<unsigned char>(*s) >> 3];



  const char* next = s + len + !len;

  using uchar = unsigned char;



  *c = uint32_t(uchar(s[0]) & masks[len]) << 18;
  *c |= uint32_t(uchar(s[1]) & 0x3f) << 12;
  *c |= uint32_t(uchar(s[2]) & 0x3f) << 6;
  *c |= uint32_t(uchar(s[3]) & 0x3f) << 0;
  *c >>= shiftc[len];


  *e = (*c < mins[len]) << 6;
  *e |= ((*c >> 11) == 0x1b) << 7;
  *e |= (*c > 0x10FFFF) << 8;
  *e |= (uchar(s[1]) & 0xc0) >> 2;
  *e |= (uchar(s[2]) & 0xc0) >> 4;
  *e |= uchar(s[3]) >> 6;
  *e ^= 0x2a;
  *e >>= shifte[len];

  return next;
}

constexpr inline uint32_t invalid_code_point = ~uint32_t();



template <typename F>
constexpr void for_each_codepoint(string_view s, F f) {
  auto decode = [f](const char* buf_ptr, const char* ptr) {
    auto cp = uint32_t();
    auto error = 0;
    auto end = utf8_decode(buf_ptr, &cp, &error);
    bool result = f(error ? invalid_code_point : cp,
                    string_view(ptr, error ? 1 : to_unsigned(end - buf_ptr)));
    return result ? (error ? buf_ptr + 1 : end) : nullptr;
  };
  auto p = s.data();
  const size_t block_size = 4;
  if (s.size() >= block_size) {
    for (auto end = p + s.size() - block_size + 1; p < end;) {
      p = decode(p, p);
      if (!p) return;
    }
  }
  if (auto num_chars_left = s.data() + s.size() - p) {
    char buf[2 * block_size - 1] = {};
    copy_str<char>(p, p + num_chars_left, buf);
    const char* buf_ptr = buf;
    do {
      auto end = decode(buf_ptr, p);
      if (!end) return;
      p += end - buf_ptr;
      buf_ptr = end;
    } while (buf_ptr - buf < num_chars_left);
  }
}

template <typename Char>
inline auto compute_width(basic_string_view<Char> s) -> size_t {
  return s.size();
}


constexpr inline auto compute_width(string_view s) -> size_t {
  size_t num_code_points = 0;

  struct count_code_points {
    size_t* count;
    constexpr auto operator()(uint32_t cp, string_view) const -> bool {
      *count += detail::to_unsigned(
          1 +
          (cp >= 0x1100 &&
           (cp <= 0x115f ||
            cp == 0x2329 ||
            cp == 0x232a ||

            (cp >= 0x2e80 && cp <= 0xa4cf && cp != 0x303f) ||
            (cp >= 0xac00 && cp <= 0xd7a3) ||
            (cp >= 0xf900 && cp <= 0xfaff) ||
            (cp >= 0xfe10 && cp <= 0xfe19) ||
            (cp >= 0xfe30 && cp <= 0xfe6f) ||
            (cp >= 0xff00 && cp <= 0xff60) ||
            (cp >= 0xffe0 && cp <= 0xffe6) ||
            (cp >= 0x20000 && cp <= 0x2fffd) ||
            (cp >= 0x30000 && cp <= 0x3fffd) ||

            (cp >= 0x1f300 && cp <= 0x1f64f) ||

            (cp >= 0x1f900 && cp <= 0x1f9ff))));
      return true;
    }
  };

  for_each_codepoint(s, count_code_points{&num_code_points});
  return num_code_points;
}

inline auto compute_width(basic_string_view<char8_type> s) -> size_t {
  return compute_width(
      string_view(reinterpret_cast<const char*>(s.data()), s.size()));
}

template <typename Char>
inline auto code_point_index(basic_string_view<Char> s, size_t n) -> size_t {
  size_t size = s.size();
  return n < size ? n : size;
}


inline auto code_point_index(string_view s, size_t n) -> size_t {
  size_t result = s.size();
  const char* begin = s.begin();
  for_each_codepoint(s, [begin, &n, &result](uint32_t, string_view sv) {
    if (n != 0) {
      --n;
      return true;
    }
    result = to_unsigned(sv.begin() - begin);
    return false;
  });
  return result;
}

inline auto code_point_index(basic_string_view<char8_type> s, size_t n)
    -> size_t {
  return code_point_index(
      string_view(reinterpret_cast<const char*>(s.data()), s.size()), n);
}

template <typename T> struct is_integral : std::is_integral<T> {};
template <> struct is_integral<int128_opt> : std::true_type {};
template <> struct is_integral<uint128_t> : std::true_type {};

template <typename T>
using is_signed =
    std::integral_constant<bool, std::numeric_limits<T>::is_signed ||
                                     std::is_same<T, int128_opt>::value>;

template <typename T>
using is_integer =
    bool_constant<is_integral<T>::value && !std::is_same<T, bool>::value &&
                  !std::is_same<T, char>::value &&
                  !std::is_same<T, wchar_t>::value>;
# 814 "/usr/include/fmt/format.h" 3 4
using float128 = void;

template <typename T> using is_float128 = std::is_same<T, float128>;

template <typename T>
using is_floating_point =
    bool_constant<std::is_floating_point<T>::value || is_float128<T>::value>;

template <typename T, bool = std::is_floating_point<T>::value>
struct is_fast_float : bool_constant<std::numeric_limits<T>::is_iec559 &&
                                     sizeof(T) <= sizeof(double)> {};
template <typename T> struct is_fast_float<T, false> : std::false_type {};

template <typename T>
using is_double_double = bool_constant<std::numeric_limits<T>::digits == 106>;





template <typename T>
template <typename U>
void buffer<T>::append(const U* begin, const U* end) {
  while (begin != end) {
    auto count = to_unsigned(end - begin);
    try_reserve(size_ + count);
    auto free_cap = capacity_ - size_;
    if (free_cap < count) count = free_cap;
    std::uninitialized_copy_n(begin, count, ptr_ + size_);
    size_ += count;
    begin += count;
  }
}

template <typename T, typename Enable = void>
struct is_locale : std::false_type {};
template <typename T>
struct is_locale<T, void_t<decltype(T::classic())>> : std::true_type {};
}





enum { inline_buffer_size = 500 };
# 881 "/usr/include/fmt/format.h" 3 4
template <typename T, size_t SIZE = inline_buffer_size,
          typename Allocator = std::allocator<T>>
class basic_memory_buffer final : public detail::buffer<T> {
 private:
  T store_[SIZE];


  [[no_unique_address]] Allocator alloc_;


  constexpr void deallocate() {
    T* data = this->data();
    if (data != store_) alloc_.deallocate(data, this->capacity());
  }

 protected:
  constexpr void grow(size_t size) override {
    detail::abort_fuzzing_if(size > 5000);
    const size_t max_size = std::allocator_traits<Allocator>::max_size(alloc_);
    size_t old_capacity = this->capacity();
    size_t new_capacity = old_capacity + old_capacity / 2;
    if (size > new_capacity)
      new_capacity = size;
    else if (new_capacity > max_size)
      new_capacity = size > max_size ? size : max_size;
    T* old_data = this->data();
    T* new_data =
        std::allocator_traits<Allocator>::allocate(alloc_, new_capacity);

    detail::assume(this->size() <= new_capacity);

    std::uninitialized_copy_n(old_data, this->size(), new_data);
    this->set(new_data, new_capacity);



    if (old_data != store_) alloc_.deallocate(old_data, old_capacity);
  }

 public:
  using value_type = T;
  using const_reference = const T&;

  constexpr explicit basic_memory_buffer(
      const Allocator& alloc = Allocator())
      : alloc_(alloc) {
    this->set(store_, SIZE);
    if (detail::is_constant_evaluated()) detail::fill_n(store_, SIZE, T());
  }
  constexpr ~basic_memory_buffer() { deallocate(); }

 private:

  constexpr void move(basic_memory_buffer& other) {
    alloc_ = std::move(other.alloc_);
    T* data = other.data();
    size_t size = other.size(), capacity = other.capacity();
    if (data == other.store_) {
      this->set(store_, capacity);
      detail::copy_str<T>(other.store_, other.store_ + size, store_);
    } else {
      this->set(data, capacity);


      other.set(other.store_, 0);
      other.clear();
    }
    this->resize(size);
  }

 public:






  constexpr basic_memory_buffer(basic_memory_buffer&& other) noexcept {
    move(other);
  }






  auto operator=(basic_memory_buffer&& other) noexcept -> basic_memory_buffer& {
    ((this != &other) ? (void)0 : fmt::detail::assert_fail("/usr/include/fmt/format.h", 968, ("")));
    deallocate();
    move(other);
    return *this;
  }


  auto get_allocator() const -> Allocator { return alloc_; }





  constexpr void resize(size_t count) { this->try_resize(count); }


  void reserve(size_t new_capacity) { this->try_reserve(new_capacity); }

  using detail::buffer<T>::append;
  template <typename ContiguousRange>
  void append(const ContiguousRange& range) {
    append(range.data(), range.data() + range.size());
  }
};

using memory_buffer = basic_memory_buffer<char>;

template <typename T, size_t SIZE, typename Allocator>
struct is_contiguous<basic_memory_buffer<T, SIZE, Allocator>> : std::true_type {
};


namespace detail {
__attribute__((visibility("default"))) auto write_console(int fd, string_view text) -> bool;
__attribute__((visibility("default"))) auto write_console(std::FILE* f, string_view text) -> bool;
__attribute__((visibility("default"))) void print(std::FILE*, string_view);
}





#pragma clang diagnostic ignored "-Wweak-vtables"



class __attribute__((visibility("default"))) format_error : public std::runtime_error {
 public:
  using std::runtime_error::runtime_error;
};

namespace detail_exported {
# 1031 "/usr/include/fmt/format.h" 3 4
template <typename Char, size_t N>
constexpr auto compile_string_to_view(const Char (&s)[N])
    -> basic_string_view<Char> {


  return {s, N - (std::char_traits<Char>::to_int_type(s[N - 1]) == 0 ? 1 : 0)};
}
template <typename Char>
constexpr auto compile_string_to_view(detail::std_string_view<Char> s)
    -> basic_string_view<Char> {
  return {s.data(), s.size()};
}
}

class loc_value {
 private:
  basic_format_arg<format_context> value_;

 public:
  template <typename T, fmt::enable_if_t<(!detail::is_float128<T>::value), int> = 0>
  loc_value(T value) : value_(detail::make_arg<format_context>(value)) {}

  template <typename T, fmt::enable_if_t<(detail::is_float128<T>::value), int> = 0>
  loc_value(T) {}

  template <typename Visitor> auto visit(Visitor&& vis) -> decltype(vis(0)) {
    return visit_format_arg(vis, value_);
  }
};



template <typename Locale> class format_facet : public Locale::facet {
 private:
  std::string separator_;
  std::string grouping_;
  std::string decimal_point_;

 protected:
  virtual auto do_put(appender out, loc_value val,
                      const format_specs<>& specs) const -> bool;

 public:
  static __attribute__((visibility("default"))) typename Locale::id id;

  explicit format_facet(Locale& loc);
  explicit format_facet(string_view sep = "",
                        std::initializer_list<unsigned char> g = {3},
                        std::string decimal_point = ".")
      : separator_(sep.data(), sep.size()),
        grouping_(g.begin(), g.end()),
        decimal_point_(decimal_point) {}

  auto put(appender out, loc_value val, const format_specs<>& specs) const
      -> bool {
    return do_put(out, val, specs);
  }
};

namespace detail {



template <typename T, fmt::enable_if_t<(is_signed<T>::value), int> = 0>
constexpr auto is_negative(T value) -> bool {
  return value < 0;
}
template <typename T, fmt::enable_if_t<(!is_signed<T>::value), int> = 0>
constexpr auto is_negative(T) -> bool {
  return false;
}

template <typename T>
constexpr auto is_supported_floating_point(T) -> bool {
  if (std::is_same<T, float>()) return 1;
  if (std::is_same<T, double>()) return 1;
  if (std::is_same<T, long double>()) return 1;
  return true;
}



template <typename T>
using uint32_or_64_or_128_t =
    conditional_t<num_bits<T>() <= 32 && !0,
                  uint32_t,
                  conditional_t<num_bits<T>() <= 64, uint64_t, uint128_t>>;
template <typename T>
using uint64_or_128_t = conditional_t<num_bits<T>() <= 64, uint64_t, uint128_t>;







constexpr auto digits2(size_t value) -> const char* {

  return &"0001020304050607080910111213141516171819"
         "2021222324252627282930313233343536373839"
         "4041424344454647484950515253545556575859"
         "6061626364656667686970717273747576777879"
         "8081828384858687888990919293949596979899"[value * 2];
}


template <typename Char, typename Sign> constexpr auto sign(Sign s) -> Char {

  static_assert(std::is_same<Sign, sign_t>::value, "");

  return static_cast<Char>("\0-+ "[s]);
}

template <typename T> constexpr auto count_digits_fallback(T n) -> int {
  int count = 1;
  for (;;) {



    if (n < 10) return count;
    if (n < 100) return count + 1;
    if (n < 1000) return count + 2;
    if (n < 10000) return count + 3;
    n /= 10000u;
    count += 4;
  }
}

constexpr inline auto count_digits(uint128_opt n) -> int {
  return count_digits_fallback(n);
}





inline auto do_count_digits(uint64_t n) -> int {




  static constexpr uint8_t bsr2log10[] = {
      1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5,
      6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 9, 9, 9, 10, 10, 10,
      10, 11, 11, 11, 12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 15, 15,
      15, 16, 16, 16, 16, 17, 17, 17, 18, 18, 18, 19, 19, 19, 19, 20};
  auto t = bsr2log10[__builtin_clzll(n | 1) ^ 63];
  static constexpr const uint64_t zero_or_powers_of_10[] = {
      0, 0, 1U * 10, (1U) * 100, (1U) * 1000, (1U) * 10000, (1U) * 100000, (1U) * 1000000, (1U) * 10000000, (1U) * 100000000, (1U) * 1000000000, 1000000000ULL * 10, (1000000000ULL) * 100, (1000000000ULL) * 1000, (1000000000ULL) * 10000, (1000000000ULL) * 100000, (1000000000ULL) * 1000000, (1000000000ULL) * 10000000, (1000000000ULL) * 100000000, (1000000000ULL) * 1000000000,
      10000000000000000000ULL};
  return t - (n < zero_or_powers_of_10[t]);
}




constexpr inline auto count_digits(uint64_t n) -> int {

  if (!is_constant_evaluated()) {
    return do_count_digits(n);
  }

  return count_digits_fallback(n);
}


template <int BITS, typename UInt>
constexpr auto count_digits(UInt n) -> int {

  if (!is_constant_evaluated() && num_bits<UInt>() == 32)
    return (__builtin_clz(static_cast<uint32_t>(n) | 1) ^ 31) / BITS + 1;


  return [](UInt m) {
    int num_digits = 0;
    do {
      ++num_digits;
    } while ((m >>= BITS) != 0);
    return num_digits;
  }(n);
}




inline __attribute__((always_inline)) auto do_count_digits(uint32_t n) -> int {



  static constexpr uint64_t table[] = {
      (((sizeof("0") - 1ull) << 32) - 0), (((sizeof("0") - 1ull) << 32) - 0), (((sizeof("0") - 1ull) << 32) - 0),
      (((sizeof("10") - 1ull) << 32) - 10), (((sizeof("10") - 1ull) << 32) - 10), (((sizeof("10") - 1ull) << 32) - 10),
      (((sizeof("100") - 1ull) << 32) - 100), (((sizeof("100") - 1ull) << 32) - 100), (((sizeof("100") - 1ull) << 32) - 100),
      (((sizeof("1000") - 1ull) << 32) - 1000), (((sizeof("1000") - 1ull) << 32) - 1000), (((sizeof("1000") - 1ull) << 32) - 1000),
      (((sizeof("10000") - 1ull) << 32) - 10000), (((sizeof("10000") - 1ull) << 32) - 10000), (((sizeof("10000") - 1ull) << 32) - 10000),
      (((sizeof("100000") - 1ull) << 32) - 100000), (((sizeof("100000") - 1ull) << 32) - 100000), (((sizeof("100000") - 1ull) << 32) - 100000),
      (((sizeof("1000000") - 1ull) << 32) - 1000000), (((sizeof("1000000") - 1ull) << 32) - 1000000), (((sizeof("1000000") - 1ull) << 32) - 1000000),
      (((sizeof("10000000") - 1ull) << 32) - 10000000), (((sizeof("10000000") - 1ull) << 32) - 10000000), (((sizeof("10000000") - 1ull) << 32) - 10000000),
      (((sizeof("100000000") - 1ull) << 32) - 100000000), (((sizeof("100000000") - 1ull) << 32) - 100000000), (((sizeof("100000000") - 1ull) << 32) - 100000000),
      (((sizeof("1000000000") - 1ull) << 32) - 1000000000), (((sizeof("1000000000") - 1ull) << 32) - 1000000000), (((sizeof("1000000000") - 1ull) << 32) - 1000000000),
      (((sizeof("1000000000") - 1ull) << 32) - 1000000000), (((sizeof("1000000000") - 1ull) << 32) - 1000000000)
  };
  auto inc = table[__builtin_clz(n | 1) ^ 31];
  return static_cast<int>((n + inc) >> 32);
}



constexpr inline auto count_digits(uint32_t n) -> int {

  if (!is_constant_evaluated()) {
    return do_count_digits(n);
  }

  return count_digits_fallback(n);
}

template <typename Int> constexpr auto digits10() noexcept -> int {
  return std::numeric_limits<Int>::digits10;
}
template <> constexpr auto digits10<int128_opt>() noexcept -> int { return 38; }
template <> constexpr auto digits10<uint128_t>() noexcept -> int { return 38; }

template <typename Char> struct thousands_sep_result {
  std::string grouping;
  Char thousands_sep;
};

template <typename Char>
__attribute__((visibility("default"))) auto thousands_sep_impl(locale_ref loc) -> thousands_sep_result<Char>;
template <typename Char>
inline auto thousands_sep(locale_ref loc) -> thousands_sep_result<Char> {
  auto result = thousands_sep_impl<char>(loc);
  return {result.grouping, Char(result.thousands_sep)};
}
template <>
inline auto thousands_sep(locale_ref loc) -> thousands_sep_result<wchar_t> {
  return thousands_sep_impl<wchar_t>(loc);
}

template <typename Char>
__attribute__((visibility("default"))) auto decimal_point_impl(locale_ref loc) -> Char;
template <typename Char> inline auto decimal_point(locale_ref loc) -> Char {
  return Char(decimal_point_impl<char>(loc));
}
template <> inline auto decimal_point(locale_ref loc) -> wchar_t {
  return decimal_point_impl<wchar_t>(loc);
}


template <typename Char> auto equal2(const Char* lhs, const char* rhs) -> bool {
  return lhs[0] == Char(rhs[0]) && lhs[1] == Char(rhs[1]);
}
inline auto equal2(const char* lhs, const char* rhs) -> bool {
  return memcmp(lhs, rhs, 2) == 0;
}


template <typename Char>
constexpr inline __attribute__((always_inline)) void copy2(Char* dst, const char* src) {
  if (!is_constant_evaluated() && sizeof(Char) == sizeof(char)) {
    memcpy(dst, src, 2);
    return;
  }
  *dst++ = static_cast<Char>(*src++);
  *dst = static_cast<Char>(*src);
}

template <typename Iterator> struct format_decimal_result {
  Iterator begin;
  Iterator end;
};




template <typename Char, typename UInt>
constexpr auto format_decimal(Char* out, UInt value, int size)
    -> format_decimal_result<Char*> {
  ((size >= count_digits(value)) ? (void)0 : fmt::detail::assert_fail("/usr/include/fmt/format.h", 1310, ("invalid digit count")));
  out += size;
  Char* end = out;
  while (value >= 100) {



    out -= 2;
    copy2(out, digits2(static_cast<size_t>(value % 100)));
    value /= 100;
  }
  if (value < 10) {
    *--out = static_cast<Char>('0' + value);
    return {out, end};
  }
  out -= 2;
  copy2(out, digits2(static_cast<size_t>(value)));
  return {out, end};
}

template <typename Char, typename UInt, typename Iterator,
          fmt::enable_if_t<(!std::is_pointer<remove_cvref_t<Iterator>>::value), int> = 0>
constexpr inline auto format_decimal(Iterator out, UInt value, int size)
    -> format_decimal_result<Iterator> {

  Char buffer[digits10<UInt>() + 1] = {};
  auto end = format_decimal(buffer, value, size).end;
  return {out, detail::copy_str_noinline<Char>(buffer, end, out)};
}

template <unsigned BASE_BITS, typename Char, typename UInt>
constexpr auto format_uint(Char* buffer, UInt value, int num_digits,
                               bool upper = false) -> Char* {
  buffer += num_digits;
  Char* end = buffer;
  do {
    const char* digits = upper ? "0123456789ABCDEF" : "0123456789abcdef";
    unsigned digit = static_cast<unsigned>(value & ((1 << BASE_BITS) - 1));
    *--buffer = static_cast<Char>(BASE_BITS < 4 ? static_cast<char>('0' + digit)
                                                : digits[digit]);
  } while ((value >>= BASE_BITS) != 0);
  return end;
}

template <unsigned BASE_BITS, typename Char, typename It, typename UInt>
constexpr inline auto format_uint(It out, UInt value, int num_digits,
                                      bool upper = false) -> It {
  if (auto ptr = to_pointer<Char>(out, to_unsigned(num_digits))) {
    format_uint<BASE_BITS>(ptr, value, num_digits, upper);
    return out;
  }

  char buffer[num_bits<UInt>() / BASE_BITS + 1] = {};
  format_uint<BASE_BITS>(buffer, value, num_digits, upper);
  return detail::copy_str_noinline<Char>(buffer, buffer + num_digits, out);
}


class utf8_to_utf16 {
 private:
  basic_memory_buffer<wchar_t> buffer_;

 public:
  __attribute__((visibility("default"))) explicit utf8_to_utf16(string_view s);
  operator basic_string_view<wchar_t>() const { return {&buffer_[0], size()}; }
  auto size() const -> size_t { return buffer_.size() - 1; }
  auto c_str() const -> const wchar_t* { return &buffer_[0]; }
  auto str() const -> std::wstring { return {&buffer_[0], size()}; }
};

enum class to_utf8_error_policy { abort, replace };


template <typename WChar, typename Buffer = memory_buffer> class to_utf8 {
 private:
  Buffer buffer_;

 public:
  to_utf8() {}
  explicit to_utf8(basic_string_view<WChar> s,
                   to_utf8_error_policy policy = to_utf8_error_policy::abort) {
    static_assert(sizeof(WChar) == 2 || sizeof(WChar) == 4,
                  "Expect utf16 or utf32");
    if (!convert(s, policy))
      throw std::runtime_error(sizeof(WChar) == 2 ? "invalid utf16" : "invalid utf32");

  }
  operator string_view() const { return string_view(&buffer_[0], size()); }
  auto size() const -> size_t { return buffer_.size() - 1; }
  auto c_str() const -> const char* { return &buffer_[0]; }
  auto str() const -> std::string { return std::string(&buffer_[0], size()); }




  auto convert(basic_string_view<WChar> s,
               to_utf8_error_policy policy = to_utf8_error_policy::abort)
      -> bool {
    if (!convert(buffer_, s, policy)) return false;
    buffer_.push_back(0);
    return true;
  }
  static auto convert(Buffer& buf, basic_string_view<WChar> s,
                      to_utf8_error_policy policy = to_utf8_error_policy::abort)
      -> bool {
    for (auto p = s.begin(); p != s.end(); ++p) {
      uint32_t c = static_cast<uint32_t>(*p);
      if (sizeof(WChar) == 2 && c >= 0xd800 && c <= 0xdfff) {

        ++p;
        if (p == s.end() || (c & 0xfc00) != 0xd800 || (*p & 0xfc00) != 0xdc00) {
          if (policy == to_utf8_error_policy::abort) return false;
          buf.append(string_view("\xEF\xBF\xBD"));
          --p;
        } else {
          c = (c << 10) + static_cast<uint32_t>(*p) - 0x35fdc00;
        }
      } else if (c < 0x80) {
        buf.push_back(static_cast<char>(c));
      } else if (c < 0x800) {
        buf.push_back(static_cast<char>(0xc0 | (c >> 6)));
        buf.push_back(static_cast<char>(0x80 | (c & 0x3f)));
      } else if ((c >= 0x800 && c <= 0xd7ff) || (c >= 0xe000 && c <= 0xffff)) {
        buf.push_back(static_cast<char>(0xe0 | (c >> 12)));
        buf.push_back(static_cast<char>(0x80 | ((c & 0xfff) >> 6)));
        buf.push_back(static_cast<char>(0x80 | (c & 0x3f)));
      } else if (c >= 0x10000 && c <= 0x10ffff) {
        buf.push_back(static_cast<char>(0xf0 | (c >> 18)));
        buf.push_back(static_cast<char>(0x80 | ((c & 0x3ffff) >> 12)));
        buf.push_back(static_cast<char>(0x80 | ((c & 0xfff) >> 6)));
        buf.push_back(static_cast<char>(0x80 | (c & 0x3f)));
      } else {
        return false;
      }
    }
    return true;
  }
};


inline auto umul128(uint64_t x, uint64_t y) noexcept -> uint128_fallback {

  auto p = static_cast<uint128_opt>(x) * static_cast<uint128_opt>(y);
  return {static_cast<uint64_t>(p >> 64), static_cast<uint64_t>(p)};
# 1476 "/usr/include/fmt/format.h" 3 4
}

namespace dragonbox {


inline auto floor_log10_pow2(int e) noexcept -> int {
  ((e <= 2620 && e >= -2620) ? (void)0 : fmt::detail::assert_fail("/usr/include/fmt/format.h", 1482, ("too large exponent")));
  static_assert((-1 >> 1) == -1, "right shift is not arithmetic");
  return (e * 315653) >> 20;
}

inline auto floor_log2_pow10(int e) noexcept -> int {
  ((e <= 1233 && e >= -1233) ? (void)0 : fmt::detail::assert_fail("/usr/include/fmt/format.h", 1488, ("too large exponent")));
  return (e * 1741647) >> 19;
}


inline auto umul128_upper64(uint64_t x, uint64_t y) noexcept -> uint64_t {

  auto p = static_cast<uint128_opt>(x) * static_cast<uint128_opt>(y);
  return static_cast<uint64_t>(p >> 64);





}



inline auto umul192_upper128(uint64_t x, uint128_fallback y) noexcept
    -> uint128_fallback {
  uint128_fallback r = umul128(x, y.high());
  r += umul128_upper64(x, y.low());
  return r;
}

__attribute__((visibility("default"))) auto get_cached_power(int k) noexcept -> uint128_fallback;


template <typename T, typename Enable = void> struct float_info;

template <> struct float_info<float> {
  using carrier_uint = uint32_t;
  static const int exponent_bits = 8;
  static const int kappa = 1;
  static const int big_divisor = 100;
  static const int small_divisor = 10;
  static const int min_k = -31;
  static const int max_k = 46;
  static const int shorter_interval_tie_lower_threshold = -35;
  static const int shorter_interval_tie_upper_threshold = -35;
};

template <> struct float_info<double> {
  using carrier_uint = uint64_t;
  static const int exponent_bits = 11;
  static const int kappa = 2;
  static const int big_divisor = 1000;
  static const int small_divisor = 100;
  static const int min_k = -292;
  static const int max_k = 341;
  static const int shorter_interval_tie_lower_threshold = -77;
  static const int shorter_interval_tie_upper_threshold = -77;
};


template <typename T>
struct float_info<T, enable_if_t<std::numeric_limits<T>::digits == 64 ||
                                 std::numeric_limits<T>::digits == 113 ||
                                 is_float128<T>::value>> {
  using carrier_uint = detail::uint128_t;
  static const int exponent_bits = 15;
};


template <typename T>
struct float_info<T, enable_if_t<is_double_double<T>::value>> {
  using carrier_uint = detail::uint128_t;
};

template <typename T> struct decimal_fp {
  using significand_type = typename float_info<T>::carrier_uint;
  significand_type significand;
  int exponent;
};

template <typename T> __attribute__((visibility("default"))) auto to_decimal(T x) noexcept -> decimal_fp<T>;
}


template <typename Float> constexpr auto has_implicit_bit() -> bool {

  return std::numeric_limits<Float>::digits != 64;
}



template <typename Float> constexpr auto num_significand_bits() -> int {

  return is_float128<Float>() ? 112
                              : (std::numeric_limits<Float>::digits -
                                 (has_implicit_bit<Float>() ? 1 : 0));
}

template <typename Float>
constexpr auto exponent_mask() ->
    typename dragonbox::float_info<Float>::carrier_uint {
  using float_uint = typename dragonbox::float_info<Float>::carrier_uint;
  return ((float_uint(1) << dragonbox::float_info<Float>::exponent_bits) - 1)
         << num_significand_bits<Float>();
}
template <typename Float> constexpr auto exponent_bias() -> int {

  return is_float128<Float>() ? 16383
                              : std::numeric_limits<Float>::max_exponent - 1;
}


template <typename Char, typename It>
constexpr auto write_exponent(int exp, It it) -> It {
  ((-10000 < exp && exp < 10000) ? (void)0 : fmt::detail::assert_fail("/usr/include/fmt/format.h", 1597, ("exponent out of range")));
  if (exp < 0) {
    *it++ = static_cast<Char>('-');
    exp = -exp;
  } else {
    *it++ = static_cast<Char>('+');
  }
  if (exp >= 100) {
    const char* top = digits2(to_unsigned(exp / 100));
    if (exp >= 1000) *it++ = static_cast<Char>(top[0]);
    *it++ = static_cast<Char>(top[1]);
    exp %= 100;
  }
  const char* d = digits2(to_unsigned(exp));
  *it++ = static_cast<Char>(d[0]);
  *it++ = static_cast<Char>(d[1]);
  return it;
}


template <typename F> struct basic_fp {
  F f;
  int e;

  static constexpr const int num_significand_bits =
      static_cast<int>(sizeof(F) * num_bits<unsigned char>());

  constexpr basic_fp() : f(0), e(0) {}
  constexpr basic_fp(uint64_t f_val, int e_val) : f(f_val), e(e_val) {}


  template <typename Float> constexpr basic_fp(Float n) { assign(n); }


  template <typename Float, fmt::enable_if_t<(!is_double_double<Float>::value), int> = 0>
  constexpr auto assign(Float n) -> bool {
    static_assert(std::numeric_limits<Float>::digits <= 113, "unsupported FP");

    using carrier_uint = typename dragonbox::float_info<Float>::carrier_uint;
    const auto num_float_significand_bits =
        detail::num_significand_bits<Float>();
    const auto implicit_bit = carrier_uint(1) << num_float_significand_bits;
    const auto significand_mask = implicit_bit - 1;
    auto u = bit_cast<carrier_uint>(n);
    f = static_cast<F>(u & significand_mask);
    auto biased_e = static_cast<int>((u & exponent_mask<Float>()) >>
                                     num_float_significand_bits);


    auto is_predecessor_closer = f == 0 && biased_e > 1;
    if (biased_e == 0)
      biased_e = 1;
    else if (has_implicit_bit<Float>())
      f += static_cast<F>(implicit_bit);
    e = biased_e - exponent_bias<Float>() - num_float_significand_bits;
    if (!has_implicit_bit<Float>()) ++e;
    return is_predecessor_closer;
  }

  template <typename Float, fmt::enable_if_t<(is_double_double<Float>::value), int> = 0>
  constexpr auto assign(Float n) -> bool {
    static_assert(std::numeric_limits<double>::is_iec559, "unsupported FP");
    return assign(static_cast<double>(n));
  }
};

using fp = basic_fp<unsigned long long>;


template <int SHIFT = 0, typename F>
constexpr auto normalize(basic_fp<F> value) -> basic_fp<F> {

  const auto implicit_bit = F(1) << num_significand_bits<double>();
  const auto shifted_implicit_bit = implicit_bit << SHIFT;
  while ((value.f & shifted_implicit_bit) == 0) {
    value.f <<= 1;
    --value.e;
  }

  const auto offset = basic_fp<F>::num_significand_bits -
                      num_significand_bits<double>() - SHIFT - 1;
  value.f <<= offset;
  value.e -= offset;
  return value;
}


constexpr inline auto multiply(uint64_t lhs, uint64_t rhs) -> uint64_t {

  auto product = static_cast<__uint128_t>(lhs) * rhs;
  auto f = static_cast<uint64_t>(product >> 64);
  return (static_cast<uint64_t>(product) & (1ULL << 63)) != 0 ? f + 1 : f;
# 1699 "/usr/include/fmt/format.h" 3 4
}

constexpr inline auto operator*(fp x, fp y) -> fp {
  return {multiply(x.f, y.f), x.e + y.e + 64};
}

template <typename T, bool doublish = num_bits<T>() == num_bits<double>()>
using convert_float_result =
    conditional_t<std::is_same<T, float>::value || doublish, double, T>;

template <typename T>
constexpr auto convert_float(T value) -> convert_float_result<T> {
  return static_cast<convert_float_result<T>>(value);
}

template <typename OutputIt, typename Char>
__attribute__((noinline)) constexpr auto fill(OutputIt it, size_t n,
                                     const fill_t<Char>& fill) -> OutputIt {
  auto fill_size = fill.size();
  if (fill_size == 1) return detail::fill_n(it, n, fill[0]);
  auto data = fill.data();
  for (size_t i = 0; i < n; ++i)
    it = copy_str<Char>(data, data + fill_size, it);
  return it;
}




template <align::type align = align::left, typename OutputIt, typename Char,
          typename F>
constexpr auto write_padded(OutputIt out, const format_specs<Char>& specs,
                                size_t size, size_t width, F&& f) -> OutputIt {
  static_assert(align == align::left || align == align::right, "");
  unsigned spec_width = to_unsigned(specs.width);
  size_t padding = spec_width > width ? spec_width - width : 0;


  auto* shifts = align == align::left ? "\x1f\x1f\x00\x01" : "\x00\x1f\x00\x01";
  size_t left_padding = padding >> shifts[specs.align];
  size_t right_padding = padding - left_padding;
  auto it = reserve(out, size + padding * specs.fill.size());
  if (left_padding != 0) it = fill(it, left_padding, specs.fill);
  it = f(it);
  if (right_padding != 0) it = fill(it, right_padding, specs.fill);
  return base_iterator(out, it);
}

template <align::type align = align::left, typename OutputIt, typename Char,
          typename F>
constexpr auto write_padded(OutputIt out, const format_specs<Char>& specs,
                            size_t size, F&& f) -> OutputIt {
  return write_padded<align>(out, specs, size, size, f);
}

template <align::type align = align::left, typename Char, typename OutputIt>
constexpr auto write_bytes(OutputIt out, string_view bytes,
                               const format_specs<Char>& specs) -> OutputIt {
  return write_padded<align>(
      out, specs, bytes.size(), [bytes](reserve_iterator<OutputIt> it) {
        const char* data = bytes.data();
        return copy_str<Char>(data, data + bytes.size(), it);
      });
}

template <typename Char, typename OutputIt, typename UIntPtr>
auto write_ptr(OutputIt out, UIntPtr value, const format_specs<Char>* specs)
    -> OutputIt {
  int num_digits = count_digits<4>(value);
  auto size = to_unsigned(num_digits) + size_t(2);
  auto write = [=](reserve_iterator<OutputIt> it) {
    *it++ = static_cast<Char>('0');
    *it++ = static_cast<Char>('x');
    return format_uint<4, Char>(it, value, num_digits);
  };
  return specs ? write_padded<align::right>(out, *specs, size, write)
               : base_iterator(out, write(reserve(out, size)));
}


__attribute__((visibility("default"))) auto is_printable(uint32_t cp) -> bool;

inline auto needs_escape(uint32_t cp) -> bool {
  return cp < 0x20 || cp == 0x7f || cp == '"' || cp == '\\' ||
         !is_printable(cp);
}

template <typename Char> struct find_escape_result {
  const Char* begin;
  const Char* end;
  uint32_t cp;
};

template <typename Char>
using make_unsigned_char =
    typename conditional_t<std::is_integral<Char>::value,
                           std::make_unsigned<Char>,
                           type_identity<uint32_t>>::type;

template <typename Char>
auto find_escape(const Char* begin, const Char* end)
    -> find_escape_result<Char> {
  for (; begin != end; ++begin) {
    uint32_t cp = static_cast<make_unsigned_char<Char>>(*begin);
    if (const_check(sizeof(Char) == 1) && cp >= 0x80) continue;
    if (needs_escape(cp)) return {begin, begin + 1, cp};
  }
  return {begin, nullptr, 0};
}

inline auto find_escape(const char* begin, const char* end)
    -> find_escape_result<char> {
  if (!is_utf8()) return find_escape<char>(begin, end);
  auto result = find_escape_result<char>{end, nullptr, 0};
  for_each_codepoint(string_view(begin, to_unsigned(end - begin)),
                     [&](uint32_t cp, string_view sv) {
                       if (needs_escape(cp)) {
                         result = {sv.begin(), sv.end(), cp};
                         return false;
                       }
                       return true;
                     });
  return result;
}
# 1850 "/usr/include/fmt/format.h" 3 4
template <size_t width, typename Char, typename OutputIt>
auto write_codepoint(OutputIt out, char prefix, uint32_t cp) -> OutputIt {
  *out++ = static_cast<Char>('\\');
  *out++ = static_cast<Char>(prefix);
  Char buf[width];
  fill_n(buf, width, static_cast<Char>('0'));
  format_uint<4>(buf, cp, width);
  return copy_str<Char>(buf, buf + width, out);
}

template <typename OutputIt, typename Char>
auto write_escaped_cp(OutputIt out, const find_escape_result<Char>& escape)
    -> OutputIt {
  auto c = static_cast<Char>(escape.cp);
  switch (escape.cp) {
  case '\n':
    *out++ = static_cast<Char>('\\');
    c = static_cast<Char>('n');
    break;
  case '\r':
    *out++ = static_cast<Char>('\\');
    c = static_cast<Char>('r');
    break;
  case '\t':
    *out++ = static_cast<Char>('\\');
    c = static_cast<Char>('t');
    break;
  case '"':
    [[fallthrough]];
  case '\'':
    [[fallthrough]];
  case '\\':
    *out++ = static_cast<Char>('\\');
    break;
  default:
    if (escape.cp < 0x100) {
      return write_codepoint<2, Char>(out, 'x', escape.cp);
    }
    if (escape.cp < 0x10000) {
      return write_codepoint<4, Char>(out, 'u', escape.cp);
    }
    if (escape.cp < 0x110000) {
      return write_codepoint<8, Char>(out, 'U', escape.cp);
    }
    for (Char escape_char : basic_string_view<Char>(
             escape.begin, to_unsigned(escape.end - escape.begin))) {
      out = write_codepoint<2, Char>(out, 'x',
                                     static_cast<uint32_t>(escape_char) & 0xFF);
    }
    return out;
  }
  *out++ = c;
  return out;
}

template <typename Char, typename OutputIt>
auto write_escaped_string(OutputIt out, basic_string_view<Char> str)
    -> OutputIt {
  *out++ = static_cast<Char>('"');
  auto begin = str.begin(), end = str.end();
  do {
    auto escape = find_escape(begin, end);
    out = copy_str<Char>(begin, escape.begin, out);
    begin = escape.end;
    if (!begin) break;
    out = write_escaped_cp<OutputIt, Char>(out, escape);
  } while (begin != end);
  *out++ = static_cast<Char>('"');
  return out;
}

template <typename Char, typename OutputIt>
auto write_escaped_char(OutputIt out, Char v) -> OutputIt {
  Char v_array[1] = {v};
  *out++ = static_cast<Char>('\'');
  if ((needs_escape(static_cast<uint32_t>(v)) && v != static_cast<Char>('"')) ||
      v == static_cast<Char>('\'')) {
    out = write_escaped_cp(out,
                           find_escape_result<Char>{v_array, v_array + 1,
                                                    static_cast<uint32_t>(v)});
  } else {
    *out++ = v;
  }
  *out++ = static_cast<Char>('\'');
  return out;
}

template <typename Char, typename OutputIt>
constexpr auto write_char(OutputIt out, Char value,
                              const format_specs<Char>& specs) -> OutputIt {
  bool is_debug = specs.type == presentation_type::debug;
  return write_padded(out, specs, 1, [=](reserve_iterator<OutputIt> it) {
    if (is_debug) return write_escaped_char(it, value);
    *it++ = value;
    return it;
  });
}
template <typename Char, typename OutputIt>
constexpr auto write(OutputIt out, Char value,
                         const format_specs<Char>& specs, locale_ref loc = {})
    -> OutputIt {

  using unsigned_type =
      conditional_t<std::is_same<Char, char>::value, unsigned char, unsigned>;
  return check_char_specs(specs)
             ? write_char(out, value, specs)
             : write(out, static_cast<unsigned_type>(value), specs, loc);
}



template <typename Char> struct write_int_data {
  size_t size;
  size_t padding;

  constexpr write_int_data(int num_digits, unsigned prefix,
                               const format_specs<Char>& specs)
      : size((prefix >> 24) + to_unsigned(num_digits)), padding(0) {
    if (specs.align == align::numeric) {
      auto width = to_unsigned(specs.width);
      if (width > size) {
        padding = width - size;
        size = width;
      }
    } else if (specs.precision > num_digits) {
      size = (prefix >> 24) + to_unsigned(specs.precision);
      padding = to_unsigned(specs.precision - num_digits);
    }
  }
};





template <typename OutputIt, typename Char, typename W>
constexpr inline __attribute__((always_inline)) auto write_int(OutputIt out, int num_digits,
                                        unsigned prefix,
                                        const format_specs<Char>& specs,
                                        W write_digits) -> OutputIt {

  if ((specs.width | (specs.precision + 1)) == 0) {
    auto it = reserve(out, to_unsigned(num_digits) + (prefix >> 24));
    if (prefix != 0) {
      for (unsigned p = prefix & 0xffffff; p != 0; p >>= 8)
        *it++ = static_cast<Char>(p & 0xff);
    }
    return base_iterator(out, write_digits(it));
  }
  auto data = write_int_data<Char>(num_digits, prefix, specs);
  return write_padded<align::right>(
      out, specs, data.size, [=](reserve_iterator<OutputIt> it) {
        for (unsigned p = prefix & 0xffffff; p != 0; p >>= 8)
          *it++ = static_cast<Char>(p & 0xff);
        it = detail::fill_n(it, data.padding, static_cast<Char>('0'));
        return write_digits(it);
      });
}

template <typename Char> class digit_grouping {
 private:
  std::string grouping_;
  std::basic_string<Char> thousands_sep_;

  struct next_state {
    std::string::const_iterator group;
    int pos;
  };
  auto initial_state() const -> next_state { return {grouping_.begin(), 0}; }


  auto next(next_state& state) const -> int {
    if (thousands_sep_.empty()) return max_value<int>();
    if (state.group == grouping_.end()) return state.pos += grouping_.back();
    if (*state.group <= 0 || *state.group == max_value<char>())
      return max_value<int>();
    state.pos += *state.group++;
    return state.pos;
  }

 public:
  explicit digit_grouping(locale_ref loc, bool localized = true) {
    if (!localized) return;
    auto sep = thousands_sep<Char>(loc);
    grouping_ = sep.grouping;
    if (sep.thousands_sep) thousands_sep_.assign(1, sep.thousands_sep);
  }
  digit_grouping(std::string grouping, std::basic_string<Char> sep)
      : grouping_(std::move(grouping)), thousands_sep_(std::move(sep)) {}

  auto has_separator() const -> bool { return !thousands_sep_.empty(); }

  auto count_separators(int num_digits) const -> int {
    int count = 0;
    auto state = initial_state();
    while (num_digits > next(state)) ++count;
    return count;
  }


  template <typename Out, typename C>
  auto apply(Out out, basic_string_view<C> digits) const -> Out {
    auto num_digits = static_cast<int>(digits.size());
    auto separators = basic_memory_buffer<int>();
    separators.push_back(0);
    auto state = initial_state();
    while (int i = next(state)) {
      if (i >= num_digits) break;
      separators.push_back(i);
    }
    for (int i = 0, sep_index = static_cast<int>(separators.size() - 1);
         i < num_digits; ++i) {
      if (num_digits - i == separators[sep_index]) {
        out =
            copy_str<Char>(thousands_sep_.data(),
                           thousands_sep_.data() + thousands_sep_.size(), out);
        --sep_index;
      }
      *out++ = static_cast<Char>(digits[to_unsigned(i)]);
    }
    return out;
  }
};

constexpr inline void prefix_append(unsigned& prefix, unsigned value) {
  prefix |= prefix != 0 ? value << 8 : value;
  prefix += (1u + (value > 0xff ? 1 : 0)) << 24;
}


template <typename OutputIt, typename UInt, typename Char>
auto write_int(OutputIt out, UInt value, unsigned prefix,
               const format_specs<Char>& specs,
               const digit_grouping<Char>& grouping) -> OutputIt {
  static_assert(std::is_same<uint64_or_128_t<UInt>, UInt>::value, "");
  int num_digits = 0;
  auto buffer = memory_buffer();
  switch (specs.type) {
  case presentation_type::none:
  case presentation_type::dec: {
    num_digits = count_digits(value);
    format_decimal<char>(appender(buffer), value, num_digits);
    break;
  }
  case presentation_type::hex_lower:
  case presentation_type::hex_upper: {
    bool upper = specs.type == presentation_type::hex_upper;
    if (specs.alt)
      prefix_append(prefix, unsigned(upper ? 'X' : 'x') << 8 | '0');
    num_digits = count_digits<4>(value);
    format_uint<4, char>(appender(buffer), value, num_digits, upper);
    break;
  }
  case presentation_type::bin_lower:
  case presentation_type::bin_upper: {
    bool upper = specs.type == presentation_type::bin_upper;
    if (specs.alt)
      prefix_append(prefix, unsigned(upper ? 'B' : 'b') << 8 | '0');
    num_digits = count_digits<1>(value);
    format_uint<1, char>(appender(buffer), value, num_digits);
    break;
  }
  case presentation_type::oct: {
    num_digits = count_digits<3>(value);


    if (specs.alt && specs.precision <= num_digits && value != 0)
      prefix_append(prefix, '0');
    format_uint<3, char>(appender(buffer), value, num_digits);
    break;
  }
  case presentation_type::chr:
    return write_char(out, static_cast<Char>(value), specs);
  default:
    throw_format_error("invalid format specifier");
  }

  unsigned size = (prefix != 0 ? prefix >> 24 : 0) + to_unsigned(num_digits) +
                  to_unsigned(grouping.count_separators(num_digits));
  return write_padded<align::right>(
      out, specs, size, size, [&](reserve_iterator<OutputIt> it) {
        for (unsigned p = prefix & 0xffffff; p != 0; p >>= 8)
          *it++ = static_cast<Char>(p & 0xff);
        return grouping.apply(it, string_view(buffer.data(), buffer.size()));
      });
}


__attribute__((visibility("default"))) auto write_loc(appender out, loc_value value,
                       const format_specs<>& specs, locale_ref loc) -> bool;
template <typename OutputIt, typename Char>
inline auto write_loc(OutputIt, loc_value, const format_specs<Char>&,
                      locale_ref) -> bool {
  return false;
}

template <typename UInt> struct write_int_arg {
  UInt abs_value;
  unsigned prefix;
};

template <typename T>
constexpr auto make_write_int_arg(T value, sign_t sign)
    -> write_int_arg<uint32_or_64_or_128_t<T>> {
  auto prefix = 0u;
  auto abs_value = static_cast<uint32_or_64_or_128_t<T>>(value);
  if (is_negative(value)) {
    prefix = 0x01000000 | '-';
    abs_value = 0 - abs_value;
  } else {
    constexpr const unsigned prefixes[4] = {0, 0, 0x1000000u | '+',
                                            0x1000000u | ' '};
    prefix = prefixes[sign];
  }
  return {abs_value, prefix};
}

template <typename Char = char> struct loc_writer {
  buffer_appender<Char> out;
  const format_specs<Char>& specs;
  std::basic_string<Char> sep;
  std::string grouping;
  std::basic_string<Char> decimal_point;

  template <typename T, fmt::enable_if_t<(is_integer<T>::value), int> = 0>
  auto operator()(T value) -> bool {
    auto arg = make_write_int_arg(value, specs.sign);
    write_int(out, static_cast<uint64_or_128_t<T>>(arg.abs_value), arg.prefix,
              specs, digit_grouping<Char>(grouping, sep));
    return true;
  }

  template <typename T, fmt::enable_if_t<(!is_integer<T>::value), int> = 0>
  auto operator()(T) -> bool {
    return false;
  }
};

template <typename Char, typename OutputIt, typename T>
constexpr inline __attribute__((always_inline)) auto write_int(OutputIt out, write_int_arg<T> arg,
                                        const format_specs<Char>& specs,
                                        locale_ref) -> OutputIt {
  static_assert(std::is_same<T, uint32_or_64_or_128_t<T>>::value, "");
  auto abs_value = arg.abs_value;
  auto prefix = arg.prefix;
  switch (specs.type) {
  case presentation_type::none:
  case presentation_type::dec: {
    auto num_digits = count_digits(abs_value);
    return write_int(
        out, num_digits, prefix, specs, [=](reserve_iterator<OutputIt> it) {
          return format_decimal<Char>(it, abs_value, num_digits).end;
        });
  }
  case presentation_type::hex_lower:
  case presentation_type::hex_upper: {
    bool upper = specs.type == presentation_type::hex_upper;
    if (specs.alt)
      prefix_append(prefix, unsigned(upper ? 'X' : 'x') << 8 | '0');
    int num_digits = count_digits<4>(abs_value);
    return write_int(
        out, num_digits, prefix, specs, [=](reserve_iterator<OutputIt> it) {
          return format_uint<4, Char>(it, abs_value, num_digits, upper);
        });
  }
  case presentation_type::bin_lower:
  case presentation_type::bin_upper: {
    bool upper = specs.type == presentation_type::bin_upper;
    if (specs.alt)
      prefix_append(prefix, unsigned(upper ? 'B' : 'b') << 8 | '0');
    int num_digits = count_digits<1>(abs_value);
    return write_int(out, num_digits, prefix, specs,
                     [=](reserve_iterator<OutputIt> it) {
                       return format_uint<1, Char>(it, abs_value, num_digits);
                     });
  }
  case presentation_type::oct: {
    int num_digits = count_digits<3>(abs_value);


    if (specs.alt && specs.precision <= num_digits && abs_value != 0)
      prefix_append(prefix, '0');
    return write_int(out, num_digits, prefix, specs,
                     [=](reserve_iterator<OutputIt> it) {
                       return format_uint<3, Char>(it, abs_value, num_digits);
                     });
  }
  case presentation_type::chr:
    return write_char(out, static_cast<Char>(abs_value), specs);
  default:
    throw_format_error("invalid format specifier");
  }
  return out;
}
template <typename Char, typename OutputIt, typename T>
constexpr __attribute__((noinline)) auto write_int_noinline(
    OutputIt out, write_int_arg<T> arg, const format_specs<Char>& specs,
    locale_ref loc) -> OutputIt {
  return write_int(out, arg, specs, loc);
}
template <typename Char, typename OutputIt, typename T,
          fmt::enable_if_t<(is_integral<T>::value && !std::is_same<T, bool>::value && std::is_same<OutputIt, buffer_appender<Char>>::value), int> = 0>


constexpr inline __attribute__((always_inline)) auto write(OutputIt out, T value,
                                    const format_specs<Char>& specs,
                                    locale_ref loc) -> OutputIt {
  if (specs.localized && write_loc(out, value, specs, loc)) return out;
  return write_int_noinline(out, make_write_int_arg(value, specs.sign), specs,
                            loc);
}

template <typename Char, typename OutputIt, typename T,
          fmt::enable_if_t<(is_integral<T>::value && !std::is_same<T, bool>::value && !std::is_same<OutputIt, buffer_appender<Char>>::value), int> = 0>


constexpr inline __attribute__((always_inline)) auto write(OutputIt out, T value,
                                    const format_specs<Char>& specs,
                                    locale_ref loc) -> OutputIt {
  if (specs.localized && write_loc(out, value, specs, loc)) return out;
  return write_int(out, make_write_int_arg(value, specs.sign), specs, loc);
}



class counting_iterator {
 private:
  size_t count_;

 public:
  using iterator_category = std::output_iterator_tag;
  using difference_type = std::ptrdiff_t;
  using pointer = void;
  using reference = void;
  using unchecked_type = counting_iterator;

  struct value_type {
    template <typename T> constexpr void operator=(const T&) {}
  };

  constexpr counting_iterator() : count_(0) {}

  constexpr auto count() const -> size_t { return count_; }

  constexpr auto operator++() -> counting_iterator& {
    ++count_;
    return *this;
  }
  constexpr auto operator++(int) -> counting_iterator {
    auto it = *this;
    ++*this;
    return it;
  }

  constexpr friend auto operator+(counting_iterator it, difference_type n)
      -> counting_iterator {
    it.count_ += static_cast<size_t>(n);
    return it;
  }

  constexpr auto operator*() const -> value_type { return {}; }
};

template <typename Char, typename OutputIt>
constexpr auto write(OutputIt out, basic_string_view<Char> s,
                         const format_specs<Char>& specs) -> OutputIt {
  auto data = s.data();
  auto size = s.size();
  if (specs.precision >= 0 && to_unsigned(specs.precision) < size)
    size = code_point_index(s, to_unsigned(specs.precision));
  bool is_debug = specs.type == presentation_type::debug;
  size_t width = 0;
  if (specs.width != 0) {
    if (is_debug)
      width = write_escaped_string(counting_iterator{}, s).count();
    else
      width = compute_width(basic_string_view<Char>(data, size));
  }
  return write_padded(out, specs, size, width,
                      [=](reserve_iterator<OutputIt> it) {
                        if (is_debug) return write_escaped_string(it, s);
                        return copy_str<Char>(data, data + size, it);
                      });
}
template <typename Char, typename OutputIt>
constexpr auto write(OutputIt out,
                         basic_string_view<type_identity_t<Char>> s,
                         const format_specs<Char>& specs, locale_ref)
    -> OutputIt {
  return write(out, s, specs);
}
template <typename Char, typename OutputIt>
constexpr auto write(OutputIt out, const Char* s,
                         const format_specs<Char>& specs, locale_ref)
    -> OutputIt {
  if (specs.type == presentation_type::pointer)
    return write_ptr<Char>(out, bit_cast<uintptr_t>(s), &specs);
  if (!s) throw_format_error("string pointer is null");
  return write(out, basic_string_view<Char>(s), specs, {});
}

template <typename Char, typename OutputIt, typename T,
          fmt::enable_if_t<(is_integral<T>::value && !std::is_same<T, bool>::value && !std::is_same<T, Char>::value), int> = 0>


constexpr auto write(OutputIt out, T value) -> OutputIt {
  auto abs_value = static_cast<uint32_or_64_or_128_t<T>>(value);
  bool negative = is_negative(value);

  if (negative) abs_value = ~abs_value + 1;
  int num_digits = count_digits(abs_value);
  auto size = (negative ? 1 : 0) + static_cast<size_t>(num_digits);
  auto it = reserve(out, size);
  if (auto ptr = to_pointer<Char>(it, size)) {
    if (negative) *ptr++ = static_cast<Char>('-');
    format_decimal<Char>(ptr, abs_value, num_digits);
    return out;
  }
  if (negative) *it++ = static_cast<Char>('-');
  it = format_decimal<Char>(it, abs_value, num_digits).end;
  return base_iterator(out, it);
}


template <typename Char>
constexpr auto parse_align(const Char* begin, const Char* end,
                               format_specs<Char>& specs) -> const Char* {
  ((begin != end) ? (void)0 : fmt::detail::assert_fail("/usr/include/fmt/format.h", 2377, ("")));
  auto align = align::none;
  auto p = begin + code_point_length(begin);
  if (end - p <= 0) p = begin;
  for (;;) {
    switch (to_ascii(*p)) {
    case '<':
      align = align::left;
      break;
    case '>':
      align = align::right;
      break;
    case '^':
      align = align::center;
      break;
    }
    if (align != align::none) {
      if (p != begin) {
        auto c = *begin;
        if (c == '}') return begin;
        if (c == '{') {
          throw_format_error("invalid fill character '{'");
          return begin;
        }
        specs.fill = {begin, to_unsigned(p - begin)};
        begin = p + 1;
      } else {
        ++begin;
      }
      break;
    } else if (p == begin) {
      break;
    }
    p = begin;
  }
  specs.align = align;
  return begin;
}


enum class float_format : unsigned char {
  general,
  exp,
  fixed,
  hex
};

struct float_specs {
  int precision;
  float_format format : 8;
  sign_t sign : 8;
  bool upper : 1;
  bool locale : 1;
  bool binary32 : 1;
  bool showpoint : 1;
};

template <typename Char>
constexpr auto parse_float_type_spec(const format_specs<Char>& specs)
    -> float_specs {
  auto result = float_specs();
  result.showpoint = specs.alt;
  result.locale = specs.localized;
  switch (specs.type) {
  case presentation_type::none:
    result.format = float_format::general;
    break;
  case presentation_type::general_upper:
    result.upper = true;
    [[fallthrough]];
  case presentation_type::general_lower:
    result.format = float_format::general;
    break;
  case presentation_type::exp_upper:
    result.upper = true;
    [[fallthrough]];
  case presentation_type::exp_lower:
    result.format = float_format::exp;
    result.showpoint |= specs.precision != 0;
    break;
  case presentation_type::fixed_upper:
    result.upper = true;
    [[fallthrough]];
  case presentation_type::fixed_lower:
    result.format = float_format::fixed;
    result.showpoint |= specs.precision != 0;
    break;
  case presentation_type::hexfloat_upper:
    result.upper = true;
    [[fallthrough]];
  case presentation_type::hexfloat_lower:
    result.format = float_format::hex;
    break;
  default:
    throw_format_error("invalid format specifier");
    break;
  }
  return result;
}

template <typename Char, typename OutputIt>
constexpr auto write_nonfinite(OutputIt out, bool isnan,
                                     format_specs<Char> specs,
                                     const float_specs& fspecs) -> OutputIt {
  auto str =
      isnan ? (fspecs.upper ? "NAN" : "nan") : (fspecs.upper ? "INF" : "inf");
  constexpr size_t str_size = 3;
  auto sign = fspecs.sign;
  auto size = str_size + (sign ? 1 : 0);

  const bool is_zero_fill =
      specs.fill.size() == 1 && *specs.fill.data() == static_cast<Char>('0');
  if (is_zero_fill) specs.fill[0] = static_cast<Char>(' ');
  return write_padded(out, specs, size, [=](reserve_iterator<OutputIt> it) {
    if (sign) *it++ = detail::sign<Char>(sign);
    return copy_str<Char>(str, str + str_size, it);
  });
}


struct big_decimal_fp {
  const char* significand;
  int significand_size;
  int exponent;
};

constexpr auto get_significand_size(const big_decimal_fp& f) -> int {
  return f.significand_size;
}
template <typename T>
inline auto get_significand_size(const dragonbox::decimal_fp<T>& f) -> int {
  return count_digits(f.significand);
}

template <typename Char, typename OutputIt>
constexpr auto write_significand(OutputIt out, const char* significand,
                                 int significand_size) -> OutputIt {
  return copy_str<Char>(significand, significand + significand_size, out);
}
template <typename Char, typename OutputIt, typename UInt>
inline auto write_significand(OutputIt out, UInt significand,
                              int significand_size) -> OutputIt {
  return format_decimal<Char>(out, significand, significand_size).end;
}
template <typename Char, typename OutputIt, typename T, typename Grouping>
constexpr auto write_significand(OutputIt out, T significand,
                                       int significand_size, int exponent,
                                       const Grouping& grouping) -> OutputIt {
  if (!grouping.has_separator()) {
    out = write_significand<Char>(out, significand, significand_size);
    return detail::fill_n(out, exponent, static_cast<Char>('0'));
  }
  auto buffer = memory_buffer();
  write_significand<char>(appender(buffer), significand, significand_size);
  detail::fill_n(appender(buffer), exponent, '0');
  return grouping.apply(out, string_view(buffer.data(), buffer.size()));
}

template <typename Char, typename UInt,
          fmt::enable_if_t<(std::is_integral<UInt>::value), int> = 0>
inline auto write_significand(Char* out, UInt significand, int significand_size,
                              int integral_size, Char decimal_point) -> Char* {
  if (!decimal_point)
    return format_decimal(out, significand, significand_size).end;
  out += significand_size + 1;
  Char* end = out;
  int floating_size = significand_size - integral_size;
  for (int i = floating_size / 2; i > 0; --i) {
    out -= 2;
    copy2(out, digits2(static_cast<std::size_t>(significand % 100)));
    significand /= 100;
  }
  if (floating_size % 2 != 0) {
    *--out = static_cast<Char>('0' + significand % 10);
    significand /= 10;
  }
  *--out = decimal_point;
  format_decimal(out - integral_size, significand, integral_size);
  return end;
}

template <typename OutputIt, typename UInt, typename Char,
          fmt::enable_if_t<(!std::is_pointer<remove_cvref_t<OutputIt>>::value), int> = 0>
inline auto write_significand(OutputIt out, UInt significand,
                              int significand_size, int integral_size,
                              Char decimal_point) -> OutputIt {

  Char buffer[digits10<UInt>() + 2];
  auto end = write_significand(buffer, significand, significand_size,
                               integral_size, decimal_point);
  return detail::copy_str_noinline<Char>(buffer, end, out);
}

template <typename OutputIt, typename Char>
constexpr auto write_significand(OutputIt out, const char* significand,
                                     int significand_size, int integral_size,
                                     Char decimal_point) -> OutputIt {
  out = detail::copy_str_noinline<Char>(significand,
                                        significand + integral_size, out);
  if (!decimal_point) return out;
  *out++ = decimal_point;
  return detail::copy_str_noinline<Char>(significand + integral_size,
                                         significand + significand_size, out);
}

template <typename OutputIt, typename Char, typename T, typename Grouping>
constexpr auto write_significand(OutputIt out, T significand,
                                       int significand_size, int integral_size,
                                       Char decimal_point,
                                       const Grouping& grouping) -> OutputIt {
  if (!grouping.has_separator()) {
    return write_significand(out, significand, significand_size, integral_size,
                             decimal_point);
  }
  auto buffer = basic_memory_buffer<Char>();
  write_significand(buffer_appender<Char>(buffer), significand,
                    significand_size, integral_size, decimal_point);
  grouping.apply(
      out, basic_string_view<Char>(buffer.data(), to_unsigned(integral_size)));
  return detail::copy_str_noinline<Char>(buffer.data() + integral_size,
                                         buffer.end(), out);
}

template <typename OutputIt, typename DecimalFP, typename Char,
          typename Grouping = digit_grouping<Char>>
constexpr auto do_write_float(OutputIt out, const DecimalFP& f,
                                    const format_specs<Char>& specs,
                                    float_specs fspecs, locale_ref loc)
    -> OutputIt {
  auto significand = f.significand;
  int significand_size = get_significand_size(f);
  const Char zero = static_cast<Char>('0');
  auto sign = fspecs.sign;
  size_t size = to_unsigned(significand_size) + (sign ? 1 : 0);
  using iterator = reserve_iterator<OutputIt>;

  Char decimal_point =
      fspecs.locale ? detail::decimal_point<Char>(loc) : static_cast<Char>('.');

  int output_exp = f.exponent + significand_size - 1;
  auto use_exp_format = [=]() {
    if (fspecs.format == float_format::exp) return true;
    if (fspecs.format != float_format::general) return false;


    const int exp_lower = -4, exp_upper = 16;
    return output_exp < exp_lower ||
           output_exp >= (fspecs.precision > 0 ? fspecs.precision : exp_upper);
  };
  if (use_exp_format()) {
    int num_zeros = 0;
    if (fspecs.showpoint) {
      num_zeros = fspecs.precision - significand_size;
      if (num_zeros < 0) num_zeros = 0;
      size += to_unsigned(num_zeros);
    } else if (significand_size == 1) {
      decimal_point = Char();
    }
    auto abs_output_exp = output_exp >= 0 ? output_exp : -output_exp;
    int exp_digits = 2;
    if (abs_output_exp >= 100) exp_digits = abs_output_exp >= 1000 ? 4 : 3;

    size += to_unsigned((decimal_point ? 1 : 0) + 2 + exp_digits);
    char exp_char = fspecs.upper ? 'E' : 'e';
    auto write = [=](iterator it) {
      if (sign) *it++ = detail::sign<Char>(sign);

      it = write_significand(it, significand, significand_size, 1,
                             decimal_point);
      if (num_zeros > 0) it = detail::fill_n(it, num_zeros, zero);
      *it++ = static_cast<Char>(exp_char);
      return write_exponent<Char>(output_exp, it);
    };
    return specs.width > 0 ? write_padded<align::right>(out, specs, size, write)
                           : base_iterator(out, write(reserve(out, size)));
  }

  int exp = f.exponent + significand_size;
  if (f.exponent >= 0) {

    size += to_unsigned(f.exponent);
    int num_zeros = fspecs.precision - exp;
    abort_fuzzing_if(num_zeros > 5000);
    if (fspecs.showpoint) {
      ++size;
      if (num_zeros <= 0 && fspecs.format != float_format::fixed) num_zeros = 0;
      if (num_zeros > 0) size += to_unsigned(num_zeros);
    }
    auto grouping = Grouping(loc, fspecs.locale);
    size += to_unsigned(grouping.count_separators(exp));
    return write_padded<align::right>(out, specs, size, [&](iterator it) {
      if (sign) *it++ = detail::sign<Char>(sign);
      it = write_significand<Char>(it, significand, significand_size,
                                   f.exponent, grouping);
      if (!fspecs.showpoint) return it;
      *it++ = decimal_point;
      return num_zeros > 0 ? detail::fill_n(it, num_zeros, zero) : it;
    });
  } else if (exp > 0) {

    int num_zeros = fspecs.showpoint ? fspecs.precision - significand_size : 0;
    size += 1 + to_unsigned(num_zeros > 0 ? num_zeros : 0);
    auto grouping = Grouping(loc, fspecs.locale);
    size += to_unsigned(grouping.count_separators(exp));
    return write_padded<align::right>(out, specs, size, [&](iterator it) {
      if (sign) *it++ = detail::sign<Char>(sign);
      it = write_significand(it, significand, significand_size, exp,
                             decimal_point, grouping);
      return num_zeros > 0 ? detail::fill_n(it, num_zeros, zero) : it;
    });
  }

  int num_zeros = -exp;
  if (significand_size == 0 && fspecs.precision >= 0 &&
      fspecs.precision < num_zeros) {
    num_zeros = fspecs.precision;
  }
  bool pointy = num_zeros != 0 || significand_size != 0 || fspecs.showpoint;
  size += 1 + (pointy ? 1 : 0) + to_unsigned(num_zeros);
  return write_padded<align::right>(out, specs, size, [&](iterator it) {
    if (sign) *it++ = detail::sign<Char>(sign);
    *it++ = zero;
    if (!pointy) return it;
    *it++ = decimal_point;
    it = detail::fill_n(it, num_zeros, zero);
    return write_significand<Char>(it, significand, significand_size);
  });
}

template <typename Char> class fallback_digit_grouping {
 public:
  constexpr fallback_digit_grouping(locale_ref, bool) {}

  constexpr auto has_separator() const -> bool { return false; }

  constexpr auto count_separators(int) const -> int { return 0; }

  template <typename Out, typename C>
  constexpr auto apply(Out out, basic_string_view<C>) const -> Out {
    return out;
  }
};

template <typename OutputIt, typename DecimalFP, typename Char>
constexpr auto write_float(OutputIt out, const DecimalFP& f,
                                 const format_specs<Char>& specs,
                                 float_specs fspecs, locale_ref loc)
    -> OutputIt {
  if (is_constant_evaluated()) {
    return do_write_float<OutputIt, DecimalFP, Char,
                          fallback_digit_grouping<Char>>(out, f, specs, fspecs,
                                                         loc);
  } else {
    return do_write_float(out, f, specs, fspecs, loc);
  }
}

template <typename T> constexpr auto isnan(T value) -> bool {
  return !(value >= value);
}

template <typename T, typename Enable = void>
struct has_isfinite : std::false_type {};

template <typename T>
struct has_isfinite<T, enable_if_t<sizeof(std::isfinite(T())) != 0>>
    : std::true_type {};

template <typename T, fmt::enable_if_t<(std::is_floating_point<T>::value&& has_isfinite<T>::value), int> = 0>

constexpr auto isfinite(T value) -> bool {
  constexpr T inf = T(std::numeric_limits<double>::infinity());
  if (is_constant_evaluated())
    return !detail::isnan(value) && value < inf && value > -inf;
  return std::isfinite(value);
}
template <typename T, fmt::enable_if_t<(!has_isfinite<T>::value), int> = 0>
constexpr auto isfinite(T value) -> bool {
  T inf = T(std::numeric_limits<double>::infinity());

  return !detail::isnan(value) && value < inf && value > -inf;
}

template <typename T, fmt::enable_if_t<(is_floating_point<T>::value), int> = 0>
inline __attribute__((always_inline)) constexpr bool signbit(T value) {
  if (is_constant_evaluated()) {

    if constexpr (std::numeric_limits<double>::is_iec559) {
      auto bits = detail::bit_cast<uint64_t>(static_cast<double>(value));
      return (bits >> (num_bits<uint64_t>() - 1)) != 0;
    }

  }
  return std::signbit(static_cast<double>(value));
}

inline constexpr void adjust_precision(int& precision, int exp10) {


  if (exp10 > 0 && precision > max_value<int>() - exp10)
    throw format_error("number is too big");
  precision += exp10;
}

class bigint {
 private:


  using bigit = uint32_t;
  using double_bigit = uint64_t;
  enum { bigits_capacity = 32 };
  basic_memory_buffer<bigit, bigits_capacity> bigits_;
  int exp_;

  constexpr auto operator[](int index) const -> bigit {
    return bigits_[to_unsigned(index)];
  }
  constexpr auto operator[](int index) -> bigit& {
    return bigits_[to_unsigned(index)];
  }

  static constexpr const int bigit_bits = num_bits<bigit>();

  friend struct formatter<bigint>;

  constexpr void subtract_bigits(int index, bigit other, bigit& borrow) {
    auto result = static_cast<double_bigit>((*this)[index]) - other - borrow;
    (*this)[index] = static_cast<bigit>(result);
    borrow = static_cast<bigit>(result >> (bigit_bits * 2 - 1));
  }

  constexpr void remove_leading_zeros() {
    int num_bigits = static_cast<int>(bigits_.size()) - 1;
    while (num_bigits > 0 && (*this)[num_bigits] == 0) --num_bigits;
    bigits_.resize(to_unsigned(num_bigits + 1));
  }


  constexpr void subtract_aligned(const bigint& other) {
    ((other.exp_ >= exp_) ? (void)0 : fmt::detail::assert_fail("/usr/include/fmt/format.h", 2816, ("unaligned bigints")));
    ((compare(*this, other) >= 0) ? (void)0 : fmt::detail::assert_fail("/usr/include/fmt/format.h", 2817, ("")));
    bigit borrow = 0;
    int i = other.exp_ - exp_;
    for (size_t j = 0, n = other.bigits_.size(); j != n; ++i, ++j)
      subtract_bigits(i, other.bigits_[j], borrow);
    while (borrow > 0) subtract_bigits(i, 0, borrow);
    remove_leading_zeros();
  }

  constexpr void multiply(uint32_t value) {
    const double_bigit wide_value = value;
    bigit carry = 0;
    for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
      double_bigit result = bigits_[i] * wide_value + carry;
      bigits_[i] = static_cast<bigit>(result);
      carry = static_cast<bigit>(result >> bigit_bits);
    }
    if (carry != 0) bigits_.push_back(carry);
  }

  template <typename UInt, fmt::enable_if_t<(std::is_same<UInt, uint64_t>::value || std::is_same<UInt, uint128_t>::value), int> = 0>

  constexpr void multiply(UInt value) {
    using half_uint =
        conditional_t<std::is_same<UInt, uint128_t>::value, uint64_t, uint32_t>;
    const int shift = num_bits<half_uint>() - bigit_bits;
    const UInt lower = static_cast<half_uint>(value);
    const UInt upper = value >> num_bits<half_uint>();
    UInt carry = 0;
    for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
      UInt result = lower * bigits_[i] + static_cast<bigit>(carry);
      carry = (upper * bigits_[i] << shift) + (result >> bigit_bits) +
              (carry >> bigit_bits);
      bigits_[i] = static_cast<bigit>(result);
    }
    while (carry != 0) {
      bigits_.push_back(static_cast<bigit>(carry));
      carry >>= bigit_bits;
    }
  }

  template <typename UInt, fmt::enable_if_t<(std::is_same<UInt, uint64_t>::value || std::is_same<UInt, uint128_t>::value), int> = 0>

  constexpr void assign(UInt n) {
    size_t num_bigits = 0;
    do {
      bigits_[num_bigits++] = static_cast<bigit>(n);
      n >>= bigit_bits;
    } while (n != 0);
    bigits_.resize(num_bigits);
    exp_ = 0;
  }

 public:
  constexpr bigint() : exp_(0) {}
  explicit bigint(uint64_t n) { assign(n); }

  bigint(const bigint&) = delete;
  void operator=(const bigint&) = delete;

  constexpr void assign(const bigint& other) {
    auto size = other.bigits_.size();
    bigits_.resize(size);
    auto data = other.bigits_.data();
    copy_str<bigit>(data, data + size, bigits_.data());
    exp_ = other.exp_;
  }

  template <typename Int> constexpr void operator=(Int n) {
    ((n > 0) ? (void)0 : fmt::detail::assert_fail("/usr/include/fmt/format.h", 2886, ("")));
    assign(uint64_or_128_t<Int>(n));
  }

  constexpr auto num_bigits() const -> int {
    return static_cast<int>(bigits_.size()) + exp_;
  }

  __attribute__((noinline)) constexpr auto operator<<=(int shift) -> bigint& {
    ((shift >= 0) ? (void)0 : fmt::detail::assert_fail("/usr/include/fmt/format.h", 2895, ("")));
    exp_ += shift / bigit_bits;
    shift %= bigit_bits;
    if (shift == 0) return *this;
    bigit carry = 0;
    for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
      bigit c = bigits_[i] >> (bigit_bits - shift);
      bigits_[i] = (bigits_[i] << shift) + carry;
      carry = c;
    }
    if (carry != 0) bigits_.push_back(carry);
    return *this;
  }

  template <typename Int>
  constexpr auto operator*=(Int value) -> bigint& {
    ((value > 0) ? (void)0 : fmt::detail::assert_fail("/usr/include/fmt/format.h", 2911, ("")));
    multiply(uint32_or_64_or_128_t<Int>(value));
    return *this;
  }

  friend constexpr auto compare(const bigint& lhs, const bigint& rhs)
      -> int {
    int num_lhs_bigits = lhs.num_bigits(), num_rhs_bigits = rhs.num_bigits();
    if (num_lhs_bigits != num_rhs_bigits)
      return num_lhs_bigits > num_rhs_bigits ? 1 : -1;
    int i = static_cast<int>(lhs.bigits_.size()) - 1;
    int j = static_cast<int>(rhs.bigits_.size()) - 1;
    int end = i - j;
    if (end < 0) end = 0;
    for (; i >= end; --i, --j) {
      bigit lhs_bigit = lhs[i], rhs_bigit = rhs[j];
      if (lhs_bigit != rhs_bigit) return lhs_bigit > rhs_bigit ? 1 : -1;
    }
    if (i != j) return i > j ? 1 : -1;
    return 0;
  }


  friend constexpr auto add_compare(const bigint& lhs1,
                                          const bigint& lhs2, const bigint& rhs)
      -> int {
    auto minimum = [](int a, int b) { return a < b ? a : b; };
    auto maximum = [](int a, int b) { return a > b ? a : b; };
    int max_lhs_bigits = maximum(lhs1.num_bigits(), lhs2.num_bigits());
    int num_rhs_bigits = rhs.num_bigits();
    if (max_lhs_bigits + 1 < num_rhs_bigits) return -1;
    if (max_lhs_bigits > num_rhs_bigits) return 1;
    auto get_bigit = [](const bigint& n, int i) -> bigit {
      return i >= n.exp_ && i < n.num_bigits() ? n[i - n.exp_] : 0;
    };
    double_bigit borrow = 0;
    int min_exp = minimum(minimum(lhs1.exp_, lhs2.exp_), rhs.exp_);
    for (int i = num_rhs_bigits - 1; i >= min_exp; --i) {
      double_bigit sum =
          static_cast<double_bigit>(get_bigit(lhs1, i)) + get_bigit(lhs2, i);
      bigit rhs_bigit = get_bigit(rhs, i);
      if (sum > rhs_bigit + borrow) return 1;
      borrow = rhs_bigit + borrow - sum;
      if (borrow > 1) return -1;
      borrow <<= bigit_bits;
    }
    return borrow != 0 ? -1 : 0;
  }


  constexpr void assign_pow10(int exp) {
    ((exp >= 0) ? (void)0 : fmt::detail::assert_fail("/usr/include/fmt/format.h", 2962, ("")));
    if (exp == 0) return *this = 1;

    int bitmask = 1;
    while (exp >= bitmask) bitmask <<= 1;
    bitmask >>= 1;


    *this = 5;
    bitmask >>= 1;
    while (bitmask != 0) {
      square();
      if ((exp & bitmask) != 0) *this *= 5;
      bitmask >>= 1;
    }
    *this <<= exp;
  }

  constexpr void square() {
    int num_bigits = static_cast<int>(bigits_.size());
    int num_result_bigits = 2 * num_bigits;
    basic_memory_buffer<bigit, bigits_capacity> n(std::move(bigits_));
    bigits_.resize(to_unsigned(num_result_bigits));
    auto sum = uint128_t();
    for (int bigit_index = 0; bigit_index < num_bigits; ++bigit_index) {


      for (int i = 0, j = bigit_index; j >= 0; ++i, --j) {

        sum += static_cast<double_bigit>(n[i]) * n[j];
      }
      (*this)[bigit_index] = static_cast<bigit>(sum);
      sum >>= num_bits<bigit>();
    }

    for (int bigit_index = num_bigits; bigit_index < num_result_bigits;
         ++bigit_index) {
      for (int j = num_bigits - 1, i = bigit_index - j; i < num_bigits;)
        sum += static_cast<double_bigit>(n[i++]) * n[j--];
      (*this)[bigit_index] = static_cast<bigit>(sum);
      sum >>= num_bits<bigit>();
    }
    remove_leading_zeros();
    exp_ *= 2;
  }



  constexpr void align(const bigint& other) {
    int exp_difference = exp_ - other.exp_;
    if (exp_difference <= 0) return;
    int num_bigits = static_cast<int>(bigits_.size());
    bigits_.resize(to_unsigned(num_bigits + exp_difference));
    for (int i = num_bigits - 1, j = i + exp_difference; i >= 0; --i, --j)
      bigits_[j] = bigits_[i];
    std::uninitialized_fill_n(bigits_.data(), exp_difference, 0u);
    exp_ -= exp_difference;
  }



  constexpr auto divmod_assign(const bigint& divisor) -> int {
    ((this != &divisor) ? (void)0 : fmt::detail::assert_fail("/usr/include/fmt/format.h", 3024, ("")));
    if (compare(*this, divisor) < 0) return 0;
    ((divisor.bigits_[divisor.bigits_.size() - 1u] != 0) ? (void)0 : fmt::detail::assert_fail("/usr/include/fmt/format.h", 3026, ("")));
    align(divisor);
    int quotient = 0;
    do {
      subtract_aligned(divisor);
      ++quotient;
    } while (compare(*this, divisor) >= 0);
    return quotient;
  }
};


enum dragon {
  predecessor_closer = 1,
  fixup = 2,
  fixed = 4,
};




constexpr inline void format_dragon(basic_fp<uint128_t> value,
                                          unsigned flags, int num_digits,
                                          buffer<char>& buf, int& exp10) {
  bigint numerator;
  bigint denominator;

  bigint lower;
  bigint upper_store;
  bigint* upper = nullptr;



  bool is_predecessor_closer = (flags & dragon::predecessor_closer) != 0;
  int shift = is_predecessor_closer ? 2 : 1;
  if (value.e >= 0) {
    numerator = value.f;
    numerator <<= value.e + shift;
    lower = 1;
    lower <<= value.e;
    if (is_predecessor_closer) {
      upper_store = 1;
      upper_store <<= value.e + 1;
      upper = &upper_store;
    }
    denominator.assign_pow10(exp10);
    denominator <<= shift;
  } else if (exp10 < 0) {
    numerator.assign_pow10(-exp10);
    lower.assign(numerator);
    if (is_predecessor_closer) {
      upper_store.assign(numerator);
      upper_store <<= 1;
      upper = &upper_store;
    }
    numerator *= value.f;
    numerator <<= shift;
    denominator = 1;
    denominator <<= shift - value.e;
  } else {
    numerator = value.f;
    numerator <<= shift;
    denominator.assign_pow10(exp10);
    denominator <<= shift - value.e;
    lower = 1;
    if (is_predecessor_closer) {
      upper_store = 1ULL << 1;
      upper = &upper_store;
    }
  }
  int even = static_cast<int>((value.f & 1) == 0);
  if (!upper) upper = &lower;
  bool shortest = num_digits < 0;
  if ((flags & dragon::fixup) != 0) {
    if (add_compare(numerator, *upper, denominator) + even <= 0) {
      --exp10;
      numerator *= 10;
      if (num_digits < 0) {
        lower *= 10;
        if (upper != &lower) *upper *= 10;
      }
    }
    if ((flags & dragon::fixed) != 0) adjust_precision(num_digits, exp10 + 1);
  }

  if (shortest) {

    num_digits = 0;
    char* data = buf.data();
    for (;;) {
      int digit = numerator.divmod_assign(denominator);
      bool low = compare(numerator, lower) - even < 0;

      bool high = add_compare(numerator, *upper, denominator) + even > 0;
      data[num_digits++] = static_cast<char>('0' + digit);
      if (low || high) {
        if (!low) {
          ++data[num_digits - 1];
        } else if (high) {
          int result = add_compare(numerator, numerator, denominator);

          if (result > 0 || (result == 0 && (digit % 2) != 0))
            ++data[num_digits - 1];
        }
        buf.try_resize(to_unsigned(num_digits));
        exp10 -= num_digits - 1;
        return;
      }
      numerator *= 10;
      lower *= 10;
      if (upper != &lower) *upper *= 10;
    }
  }

  exp10 -= num_digits - 1;
  if (num_digits <= 0) {
    denominator *= 10;
    auto digit = add_compare(numerator, numerator, denominator) > 0 ? '1' : '0';
    buf.push_back(digit);
    return;
  }
  buf.try_resize(to_unsigned(num_digits));
  for (int i = 0; i < num_digits - 1; ++i) {
    int digit = numerator.divmod_assign(denominator);
    buf[i] = static_cast<char>('0' + digit);
    numerator *= 10;
  }
  int digit = numerator.divmod_assign(denominator);
  auto result = add_compare(numerator, numerator, denominator);
  if (result > 0 || (result == 0 && (digit % 2) != 0)) {
    if (digit == 9) {
      const auto overflow = '0' + 10;
      buf[num_digits - 1] = overflow;

      for (int i = num_digits - 1; i > 0 && buf[i] == overflow; --i) {
        buf[i] = '0';
        ++buf[i - 1];
      }
      if (buf[0] == overflow) {
        buf[0] = '1';
        if ((flags & dragon::fixed) != 0)
          buf.push_back('0');
        else
          ++exp10;
      }
      return;
    }
    ++digit;
  }
  buf[num_digits - 1] = static_cast<char>('0' + digit);
}


template <typename Float, fmt::enable_if_t<(!is_double_double<Float>::value), int> = 0>
constexpr void format_hexfloat(Float value, int precision,
                                     float_specs specs, buffer<char>& buf) {


  static_assert(!std::is_same<Float, float>::value, "");

  using info = dragonbox::float_info<Float>;


  using carrier_uint = typename info::carrier_uint;

  constexpr auto num_float_significand_bits =
      detail::num_significand_bits<Float>();

  basic_fp<carrier_uint> f(value);
  f.e += num_float_significand_bits;
  if (!has_implicit_bit<Float>()) --f.e;

  constexpr auto num_fraction_bits =
      num_float_significand_bits + (has_implicit_bit<Float>() ? 1 : 0);
  constexpr auto num_xdigits = (num_fraction_bits + 3) / 4;

  constexpr auto leading_shift = ((num_xdigits - 1) * 4);
  const auto leading_mask = carrier_uint(0xF) << leading_shift;
  const auto leading_xdigit =
      static_cast<uint32_t>((f.f & leading_mask) >> leading_shift);
  if (leading_xdigit > 1) f.e -= (32 - countl_zero(leading_xdigit) - 1);

  int print_xdigits = num_xdigits - 1;
  if (precision >= 0 && print_xdigits > precision) {
    const int shift = ((print_xdigits - precision - 1) * 4);
    const auto mask = carrier_uint(0xF) << shift;
    const auto v = static_cast<uint32_t>((f.f & mask) >> shift);

    if (v >= 8) {
      const auto inc = carrier_uint(1) << (shift + 4);
      f.f += inc;
      f.f &= ~(inc - 1);
    }


    if (!has_implicit_bit<Float>()) {
      const auto implicit_bit = carrier_uint(1) << num_float_significand_bits;
      if ((f.f & implicit_bit) == implicit_bit) {
        f.f >>= 4;
        f.e += 4;
      }
    }

    print_xdigits = precision;
  }

  char xdigits[num_bits<carrier_uint>() / 4];
  detail::fill_n(xdigits, sizeof(xdigits), '0');
  format_uint<4>(xdigits, f.f, num_xdigits, specs.upper);


  while (print_xdigits > 0 && xdigits[print_xdigits] == '0') --print_xdigits;

  buf.push_back('0');
  buf.push_back(specs.upper ? 'X' : 'x');
  buf.push_back(xdigits[0]);
  if (specs.showpoint || print_xdigits > 0 || print_xdigits < precision)
    buf.push_back('.');
  buf.append(xdigits + 1, xdigits + 1 + print_xdigits);
  for (; print_xdigits < precision; ++print_xdigits) buf.push_back('0');

  buf.push_back(specs.upper ? 'P' : 'p');

  uint32_t abs_e;
  if (f.e < 0) {
    buf.push_back('-');
    abs_e = static_cast<uint32_t>(-f.e);
  } else {
    buf.push_back('+');
    abs_e = static_cast<uint32_t>(f.e);
  }
  format_decimal<char>(appender(buf), abs_e, detail::count_digits(abs_e));
}

template <typename Float, fmt::enable_if_t<(is_double_double<Float>::value), int> = 0>
constexpr void format_hexfloat(Float value, int precision,
                                     float_specs specs, buffer<char>& buf) {
  format_hexfloat(static_cast<double>(value), precision, specs, buf);
}

constexpr auto fractional_part_rounding_thresholds(int index) -> uint32_t {






  return U"\x9999999a\x828f5c29\x80418938\x80068db9\x8000a7c6\x800010c7"
         U"\x800001ae\x8000002b"[index];
}

template <typename Float>
constexpr auto format_float(Float value, int precision, float_specs specs,
                                  buffer<char>& buf) -> int {

  static_assert(!std::is_same<Float, float>::value, "");
  ((value >= 0) ? (void)0 : fmt::detail::assert_fail("/usr/include/fmt/format.h", 3282, ("value is negative")));
  auto converted_value = convert_float(value);

  const bool fixed = specs.format == float_format::fixed;
  if (value <= 0) {
    if (precision <= 0 || !fixed) {
      buf.push_back('0');
      return 0;
    }
    buf.try_resize(to_unsigned(precision));
    fill_n(buf.data(), precision, '0');
    return -precision;
  }

  int exp = 0;
  bool use_dragon = true;
  unsigned dragon_flags = 0;
  if (!is_fast_float<Float>() || is_constant_evaluated()) {
    const auto inv_log2_10 = 0.3010299956639812;
    using info = dragonbox::float_info<decltype(converted_value)>;
    const auto f = basic_fp<typename info::carrier_uint>(converted_value);




    auto e = (f.e + count_digits<1>(f.f) - 1) * inv_log2_10 - 1e-10;
    exp = static_cast<int>(e);
    if (e > exp) ++exp;
    dragon_flags = dragon::fixup;
  } else if (precision < 0) {

    if (specs.binary32) {
      auto dec = dragonbox::to_decimal(static_cast<float>(value));
      write<char>(buffer_appender<char>(buf), dec.significand);
      return dec.exponent;
    }
    auto dec = dragonbox::to_decimal(static_cast<double>(value));
    write<char>(buffer_appender<char>(buf), dec.significand);
    return dec.exponent;
  } else {

    using info = dragonbox::float_info<double>;
    auto br = bit_cast<uint64_t>(static_cast<double>(value));

    const uint64_t significand_mask =
        (static_cast<uint64_t>(1) << num_significand_bits<double>()) - 1;
    uint64_t significand = (br & significand_mask);
    int exponent = static_cast<int>((br & exponent_mask<double>()) >>
                                    num_significand_bits<double>());

    if (exponent != 0) {
      exponent -= exponent_bias<double>() + num_significand_bits<double>();
      significand |=
          (static_cast<uint64_t>(1) << num_significand_bits<double>());
      significand <<= 1;
    } else {

      ((significand != 0) ? (void)0 : fmt::detail::assert_fail("/usr/include/fmt/format.h", 3339, ("zeros should not appear here")));
      int shift = countl_zero(significand);
      ((shift >= num_bits<uint64_t>() - num_significand_bits<double>()) ? (void)0 : fmt::detail::assert_fail("/usr/include/fmt/format.h", 3342, ("")));

      shift -= (num_bits<uint64_t>() - num_significand_bits<double>() - 2);
      exponent = (std::numeric_limits<double>::min_exponent -
                  num_significand_bits<double>()) -
                 shift;
      significand <<= shift;
    }



    const int k = info::kappa - dragonbox::floor_log10_pow2(exponent);
    exp = -k;
    const int beta = exponent + dragonbox::floor_log2_pow10(k);
    uint64_t first_segment;
    bool has_more_segments;
    int digits_in_the_first_segment;
    {
      const auto r = dragonbox::umul192_upper128(
          significand << beta, dragonbox::get_cached_power(k));
      first_segment = r.high();
      has_more_segments = r.low() != 0;


      if (first_segment >= 1000000000000000000ULL) {
        digits_in_the_first_segment = 19;
      } else {


        digits_in_the_first_segment = 18;
        first_segment *= 10;
      }
    }


    if (fixed) adjust_precision(precision, exp + digits_in_the_first_segment);



    if (digits_in_the_first_segment > precision) {
      use_dragon = false;

      if (precision <= 0) {
        exp += digits_in_the_first_segment;

        if (precision < 0) {

          buf.try_resize(0);
        } else {

          buf.try_resize(1);
          if ((first_segment | static_cast<uint64_t>(has_more_segments)) >
              5000000000000000000ULL) {
            buf[0] = '1';
          } else {
            buf[0] = '0';
          }
        }
      }
      else {
        exp += digits_in_the_first_segment - precision;
# 3410 "/usr/include/fmt/format.h" 3 4
        const uint32_t first_subsegment = static_cast<uint32_t>(
            dragonbox::umul128_upper64(first_segment, 7922816251426433760ULL) >>
            32);
        const uint64_t second_third_subsegments =
            first_segment - first_subsegment * 10000000000ULL;

        uint64_t prod;
        uint32_t digits;
        bool should_round_up;
        int number_of_digits_to_print = precision > 9 ? 9 : precision;


        auto print_subsegment = [&](uint32_t subsegment, char* buffer) {
          int number_of_digits_printed = 0;


          if ((number_of_digits_to_print & 1) != 0) {





            prod = ((subsegment * static_cast<uint64_t>(720575941)) >> 24) + 1;
            digits = static_cast<uint32_t>(prod >> 32);
            *buffer = static_cast<char>('0' + digits);
            number_of_digits_printed++;
          }


          else {





            prod = ((subsegment * static_cast<uint64_t>(450359963)) >> 20) + 1;
            digits = static_cast<uint32_t>(prod >> 32);
            copy2(buffer, digits2(digits));
            number_of_digits_printed += 2;
          }


          while (number_of_digits_printed < number_of_digits_to_print) {
            prod = static_cast<uint32_t>(prod) * static_cast<uint64_t>(100);
            digits = static_cast<uint32_t>(prod >> 32);
            copy2(buffer + number_of_digits_printed, digits2(digits));
            number_of_digits_printed += 2;
          }
        };


        print_subsegment(first_subsegment, buf.data());



        if (precision <= 9) {
# 3479 "/usr/include/fmt/format.h" 3 4
          if (precision < 9) {
            uint32_t fractional_part = static_cast<uint32_t>(prod);
            should_round_up =
                fractional_part >= fractional_part_rounding_thresholds(
                                       8 - number_of_digits_to_print) ||
                ((fractional_part >> 31) &
                 ((digits & 1) | (second_third_subsegments != 0) |
                  has_more_segments)) != 0;
          }





          else {
            should_round_up = second_third_subsegments > 5000000000ULL ||
                              (second_third_subsegments == 5000000000ULL &&
                               ((digits & 1) != 0 || has_more_segments));
          }
        }

        else {




          const uint32_t second_subsegment =
              static_cast<uint32_t>(dragonbox::umul128_upper64(
                  second_third_subsegments, 1844674407370955162ULL));
          const uint32_t third_subsegment =
              static_cast<uint32_t>(second_third_subsegments) -
              second_subsegment * 10;

          number_of_digits_to_print = precision - 9;
          print_subsegment(second_subsegment, buf.data() + 9);


          if (precision < 18) {



            uint32_t fractional_part = static_cast<uint32_t>(prod);
            should_round_up =
                fractional_part >= fractional_part_rounding_thresholds(
                                       8 - number_of_digits_to_print) ||
                ((fractional_part >> 31) &
                 ((digits & 1) | (third_subsegment != 0) |
                  has_more_segments)) != 0;
          }

          else {



            should_round_up = third_subsegment > 5 ||
                              (third_subsegment == 5 &&
                               ((digits & 1) != 0 || has_more_segments));
          }
        }


        if (should_round_up) {
          ++buf[precision - 1];
          for (int i = precision - 1; i > 0 && buf[i] > '9'; --i) {
            buf[i] = '0';
            ++buf[i - 1];
          }
          if (buf[0] > '9') {
            buf[0] = '1';
            if (fixed)
              buf[precision++] = '0';
            else
              ++exp;
          }
        }
        buf.try_resize(to_unsigned(precision));
      }
    }
    else {

      exp += digits_in_the_first_segment - 1;
    }
  }
  if (use_dragon) {
    auto f = basic_fp<uint128_t>();
    bool is_predecessor_closer = specs.binary32
                                     ? f.assign(static_cast<float>(value))
                                     : f.assign(converted_value);
    if (is_predecessor_closer) dragon_flags |= dragon::predecessor_closer;
    if (fixed) dragon_flags |= dragon::fixed;


    const int max_double_digits = 767;
    if (precision > max_double_digits) precision = max_double_digits;
    format_dragon(f, dragon_flags, precision, buf, exp);
  }
  if (!fixed && !specs.showpoint) {

    auto num_digits = buf.size();
    while (num_digits > 0 && buf[num_digits - 1] == '0') {
      --num_digits;
      ++exp;
    }
    buf.try_resize(num_digits);
  }
  return exp;
}
template <typename Char, typename OutputIt, typename T>
constexpr auto write_float(OutputIt out, T value,
                                 format_specs<Char> specs, locale_ref loc)
    -> OutputIt {
  float_specs fspecs = parse_float_type_spec(specs);
  fspecs.sign = specs.sign;
  if (detail::signbit(value)) {
    fspecs.sign = sign::minus;
    value = -value;
  } else if (fspecs.sign == sign::minus) {
    fspecs.sign = sign::none;
  }

  if (!detail::isfinite(value))
    return write_nonfinite(out, detail::isnan(value), specs, fspecs);

  if (specs.align == align::numeric && fspecs.sign) {
    auto it = reserve(out, 1);
    *it++ = detail::sign<Char>(fspecs.sign);
    out = base_iterator(out, it);
    fspecs.sign = sign::none;
    if (specs.width != 0) --specs.width;
  }

  memory_buffer buffer;
  if (fspecs.format == float_format::hex) {
    if (fspecs.sign) buffer.push_back(detail::sign<char>(fspecs.sign));
    format_hexfloat(convert_float(value), specs.precision, fspecs, buffer);
    return write_bytes<align::right>(out, {buffer.data(), buffer.size()},
                                     specs);
  }
  int precision = specs.precision >= 0 || specs.type == presentation_type::none
                      ? specs.precision
                      : 6;
  if (fspecs.format == float_format::exp) {
    if (precision == max_value<int>())
      throw_format_error("number is too big");
    else
      ++precision;
  } else if (fspecs.format != float_format::fixed && precision == 0) {
    precision = 1;
  }
  if (const_check(std::is_same<T, float>())) fspecs.binary32 = true;
  int exp = format_float(convert_float(value), precision, fspecs, buffer);
  fspecs.precision = precision;
  auto f = big_decimal_fp{buffer.data(), static_cast<int>(buffer.size()), exp};
  return write_float(out, f, specs, fspecs, loc);
}

template <typename Char, typename OutputIt, typename T,
          fmt::enable_if_t<(is_floating_point<T>::value), int> = 0>
constexpr auto write(OutputIt out, T value, format_specs<Char> specs,
                           locale_ref loc = {}) -> OutputIt {
  if (const_check(!is_supported_floating_point(value))) return out;
  return specs.localized && write_loc(out, value, specs, loc)
             ? out
             : write_float(out, value, specs, loc);
}

template <typename Char, typename OutputIt, typename T,
          fmt::enable_if_t<(is_fast_float<T>::value), int> = 0>
constexpr auto write(OutputIt out, T value) -> OutputIt {
  if (is_constant_evaluated()) return write(out, value, format_specs<Char>());
  if (const_check(!is_supported_floating_point(value))) return out;

  auto fspecs = float_specs();
  if (detail::signbit(value)) {
    fspecs.sign = sign::minus;
    value = -value;
  }

  constexpr auto specs = format_specs<Char>();
  using floaty = conditional_t<std::is_same<T, long double>::value, double, T>;
  using floaty_uint = typename dragonbox::float_info<floaty>::carrier_uint;
  floaty_uint mask = exponent_mask<floaty>();
  if ((bit_cast<floaty_uint>(value) & mask) == mask)
    return write_nonfinite(out, std::isnan(value), specs, fspecs);

  auto dec = dragonbox::to_decimal(static_cast<floaty>(value));
  return write_float(out, dec, specs, fspecs, {});
}

template <typename Char, typename OutputIt, typename T,
          fmt::enable_if_t<(is_floating_point<T>::value && !is_fast_float<T>::value), int> = 0>

inline auto write(OutputIt out, T value) -> OutputIt {
  return write(out, value, format_specs<Char>());
}

template <typename Char, typename OutputIt>
auto write(OutputIt out, monostate, format_specs<Char> = {}, locale_ref = {})
    -> OutputIt {
  ((false) ? (void)0 : fmt::detail::assert_fail("/usr/include/fmt/format.h", 3678, ("")));
  return out;
}

template <typename Char, typename OutputIt>
constexpr auto write(OutputIt out, basic_string_view<Char> value)
    -> OutputIt {
  auto it = reserve(out, value.size());
  it = copy_str_noinline<Char>(value.begin(), value.end(), it);
  return base_iterator(out, it);
}

template <typename Char, typename OutputIt, typename T,
          fmt::enable_if_t<(is_string<T>::value), int> = 0>
constexpr auto write(OutputIt out, const T& value) -> OutputIt {
  return write<Char>(out, to_string_view(value));
}


template <
    typename Char, typename OutputIt, typename T,
    bool check =
        std::is_enum<T>::value && !std::is_same<T, Char>::value &&
        mapped_type_constant<T, basic_format_context<OutputIt, Char>>::value !=
            type::custom_type,
    fmt::enable_if_t<(check), int> = 0>
constexpr auto write(OutputIt out, T value) -> OutputIt {
  return write<Char>(out, static_cast<underlying_t<T>>(value));
}

template <typename Char, typename OutputIt, typename T,
          fmt::enable_if_t<(std::is_same<T, bool>::value), int> = 0>
constexpr auto write(OutputIt out, T value,
                         const format_specs<Char>& specs = {}, locale_ref = {})
    -> OutputIt {
  return specs.type != presentation_type::none &&
                 specs.type != presentation_type::string
             ? write(out, value ? 1 : 0, specs, {})
             : write_bytes(out, value ? "true" : "false", specs);
}

template <typename Char, typename OutputIt>
constexpr auto write(OutputIt out, Char value) -> OutputIt {
  auto it = reserve(out, 1);
  *it++ = value;
  return base_iterator(out, it);
}

template <typename Char, typename OutputIt>
constexpr auto write(OutputIt out, const Char* value)
    -> OutputIt {
  if (value) return write(out, basic_string_view<Char>(value));
  throw_format_error("string pointer is null");
  return out;
}

template <typename Char, typename OutputIt, typename T,
          fmt::enable_if_t<(std::is_same<T, void>::value), int> = 0>
auto write(OutputIt out, const T* value, const format_specs<Char>& specs = {},
           locale_ref = {}) -> OutputIt {
  return write_ptr<Char>(out, bit_cast<uintptr_t>(value), &specs);
}


template <typename Char, typename OutputIt, typename T,
          typename Context = basic_format_context<OutputIt, Char>>
constexpr auto write(OutputIt out, const T& value) -> enable_if_t<
    std::is_class<T>::value && !is_string<T>::value &&
        !is_floating_point<T>::value && !std::is_same<T, Char>::value &&
        !std::is_same<T, remove_cvref_t<decltype(arg_mapper<Context>().map(
                             value))>>::value,
    OutputIt> {
  return write<Char>(out, arg_mapper<Context>().map(value));
}

template <typename Char, typename OutputIt, typename T,
          typename Context = basic_format_context<OutputIt, Char>>
constexpr auto write(OutputIt out, const T& value)
    -> enable_if_t<mapped_type_constant<T, Context>::value == type::custom_type,
                   OutputIt> {
  auto formatter = typename Context::template formatter_type<T>();
  auto parse_ctx = typename Context::parse_context_type({});
  formatter.parse(parse_ctx);
  auto ctx = Context(out, {}, {});
  return formatter.format(value, ctx);
}



template <typename Char> struct default_arg_formatter {
  using iterator = buffer_appender<Char>;
  using context = buffer_context<Char>;

  iterator out;
  basic_format_args<context> args;
  locale_ref loc;

  template <typename T> auto operator()(T value) -> iterator {
    return write<Char>(out, value);
  }
  auto operator()(typename basic_format_arg<context>::handle h) -> iterator {
    basic_format_parse_context<Char> parse_ctx({});
    context format_ctx(out, args, loc);
    h.format(parse_ctx, format_ctx);
    return format_ctx.out();
  }
};

template <typename Char> struct arg_formatter {
  using iterator = buffer_appender<Char>;
  using context = buffer_context<Char>;

  iterator out;
  const format_specs<Char>& specs;
  locale_ref locale;

  template <typename T>
  constexpr inline __attribute__((always_inline)) auto operator()(T value) -> iterator {
    return detail::write(out, value, specs, locale);
  }
  auto operator()(typename basic_format_arg<context>::handle) -> iterator {


    return out;
  }
};

struct width_checker {
  template <typename T, fmt::enable_if_t<(is_integer<T>::value), int> = 0>
  constexpr auto operator()(T value) -> unsigned long long {
    if (is_negative(value)) throw_format_error("negative width");
    return static_cast<unsigned long long>(value);
  }

  template <typename T, fmt::enable_if_t<(!is_integer<T>::value), int> = 0>
  constexpr auto operator()(T) -> unsigned long long {
    throw_format_error("width is not integer");
    return 0;
  }
};

struct precision_checker {
  template <typename T, fmt::enable_if_t<(is_integer<T>::value), int> = 0>
  constexpr auto operator()(T value) -> unsigned long long {
    if (is_negative(value)) throw_format_error("negative precision");
    return static_cast<unsigned long long>(value);
  }

  template <typename T, fmt::enable_if_t<(!is_integer<T>::value), int> = 0>
  constexpr auto operator()(T) -> unsigned long long {
    throw_format_error("precision is not integer");
    return 0;
  }
};

template <typename Handler, typename FormatArg>
constexpr auto get_dynamic_spec(FormatArg arg) -> int {
  unsigned long long value = visit_format_arg(Handler(), arg);
  if (value > to_unsigned(max_value<int>()))
    throw_format_error("number is too big");
  return static_cast<int>(value);
}

template <typename Context, typename ID>
constexpr auto get_arg(Context& ctx, ID id) -> decltype(ctx.arg(id)) {
  auto arg = ctx.arg(id);
  if (!arg) ctx.on_error("argument not found");
  return arg;
}

template <typename Handler, typename Context>
constexpr void handle_dynamic_spec(int& value,
                                       arg_ref<typename Context::char_type> ref,
                                       Context& ctx) {
  switch (ref.kind) {
  case arg_id_kind::none:
    break;
  case arg_id_kind::index:
    value = detail::get_dynamic_spec<Handler>(get_arg(ctx, ref.val.index));
    break;
  case arg_id_kind::name:
    value = detail::get_dynamic_spec<Handler>(get_arg(ctx, ref.val.name));
    break;
  }
}
# 3892 "/usr/include/fmt/format.h" 3 4
template <typename Char> struct udl_arg {
  const Char* str;

  template <typename T> auto operator=(T&& value) const -> named_arg<Char, T> {
    return {str, std::forward<T>(value)};
  }
};



template <typename Locale, typename Char>
auto vformat(const Locale& loc, basic_string_view<Char> fmt,
             basic_format_args<buffer_context<type_identity_t<Char>>> args)
    -> std::basic_string<Char> {
  auto buf = basic_memory_buffer<Char>();
  detail::vformat_to(buf, fmt, args, detail::locale_ref(loc));
  return {buf.data(), buf.size()};
}

using format_func = void (*)(detail::buffer<char>&, int, const char*);

__attribute__((visibility("default"))) void format_error_code(buffer<char>& out, int error_code,
                               string_view message) noexcept;

__attribute__((visibility("default"))) void report_error(format_func func, int error_code,
                          const char* message) noexcept;
}

__attribute__((visibility("default"))) auto vsystem_error(int error_code, string_view format_str,
                           format_args args) -> std::system_error;
# 3940 "/usr/include/fmt/format.h" 3 4
template <typename... T>
auto system_error(int error_code, format_string<T...> fmt, T&&... args)
    -> std::system_error {
  return vsystem_error(error_code, fmt, fmt::make_format_args(args...));
}
# 3962 "/usr/include/fmt/format.h" 3 4
__attribute__((visibility("default"))) void format_system_error(detail::buffer<char>& out, int error_code,
                                 const char* message) noexcept;



__attribute__((visibility("default"))) void report_system_error(int error_code, const char* message) noexcept;


class format_int {
 private:


  enum { buffer_size = std::numeric_limits<unsigned long long>::digits10 + 3 };
  mutable char buffer_[buffer_size];
  char* str_;

  template <typename UInt> auto format_unsigned(UInt value) -> char* {
    auto n = static_cast<detail::uint32_or_64_or_128_t<UInt>>(value);
    return detail::format_decimal(buffer_, n, buffer_size - 1).begin;
  }

  template <typename Int> auto format_signed(Int value) -> char* {
    auto abs_value = static_cast<detail::uint32_or_64_or_128_t<Int>>(value);
    bool negative = value < 0;
    if (negative) abs_value = 0 - abs_value;
    auto begin = format_unsigned(abs_value);
    if (negative) *--begin = '-';
    return begin;
  }

 public:
  explicit format_int(int value) : str_(format_signed(value)) {}
  explicit format_int(long value) : str_(format_signed(value)) {}
  explicit format_int(long long value) : str_(format_signed(value)) {}
  explicit format_int(unsigned value) : str_(format_unsigned(value)) {}
  explicit format_int(unsigned long value) : str_(format_unsigned(value)) {}
  explicit format_int(unsigned long long value)
      : str_(format_unsigned(value)) {}


  auto size() const -> size_t {
    return detail::to_unsigned(buffer_ - str_ + buffer_size - 1);
  }





  auto data() const -> const char* { return str_; }





  auto c_str() const -> const char* {
    buffer_[buffer_size - 1] = '\0';
    return str_;
  }






  auto str() const -> std::string { return std::string(str_, size()); }
};

template <typename T, typename Char>
struct formatter<T, Char, enable_if_t<detail::has_format_as<T>::value>>
    : formatter<detail::format_as_t<T>, Char> {
  template <typename FormatContext>
  auto format(const T& value, FormatContext& ctx) const -> decltype(ctx.out()) {
    using base = formatter<detail::format_as_t<T>, Char>;
    return base::format(format_as(value), ctx);
  }
};





template <typename Char> struct formatter<signed char, Char> : formatter<int, Char> {};
template <typename Char> struct formatter<unsigned char, Char> : formatter<unsigned, Char> {};
template <typename Char> struct formatter<short, Char> : formatter<int, Char> {};
template <typename Char> struct formatter<unsigned short, Char> : formatter<unsigned, Char> {};
template <typename Char> struct formatter<long, Char> : formatter<detail::long_type, Char> {};
template <typename Char> struct formatter<unsigned long, Char> : formatter<detail::ulong_type, Char> {};
template <typename Char> struct formatter<Char*, Char> : formatter<const Char*, Char> {};
template <typename Char> struct formatter<std::basic_string<Char>, Char> : formatter<basic_string_view<Char>, Char> {};
template <typename Char> struct formatter<std::nullptr_t, Char> : formatter<const void*, Char> {};
template <typename Char> struct formatter<detail::std_string_view<Char>, Char> : formatter<basic_string_view<Char>, Char> {};
template <typename Char> struct formatter<void*, Char> : formatter<const void*, Char> {};

template <typename Char, size_t N>
struct formatter<Char[N], Char> : formatter<basic_string_view<Char>, Char> {};
# 4067 "/usr/include/fmt/format.h" 3 4
template <typename T> auto ptr(T p) -> const void* {
  static_assert(std::is_pointer<T>::value, "");
  return detail::bit_cast<const void*>(p);
}
template <typename T, typename Deleter>
auto ptr(const std::unique_ptr<T, Deleter>& p) -> const void* {
  return p.get();
}
template <typename T> auto ptr(const std::shared_ptr<T>& p) -> const void* {
  return p.get();
}
# 4089 "/usr/include/fmt/format.h" 3 4
template <typename Enum>
constexpr auto underlying(Enum e) noexcept -> underlying_t<Enum> {
  return static_cast<underlying_t<Enum>>(e);
}

namespace enums {
template <typename Enum, fmt::enable_if_t<(std::is_enum<Enum>::value), int> = 0>
constexpr auto format_as(Enum e) noexcept -> underlying_t<Enum> {
  return static_cast<underlying_t<Enum>>(e);
}
}

class bytes {
 private:
  string_view data_;
  friend struct formatter<bytes>;

 public:
  explicit bytes(string_view data) : data_(data) {}
};

template <> struct formatter<bytes> {
 private:
  detail::dynamic_format_specs<> specs_;

 public:
  template <typename ParseContext>
  constexpr auto parse(ParseContext& ctx) -> const char* {
    return parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx,
                              detail::type::string_type);
  }

  template <typename FormatContext>
  auto format(bytes b, FormatContext& ctx) -> decltype(ctx.out()) {
    detail::handle_dynamic_spec<detail::width_checker>(specs_.width,
                                                       specs_.width_ref, ctx);
    detail::handle_dynamic_spec<detail::precision_checker>(
        specs_.precision, specs_.precision_ref, ctx);
    return detail::write_bytes(ctx.out(), b.data_, specs_);
  }
};


template <typename T> struct group_digits_view {
  T value;
};
# 4147 "/usr/include/fmt/format.h" 3 4
template <typename T> auto group_digits(T value) -> group_digits_view<T> {
  return {value};
}

template <typename T> struct formatter<group_digits_view<T>> : formatter<T> {
 private:
  detail::dynamic_format_specs<> specs_;

 public:
  template <typename ParseContext>
  constexpr auto parse(ParseContext& ctx) -> const char* {
    return parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx,
                              detail::type::int_type);
  }

  template <typename FormatContext>
  auto format(group_digits_view<T> t, FormatContext& ctx)
      -> decltype(ctx.out()) {
    detail::handle_dynamic_spec<detail::width_checker>(specs_.width,
                                                       specs_.width_ref, ctx);
    detail::handle_dynamic_spec<detail::precision_checker>(
        specs_.precision, specs_.precision_ref, ctx);
    return detail::write_int(
        ctx.out(), static_cast<detail::uint64_or_128_t<T>>(t.value), 0, specs_,
        detail::digit_grouping<char>("\3", ","));
  }
};

template <typename T> struct nested_view {
  const formatter<T>* fmt;
  const T* value;
};

template <typename T> struct formatter<nested_view<T>> {
  constexpr auto parse(format_parse_context& ctx) -> const char* {
    return ctx.begin();
  }
  auto format(nested_view<T> view, format_context& ctx) const
      -> decltype(ctx.out()) {
    return view.fmt->format(*view.value, ctx);
  }
};

template <typename T> struct nested_formatter {
 private:
  int width_;
  detail::fill_t<char> fill_;
  align_t align_ : 4;
  formatter<T> formatter_;

 public:
  constexpr nested_formatter() : width_(0), align_(align_t::none) {}

  constexpr auto parse(format_parse_context& ctx) -> const char* {
    auto specs = detail::dynamic_format_specs<char>();
    auto it = parse_format_specs(ctx.begin(), ctx.end(), specs, ctx,
                                 detail::type::none_type);
    width_ = specs.width;
    fill_ = specs.fill;
    align_ = specs.align;
    ctx.advance_to(it);
    return formatter_.parse(ctx);
  }

  template <typename F>
  auto write_padded(format_context& ctx, F write) const -> decltype(ctx.out()) {
    if (width_ == 0) return write(ctx.out());
    auto buf = memory_buffer();
    write(std::back_inserter(buf));
    auto specs = format_specs<>();
    specs.width = width_;
    specs.fill = fill_;
    specs.align = align_;
    return detail::write(ctx.out(), string_view(buf.data(), buf.size()), specs);
  }

  auto nested(const T& value) const -> nested_view<T> {
    return nested_view<T>{&formatter_, &value};
  }
};


template <typename It, typename Sentinel, typename Char = char>
struct join_view : detail::view {
  It begin;
  Sentinel end;
  basic_string_view<Char> sep;

  join_view(It b, Sentinel e, basic_string_view<Char> s)
      : begin(b), end(e), sep(s) {}
};

template <typename It, typename Sentinel, typename Char>
struct formatter<join_view<It, Sentinel, Char>, Char> {
 private:
  using value_type =

      std::iter_value_t<It>;



  formatter<remove_cvref_t<value_type>, Char> value_formatter_;

 public:
  template <typename ParseContext>
  constexpr auto parse(ParseContext& ctx) -> const Char* {
    return value_formatter_.parse(ctx);
  }

  template <typename FormatContext>
  auto format(const join_view<It, Sentinel, Char>& value,
              FormatContext& ctx) const -> decltype(ctx.out()) {
    auto it = value.begin;
    auto out = ctx.out();
    if (it != value.end) {
      out = value_formatter_.format(*it, ctx);
      ++it;
      while (it != value.end) {
        out = detail::copy_str<Char>(value.sep.begin(), value.sep.end(), out);
        ctx.advance_to(out);
        out = value_formatter_.format(*it, ctx);
        ++it;
      }
    }
    return out;
  }
};





template <typename It, typename Sentinel>
auto join(It begin, Sentinel end, string_view sep) -> join_view<It, Sentinel> {
  return {begin, end, sep};
}
# 4300 "/usr/include/fmt/format.h" 3 4
template <typename Range>
auto join(Range&& range, string_view sep)
    -> join_view<detail::iterator_t<Range>, detail::sentinel_t<Range>> {
  return join(std::begin(range), std::end(range), sep);
}
# 4317 "/usr/include/fmt/format.h" 3 4
template <typename T, fmt::enable_if_t<(!std::is_integral<T>::value && !detail::has_format_as<T>::value), int> = 0>

inline auto to_string(const T& value) -> std::string {
  auto buffer = memory_buffer();
  detail::write<char>(appender(buffer), value);
  return {buffer.data(), buffer.size()};
}

template <typename T, fmt::enable_if_t<(std::is_integral<T>::value), int> = 0>
[[nodiscard]] inline auto to_string(T value) -> std::string {


  constexpr int max_size = detail::digits10<T>() + 2;
  char buffer[max_size > 5 ? static_cast<unsigned>(max_size) : 5];
  char* begin = buffer;
  return std::string(begin, detail::write<char>(begin, value));
}

template <typename Char, size_t SIZE>
[[nodiscard]] auto to_string(const basic_memory_buffer<Char, SIZE>& buf)
    -> std::basic_string<Char> {
  auto size = buf.size();
  detail::assume(size < std::basic_string<Char>().max_size());
  return std::basic_string<Char>(buf.data(), size);
}

template <typename T, fmt::enable_if_t<(!std::is_integral<T>::value && detail::has_format_as<T>::value), int> = 0>

inline auto to_string(const T& value) -> std::string {
  return to_string(format_as(value));
}



namespace detail {

template <typename Char>
void vformat_to(buffer<Char>& buf, basic_string_view<Char> fmt,
                typename vformat_args<Char>::type args, locale_ref loc) {
  auto out = buffer_appender<Char>(buf);
  if (fmt.size() == 2 && equal2(fmt.data(), "{}")) {
    auto arg = args.get(0);
    if (!arg) throw_format_error("argument not found");
    visit_format_arg(default_arg_formatter<Char>{out, args, loc}, arg);
    return;
  }

  struct format_handler : error_handler {
    basic_format_parse_context<Char> parse_context;
    buffer_context<Char> context;

    format_handler(buffer_appender<Char> p_out, basic_string_view<Char> str,
                   basic_format_args<buffer_context<Char>> p_args,
                   locale_ref p_loc)
        : parse_context(str), context(p_out, p_args, p_loc) {}

    void on_text(const Char* begin, const Char* end) {
      auto text = basic_string_view<Char>(begin, to_unsigned(end - begin));
      context.advance_to(write<Char>(context.out(), text));
    }

    constexpr auto on_arg_id() -> int {
      return parse_context.next_arg_id();
    }
    constexpr auto on_arg_id(int id) -> int {
      return parse_context.check_arg_id(id), id;
    }
    constexpr auto on_arg_id(basic_string_view<Char> id) -> int {
      int arg_id = context.arg_id(id);
      if (arg_id < 0) throw_format_error("argument not found");
      return arg_id;
    }

    inline __attribute__((always_inline)) void on_replacement_field(int id, const Char*) {
      auto arg = get_arg(context, id);
      context.advance_to(visit_format_arg(
          default_arg_formatter<Char>{context.out(), context.args(),
                                      context.locale()},
          arg));
    }

    auto on_format_specs(int id, const Char* begin, const Char* end)
        -> const Char* {
      auto arg = get_arg(context, id);

      if (arg.format_custom(begin, parse_context, context))
        return parse_context.begin();
      auto specs = detail::dynamic_format_specs<Char>();
      begin = parse_format_specs(begin, end, specs, parse_context, arg.type());
      detail::handle_dynamic_spec<detail::width_checker>(
          specs.width, specs.width_ref, context);
      detail::handle_dynamic_spec<detail::precision_checker>(
          specs.precision, specs.precision_ref, context);
      if (begin == end || *begin != '}')
        throw_format_error("missing '}' in format string");
      auto f = arg_formatter<Char>{context.out(), specs, context.locale()};
      context.advance_to(visit_format_arg(f, arg));
      return begin;
    }
  };
  detail::parse_format_string<false>(fmt, format_handler(out, fmt, args, loc));
}




extern template __attribute__((visibility("default"))) void vformat_to(buffer<char>&, string_view,
                                        typename vformat_args<>::type,
                                        locale_ref);
extern template __attribute__((visibility("default"))) auto thousands_sep_impl<char>(locale_ref)
    -> thousands_sep_result<char>;
extern template __attribute__((visibility("default"))) auto thousands_sep_impl<wchar_t>(locale_ref)
    -> thousands_sep_result<wchar_t>;
extern template __attribute__((visibility("default"))) auto decimal_point_impl(locale_ref) -> char;
extern template __attribute__((visibility("default"))) auto decimal_point_impl(locale_ref) -> wchar_t;


}


inline namespace literals {
# 4454 "/usr/include/fmt/format.h" 3 4
constexpr auto operator""_a(const char* s, size_t) -> detail::udl_arg<char> {
  return {s};
}

}


template <typename Locale, fmt::enable_if_t<(detail::is_locale<Locale>::value), int> = 0>
inline auto vformat(const Locale& loc, string_view fmt, format_args args)
    -> std::string {
  return detail::vformat(loc, fmt, args);
}

template <typename Locale, typename... T,
          fmt::enable_if_t<(detail::is_locale<Locale>::value), int> = 0>
inline auto format(const Locale& loc, format_string<T...> fmt, T&&... args)
    -> std::string {
  return fmt::vformat(loc, string_view(fmt), fmt::make_format_args(args...));
}

template <typename OutputIt, typename Locale,
          fmt::enable_if_t<(detail::is_output_iterator<OutputIt, char>::value&& detail::is_locale<Locale>::value), int> = 0>

auto vformat_to(OutputIt out, const Locale& loc, string_view fmt,
                format_args args) -> OutputIt {
  using detail::get_buffer;
  auto&& buf = get_buffer<char>(out);
  detail::vformat_to(buf, fmt, args, detail::locale_ref(loc));
  return detail::get_iterator(buf, out);
}

template <typename OutputIt, typename Locale, typename... T,
          fmt::enable_if_t<(detail::is_output_iterator<OutputIt, char>::value&& detail::is_locale<Locale>::value), int> = 0>

inline __attribute__((always_inline)) auto format_to(OutputIt out, const Locale& loc,
                          format_string<T...> fmt, T&&... args) -> OutputIt {
  return vformat_to(out, loc, fmt, fmt::make_format_args(args...));
}

template <typename Locale, typename... T,
          fmt::enable_if_t<(detail::is_locale<Locale>::value), int> = 0>
[[nodiscard]] inline __attribute__((always_inline)) auto formatted_size(const Locale& loc,
                                             format_string<T...> fmt,
                                             T&&... args) -> size_t {
  auto buf = detail::counting_buffer<>();
  detail::vformat_to<char>(buf, fmt, fmt::make_format_args(args...),
                           detail::locale_ref(loc));
  return buf.count();
}



template <typename T, typename Char>
template <typename FormatContext>
constexpr inline __attribute__((always_inline)) auto
formatter<T, Char,
          enable_if_t<detail::type_constant<T, Char>::value !=
                      detail::type::custom_type>>::format(const T& val,
                                                          FormatContext& ctx)
    const -> decltype(ctx.out()) {
  if (specs_.width_ref.kind == detail::arg_id_kind::none &&
      specs_.precision_ref.kind == detail::arg_id_kind::none) {
    return detail::write<Char>(ctx.out(), val, specs_, ctx.locale());
  }
  auto specs = specs_;
  detail::handle_dynamic_spec<detail::width_checker>(specs.width,
                                                     specs.width_ref, ctx);
  detail::handle_dynamic_spec<detail::precision_checker>(
      specs.precision, specs.precision_ref, ctx);
  return detail::write<Char>(ctx.out(), val, specs, ctx.locale());
}

} }
# 41 "/home/avi/scylla-maint/seastar/include/seastar/core/sstring.hh" 2

# 1 "/home/avi/scylla-maint/seastar/include/seastar/util/std-compat.hh" 1
# 24 "/home/avi/scylla-maint/seastar/include/seastar/util/std-compat.hh"
# 1 "/home/avi/scylla-maint/seastar/include/seastar/util/modules.hh" 1
# 25 "/home/avi/scylla-maint/seastar/include/seastar/util/std-compat.hh" 2




# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/memory_resource" 1 3
# 36 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/memory_resource" 3





# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 42 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/memory_resource" 2 3
# 66 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/memory_resource" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/shared_mutex" 1 3
# 33 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/shared_mutex" 3
# 46 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/shared_mutex" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 47 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/shared_mutex" 2 3





namespace std __attribute__ ((__visibility__ ("default")))
{
# 64 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/shared_mutex" 3
  class shared_mutex;


  class shared_timed_mutex;
# 83 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/shared_mutex" 3
  ; static inline int __glibcxx_rwlock_rdlock (pthread_rwlock_t *__rwlock) { if (__gthread_active_p ()) return pthread_rwlock_rdlock (__rwlock); else return 0; }
  ; static inline int __glibcxx_rwlock_tryrdlock (pthread_rwlock_t *__rwlock) { if (__gthread_active_p ()) return pthread_rwlock_tryrdlock (__rwlock); else return 0; }
  ; static inline int __glibcxx_rwlock_wrlock (pthread_rwlock_t *__rwlock) { if (__gthread_active_p ()) return pthread_rwlock_wrlock (__rwlock); else return 0; }
  ; static inline int __glibcxx_rwlock_trywrlock (pthread_rwlock_t *__rwlock) { if (__gthread_active_p ()) return pthread_rwlock_trywrlock (__rwlock); else return 0; }
  ; static inline int __glibcxx_rwlock_unlock (pthread_rwlock_t *__rwlock) { if (__gthread_active_p ()) return pthread_rwlock_unlock (__rwlock); else return 0; }
# 101 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/shared_mutex" 3
                                      ;
  static inline int
  __glibcxx_rwlock_timedrdlock (pthread_rwlock_t *__rwlock,
    const timespec *__ts)
  {
    if (__gthread_active_p ())
      return pthread_rwlock_timedrdlock (__rwlock, __ts);
    else
      return 0;
  }
                                      ;
  static inline int
  __glibcxx_rwlock_timedwrlock (pthread_rwlock_t *__rwlock,
    const timespec *__ts)
  {
    if (__gthread_active_p ())
      return pthread_rwlock_timedwrlock (__rwlock, __ts);
    else
      return 0;
  }
# 157 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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;
# 192 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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));

      do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__ret == 0), false)) std::__glibcxx_assert_fail(); } while (false);
    }

    bool
    try_lock()
    {
      int __ret = __glibcxx_rwlock_trywrlock(&_M_rwlock);
      if (__ret == 16) return false;

      do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__ret == 0), false)) std::__glibcxx_assert_fail(); } while (false);
      return true;
    }

    void
    unlock()
    {
      int __ret __attribute((__unused__)) = __glibcxx_rwlock_unlock(&_M_rwlock);

      do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__ret == 0), false)) std::__glibcxx_assert_fail(); } while (false);
    }



    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));

      do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__ret == 0), false)) std::__glibcxx_assert_fail(); } while (false);
    }

    bool
    try_lock_shared()
    {
      int __ret = __glibcxx_rwlock_tryrdlock(&_M_rwlock);



      if (__ret == 16 || __ret == 11) return false;

      do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__ret == 0), false)) std::__glibcxx_assert_fail(); } while (false);
      return true;
    }

    void
    unlock_shared()
    {
      unlock();
    }

    void* native_handle() { return &_M_rwlock; }
  };
# 414 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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(); }
    [[nodiscard]] bool try_lock() { return _M_impl.try_lock(); }
    void unlock() { _M_impl.unlock(); }



    void lock_shared() { _M_impl.lock_shared(); }
    [[nodiscard]] 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(); }
    [[__nodiscard__]] bool try_lock() { return _Base::try_lock(); }
    void unlock() { _Base::unlock(); }

    template<typename _Rep, typename _Period>
      [[__nodiscard__]]
      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(); }
    [[__nodiscard__]]
    bool try_lock_shared() { return _Base::try_lock_shared(); }
    void unlock_shared() { _Base::unlock_shared(); }

    template<typename _Rep, typename _Period>
      [[__nodiscard__]]
      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<typename _Duration>
      [[__nodiscard__]]
      bool
      try_lock_until(const chrono::time_point<chrono::system_clock,
       _Duration>& __atime)
      {
 auto __s = chrono::time_point_cast<chrono::seconds>(__atime);
 auto __ns = chrono::duration_cast<chrono::nanoseconds>(__atime - __s);

 __gthread_time_t __ts =
   {
     static_cast<std::time_t>(__s.time_since_epoch().count()),
     static_cast<long>(__ns.count())
   };

 int __ret = __glibcxx_rwlock_timedwrlock(&_M_rwlock, &__ts);


 if (__ret == 110 || __ret == 35)
   return false;

 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__ret == 0), false)) std::__glibcxx_assert_fail(); } while (false);
 return true;
      }


    template<typename _Duration>
      [[__nodiscard__]]
      bool
      try_lock_until(const chrono::time_point<chrono::steady_clock,
     _Duration>& __atime)
      {
 auto __s = chrono::time_point_cast<chrono::seconds>(__atime);
 auto __ns = chrono::duration_cast<chrono::nanoseconds>(__atime - __s);

 __gthread_time_t __ts =
   {
     static_cast<std::time_t>(__s.time_since_epoch().count()),
     static_cast<long>(__ns.count())
   };

 int __ret = pthread_rwlock_clockwrlock(&_M_rwlock, 1,
            &__ts);


 if (__ret == 110 || __ret == 35)
   return false;

 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__ret == 0), false)) std::__glibcxx_assert_fail(); } while (false);
 return true;
      }


    template<typename _Clock, typename _Duration>
      [[__nodiscard__]]
      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<typename _Duration>
      [[__nodiscard__]]
      bool
      try_lock_shared_until(const chrono::time_point<chrono::system_clock,
       _Duration>& __atime)
      {
 auto __s = chrono::time_point_cast<chrono::seconds>(__atime);
 auto __ns = chrono::duration_cast<chrono::nanoseconds>(__atime - __s);

 __gthread_time_t __ts =
   {
     static_cast<std::time_t>(__s.time_since_epoch().count()),
     static_cast<long>(__ns.count())
   };

 int __ret;
# 620 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/shared_mutex" 3
 do
   __ret = __glibcxx_rwlock_timedrdlock(&_M_rwlock, &__ts);
 while (__ret == 11 || __ret == 35);
 if (__ret == 110)
   return false;

 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__ret == 0), false)) std::__glibcxx_assert_fail(); } while (false);
 return true;
      }


    template<typename _Duration>
      [[__nodiscard__]]
      bool
      try_lock_shared_until(const chrono::time_point<chrono::steady_clock,
       _Duration>& __atime)
      {
 auto __s = chrono::time_point_cast<chrono::seconds>(__atime);
 auto __ns = chrono::duration_cast<chrono::nanoseconds>(__atime - __s);

 __gthread_time_t __ts =
   {
     static_cast<std::time_t>(__s.time_since_epoch().count()),
     static_cast<long>(__ns.count())
   };

 int __ret = pthread_rwlock_clockrdlock(&_M_rwlock, 1,
            &__ts);


 if (__ret == 110 || __ret == 35)
   return false;

 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__ret == 0), false)) std::__glibcxx_assert_fail(); } while (false);
 return true;
      }


    template<typename _Clock, typename _Duration>
      [[__nodiscard__]]
      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;
      }
# 726 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/shared_mutex" 3
  };



  template<typename _Mutex>
    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<typename _Clock, typename _Duration>
 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<typename _Rep, typename _Period>
 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;
      }

      [[__nodiscard__]]
      bool
      try_lock()
      {
 _M_lockable();
 return _M_owns = _M_pm->try_lock_shared();
      }

      template<typename _Rep, typename _Period>
 [[__nodiscard__]]
 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<typename _Clock, typename _Duration>
 [[__nodiscard__]]
 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::operation_not_permitted));
 _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);
      }



      [[__nodiscard__]]
      bool owns_lock() const noexcept { return _M_owns; }

      explicit operator bool() const noexcept { return _M_owns; }

      [[__nodiscard__]]
      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<typename _Mutex>
    void
    swap(shared_lock<_Mutex>& __x, shared_lock<_Mutex>& __y) noexcept
    { __x.swap(__y); }



}
# 67 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/memory_resource" 2 3



namespace std __attribute__ ((__visibility__ ("default")))
{

namespace pmr
{


  template<typename _Tp = std::byte>
    class polymorphic_allocator;
# 89 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/memory_resource" 3
  [[nodiscard, __gnu__::__returns_nonnull__, __gnu__::__const__]]
  memory_resource*
  new_delete_resource() noexcept;


  [[nodiscard, __gnu__::__returns_nonnull__, __gnu__::__const__]]
  memory_resource*
  null_memory_resource() noexcept;


  [[__gnu__::__returns_nonnull__]]
  memory_resource*
  set_default_resource(memory_resource* __r) noexcept;


  [[__gnu__::__returns_nonnull__]]
  memory_resource*
  get_default_resource() noexcept;


  struct pool_options;

  class synchronized_pool_resource;

  class unsynchronized_pool_resource;
  class monotonic_buffer_resource;







  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;
  };
# 188 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/memory_resource" 3
  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<shared_mutex>&);
    _TPools* _M_alloc_shared_tpools(lock_guard<shared_mutex>&);
    auto _M_thread_specific_pools() noexcept;

    __pool_resource _M_impl;
    __gthread_key_t _M_key;

    _TPools* _M_tpools = nullptr;
    mutable shared_mutex _M_mx;
  };
# 259 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/memory_resource" 3
  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;
  };
# 337 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/memory_resource" 3
  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 (__builtin_expect(__bytes == 0, false))
 __bytes = 1;

      void* __p = std::align(__alignment, __bytes, _M_current_buf, _M_avail);
      if (__builtin_expect(__p == nullptr, false))
 {
   _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 (__builtin_expect(__buffer_size == 0, false))
 __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;
  };

}

}
# 30 "/home/avi/scylla-maint/seastar/include/seastar/util/std-compat.hh" 2
# 51 "/home/avi/scylla-maint/seastar/include/seastar/util/std-compat.hh"
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/source_location" 1 3
# 33 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/source_location" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/source_location" 2 3




namespace std
{



  struct source_location
  {
  private:
    using uint_least32_t = unsigned int;
    struct __impl
    {
      const char* _M_file_name;
      const char* _M_function_name;
      unsigned _M_line;
      unsigned _M_column;
    };
    using __builtin_ret_type = decltype(__builtin_source_location());

  public:


    static consteval source_location
    current(__builtin_ret_type __p = __builtin_source_location()) noexcept
    {
      source_location __ret;
      __ret._M_impl = static_cast <const __impl*>(__p);
      return __ret;
    }

    constexpr source_location() noexcept { }


    constexpr uint_least32_t
    line() const noexcept
    { return _M_impl ? _M_impl->_M_line : 0u; }

    constexpr uint_least32_t
    column() const noexcept
    { return _M_impl ? _M_impl->_M_column : 0u; }

    constexpr const char*
    file_name() const noexcept
    { return _M_impl ? _M_impl->_M_file_name : ""; }

    constexpr const char*
    function_name() const noexcept
    { return _M_impl ? _M_impl->_M_function_name : ""; }

  private:
    const __impl* _M_impl = nullptr;
  };


}
# 52 "/home/avi/scylla-maint/seastar/include/seastar/util/std-compat.hh" 2
# 64 "/home/avi/scylla-maint/seastar/include/seastar/util/std-compat.hh"
namespace seastar::compat {



using source_location = std::source_location;







}
# 43 "/home/avi/scylla-maint/seastar/include/seastar/core/sstring.hh" 2

# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/temporary_buffer.hh" 1
# 28 "/home/avi/scylla-maint/seastar/include/seastar/core/temporary_buffer.hh"
# 1 "/usr/include/malloc.h" 1 3 4
# 24 "/usr/include/malloc.h" 3 4
# 1 "/usr/bin/../lib/clang/18/include/stddef.h" 1 3 4
# 72 "/usr/bin/../lib/clang/18/include/stddef.h" 3 4
# 1 "/usr/bin/../lib/clang/18/include/__stddef_ptrdiff_t.h" 1 3 4
# 18 "/usr/bin/../lib/clang/18/include/__stddef_ptrdiff_t.h" 3 4
typedef long int ptrdiff_t;
# 73 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3 4




# 1 "/usr/bin/../lib/clang/18/include/__stddef_size_t.h" 1 3 4
# 18 "/usr/bin/../lib/clang/18/include/__stddef_size_t.h" 3 4
typedef long unsigned int size_t;
# 78 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3 4
# 87 "/usr/bin/../lib/clang/18/include/stddef.h" 3 4
# 1 "/usr/bin/../lib/clang/18/include/__stddef_wchar_t.h" 1 3 4
# 88 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3 4




# 1 "/usr/bin/../lib/clang/18/include/__stddef_null.h" 1 3 4
# 93 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3 4




# 1 "/usr/bin/../lib/clang/18/include/__stddef_nullptr_t.h" 1 3 4
# 98 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3 4
# 112 "/usr/bin/../lib/clang/18/include/stddef.h" 3 4
# 1 "/usr/bin/../lib/clang/18/include/__stddef_offsetof.h" 1 3 4
# 113 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3 4
# 25 "/usr/include/malloc.h" 2 3 4
# 36 "/usr/include/malloc.h" 3 4
extern "C" {


extern void *malloc (size_t __size) noexcept (true) __attribute__ ((__malloc__))
                                         ;


extern void *calloc (size_t __nmemb, size_t __size)
noexcept (true) __attribute__ ((__malloc__)) ;






extern void *realloc (void *__ptr, size_t __size)
noexcept (true) __attribute__ ((__warn_unused_result__)) ;






extern void *reallocarray (void *__ptr, size_t __nmemb, size_t __size)
  noexcept (true) __attribute__ ((__warn_unused_result__))
                     ;


extern void free (void *__ptr) noexcept (true);


extern void *memalign (size_t __alignment, size_t __size)
  noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__alloc_align__ (1)))
                                                          ;


extern void *valloc (size_t __size) noexcept (true) __attribute__ ((__malloc__))
                                                             ;



extern void *pvalloc (size_t __size) noexcept (true) __attribute__ ((__malloc__))
                           ;



struct mallinfo
{
  int arena;
  int ordblks;
  int smblks;
  int hblks;
  int hblkhd;
  int usmblks;
  int fsmblks;
  int uordblks;
  int fordblks;
  int keepcost;
};




struct mallinfo2
{
  size_t arena;
  size_t ordblks;
  size_t smblks;
  size_t hblks;
  size_t hblkhd;
  size_t usmblks;
  size_t fsmblks;
  size_t uordblks;
  size_t fordblks;
  size_t keepcost;
};


extern struct mallinfo mallinfo (void) noexcept (true) __attribute__ ((__deprecated__));


extern struct mallinfo2 mallinfo2 (void) noexcept (true);
# 144 "/usr/include/malloc.h" 3 4
extern int mallopt (int __param, int __val) noexcept (true);



extern int malloc_trim (size_t __pad) noexcept (true);



extern size_t malloc_usable_size (void *__ptr) noexcept (true);


extern void malloc_stats (void) noexcept (true);


extern int malloc_info (int __options, FILE *__fp) noexcept (true);

}
# 29 "/home/avi/scylla-maint/seastar/include/seastar/core/temporary_buffer.hh" 2

# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/deleter.hh" 1
# 25 "/home/avi/scylla-maint/seastar/include/seastar/core/deleter.hh"
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 1 3
# 42 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 3


# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 45 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 2 3
# 26 "/home/avi/scylla-maint/seastar/include/seastar/core/deleter.hh" 2

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdlib" 1 3
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdlib" 3
# 28 "/home/avi/scylla-maint/seastar/include/seastar/core/deleter.hh" 2





namespace seastar {
# 52 "/home/avi/scylla-maint/seastar/include/seastar/core/deleter.hh"
class deleter final {
public:

    struct impl;
    struct raw_object_tag {};

private:

    impl* _impl = nullptr;
public:

    deleter() noexcept = default;
    deleter(const deleter&) = delete;

    deleter(deleter&& x) noexcept : _impl(x._impl) { x._impl = nullptr; }

    explicit deleter(impl* i) noexcept : _impl(i) {}
    deleter(raw_object_tag, void* object) noexcept
        : _impl(from_raw_object(object)) {}


    ~deleter();
    deleter& operator=(deleter&& x) noexcept;
    deleter& operator=(deleter&) = delete;





    deleter share();

    explicit operator bool() const noexcept { return bool(_impl); }

    void reset(impl* i) {
        this->~deleter();
        new (this) deleter(i);
    }



    void append(deleter d);
private:
    static bool is_raw_object(impl* i) noexcept {
        auto x = reinterpret_cast<uintptr_t>(i);
        return x & 1;
    }
    bool is_raw_object() const noexcept {
        return is_raw_object(_impl);
    }
    static void* to_raw_object(impl* i) noexcept {
        auto x = reinterpret_cast<uintptr_t>(i);
        return reinterpret_cast<void*>(x & ~uintptr_t(1));
    }
    void* to_raw_object() const noexcept {
        return to_raw_object(_impl);
    }
    impl* from_raw_object(void* object) noexcept {
        auto x = reinterpret_cast<uintptr_t>(object);
        return reinterpret_cast<impl*>(x | 1);
    }
};


struct deleter::impl {
    unsigned refs = 1;
    deleter next;
    impl(deleter next) : next(std::move(next)) {}
    virtual ~impl() {}
};


inline
deleter::~deleter() {
    if (is_raw_object()) {
        std::free(to_raw_object());
        return;
    }
    if (_impl && --_impl->refs == 0) {
        delete _impl;
    }
}

inline
deleter& deleter::operator=(deleter&& x) noexcept {
    if (this != &x) {
        this->~deleter();
        new (this) deleter(std::move(x));
    }
    return *this;
}


template <typename Deleter>
struct lambda_deleter_impl final : deleter::impl {
    Deleter del;
    lambda_deleter_impl(deleter next, Deleter&& del)
        : impl(std::move(next)), del(std::move(del)) {}
    virtual ~lambda_deleter_impl() override { del(); }
};

template <typename Object>
struct object_deleter_impl final : deleter::impl {
    Object obj;
    object_deleter_impl(deleter next, Object&& obj)
        : impl(std::move(next)), obj(std::move(obj)) {}
};

template <typename Object>
inline
object_deleter_impl<Object>* make_object_deleter_impl(deleter next, Object obj) {
    return new object_deleter_impl<Object>(std::move(next), std::move(obj));
}
# 175 "/home/avi/scylla-maint/seastar/include/seastar/core/deleter.hh"
template <typename Object>
deleter
make_deleter(deleter next, Object o) {
    return deleter(new lambda_deleter_impl<Object>(std::move(next), std::move(o)));
}






template <typename Object>
deleter
make_deleter(Object o) {
    return make_deleter(deleter(), std::move(o));
}



struct free_deleter_impl final : deleter::impl {
    void* obj;
    free_deleter_impl(void* obj) : impl(deleter()), obj(obj) {}
    free_deleter_impl(const free_deleter_impl&) = delete;
    free_deleter_impl(free_deleter_impl&&) = delete;
    virtual ~free_deleter_impl() override { std::free(obj); }
};


inline
deleter
deleter::share() {
    if (!_impl) {
        return deleter();
    }
    if (is_raw_object()) {
        _impl = new free_deleter_impl(to_raw_object());
    }
    ++_impl->refs;
    return deleter(_impl);
}




inline
void deleter::append(deleter d) {
    if (!d._impl) {
        return;
    }
    impl* next_impl = _impl;
    deleter* next_d = this;
    while (next_impl) {
        if (next_impl == d._impl) {
            return;
        }
        if (is_raw_object(next_impl)) {
            next_d->_impl = next_impl = new free_deleter_impl(to_raw_object(next_impl));
        }

        if (next_impl->refs != 1) {
            next_d->_impl = next_impl = make_object_deleter_impl(deleter(next_impl), std::move(d));
            return;
        }

        next_d = &next_impl->next;
        next_impl = next_d->_impl;
    }
    next_d->_impl = d._impl;
    d._impl = nullptr;
}






inline
deleter
make_free_deleter(void* obj) {
    if (!obj) {
        return deleter();
    }
    return deleter(deleter::raw_object_tag(), obj);
}







inline
deleter
make_free_deleter(deleter next, void* obj) {
    return make_deleter(std::move(next), [obj] () mutable { std::free(obj); });
}



template <typename T>
inline
deleter
make_object_deleter(T&& obj) {
    return deleter{make_object_deleter_impl(deleter(), std::move(obj))};
}



template <typename T>
inline
deleter
make_object_deleter(deleter d, T&& obj) {
    return deleter{make_object_deleter_impl(std::move(d), std::move(obj))};
}




}
# 31 "/home/avi/scylla-maint/seastar/include/seastar/core/temporary_buffer.hh" 2
# 1 "/home/avi/scylla-maint/seastar/include/seastar/util/eclipse.hh" 1
# 32 "/home/avi/scylla-maint/seastar/include/seastar/core/temporary_buffer.hh" 2



namespace seastar {
# 66 "/home/avi/scylla-maint/seastar/include/seastar/core/temporary_buffer.hh"
template <typename CharType>
class temporary_buffer {
    static_assert(sizeof(CharType) == 1, "must buffer stream of bytes");
    CharType* _buffer;
    size_t _size;
    deleter _deleter;
public:




    explicit temporary_buffer(size_t size)
        : _buffer(static_cast<CharType*>(malloc(size * sizeof(CharType)))), _size(size)
        , _deleter(make_free_deleter(_buffer)) {
        if (size && !_buffer) {
            throw std::bad_alloc();
        }
    }


    temporary_buffer() noexcept
        : _buffer(nullptr)
        , _size(0) {}
    temporary_buffer(const temporary_buffer&) = delete;


    temporary_buffer(temporary_buffer&& x) noexcept : _buffer(x._buffer), _size(x._size), _deleter(std::move(x._deleter)) {
        x._buffer = nullptr;
        x._size = 0;
    }







    temporary_buffer(CharType* buf, size_t size, deleter d) noexcept
        : _buffer(buf), _size(size), _deleter(std::move(d)) {}




    temporary_buffer(const CharType* src, size_t size) : temporary_buffer(size) {
        std::copy_n(src, size, _buffer);
    }
    void operator=(const temporary_buffer&) = delete;

    temporary_buffer& operator=(temporary_buffer&& x) noexcept {
        if (this != &x) {
            _buffer = x._buffer;
            _size = x._size;
            _deleter = std::move(x._deleter);
            x._buffer = nullptr;
            x._size = 0;
        }
        return *this;
    }

    const CharType* get() const noexcept { return _buffer; }


    CharType* get_write() noexcept { return _buffer; }

    size_t size() const noexcept { return _size; }

    const CharType* begin() const noexcept { return _buffer; }

    const CharType* end() const noexcept { return _buffer + _size; }





    temporary_buffer prefix(size_t size) && noexcept {
        auto ret = std::move(*this);
        ret._size = size;
        return ret;
    }



    CharType operator[](size_t pos) const noexcept {
        return _buffer[pos];
    }

    bool empty() const noexcept { return !size(); }

    explicit operator bool() const noexcept { return size(); }





    temporary_buffer share() {
        return temporary_buffer(_buffer, _size, _deleter.share());
    }







    temporary_buffer share(size_t pos, size_t len) {
        auto ret = share();
        ret._buffer += pos;
        ret._size = len;
        return ret;
    }



    temporary_buffer clone() const {
        return {_buffer, _size};
    }




    void trim_front(size_t pos) noexcept {
        _buffer += pos;
        _size -= pos;
    }




    void trim(size_t pos) noexcept {
        _size = pos;
    }






    deleter release() noexcept {
        return std::move(_deleter);
    }






    static temporary_buffer aligned(size_t alignment, size_t size) {
        void *ptr = nullptr;
        auto ret = ::posix_memalign(&ptr, alignment, size * sizeof(CharType));
        auto buf = static_cast<CharType*>(ptr);
        if (ret) {
            throw std::bad_alloc();
        }
        return temporary_buffer(buf, size, make_free_deleter(buf));
    }

    static temporary_buffer copy_of(std::string_view view) {
        void* ptr = ::malloc(view.size());
        if (!ptr) {
            throw std::bad_alloc();
        }
        auto buf = static_cast<CharType*>(ptr);
        memcpy(buf, view.data(), view.size());
        return temporary_buffer(buf, view.size(), make_free_deleter(buf));
    }





    bool operator==(const temporary_buffer& o) const noexcept {
        return size() == o.size() && std::equal(begin(), end(), o.begin());
    }





    bool operator!=(const temporary_buffer& o) const noexcept {
        return !(*this == o);
    }
};



}
# 45 "/home/avi/scylla-maint/seastar/include/seastar/core/sstring.hh" 2

namespace seastar {



template <typename char_type, typename Size, Size max_size, bool NulTerminate = true>
class basic_sstring;






using sstring = basic_sstring<char, uint32_t, 15>;






namespace internal {
[[noreturn]] void throw_bad_alloc();
[[noreturn]] void throw_sstring_overflow();
[[noreturn]] void throw_sstring_out_of_range();
}


template <typename char_type, typename Size, Size max_size, bool NulTerminate>
class basic_sstring {
    static_assert(
            (std::is_same_v<char_type, char>
             || std::is_same_v<char_type, signed char>
             || std::is_same_v<char_type, unsigned char>),
            "basic_sstring only supports single byte char types");
    union contents {
        struct external_type {
            char_type* str;
            Size size;
            int8_t pad;
        } external;
        struct internal_type {
            char_type str[max_size];
            int8_t size;
        } internal;
        static_assert(sizeof(external_type) <= sizeof(internal_type), "max_size too small");
        static_assert(max_size <= 127, "max_size too large");
    } u;
    bool is_internal() const noexcept {
        return u.internal.size >= 0;
    }
    bool is_external() const noexcept {
        return !is_internal();
    }
    const char_type* str() const noexcept {
        return is_internal() ? u.internal.str : u.external.str;
    }
    char_type* str() noexcept {
        return is_internal() ? u.internal.str : u.external.str;
    }

public:
    using value_type = char_type;
    using traits_type = std::char_traits<char_type>;
    using allocator_type = std::allocator<char_type>;
    using reference = char_type&;
    using const_reference = const char_type&;
    using pointer = char_type*;
    using const_pointer = const char_type*;
    using iterator = char_type*;
    using const_iterator = const char_type*;

    using difference_type = ssize_t;
    using size_type = Size;
    static constexpr size_type npos = static_cast<size_type>(-1);
    static constexpr unsigned padding() { return unsigned(NulTerminate); }
public:
    struct initialized_later {};

    basic_sstring() noexcept {
        u.internal.size = 0;
        if (NulTerminate) {
            u.internal.str[0] = '\0';
        }
    }
    basic_sstring(const basic_sstring& x) {
        if (x.is_internal()) {
            u.internal = x.u.internal;
        } else {
            u.internal.size = -1;
            u.external.str = reinterpret_cast<char_type*>(std::malloc(x.u.external.size + padding()));
            if (!u.external.str) {
                internal::throw_bad_alloc();
            }
            std::copy(x.u.external.str, x.u.external.str + x.u.external.size + padding(), u.external.str);
            u.external.size = x.u.external.size;
        }
    }
    basic_sstring(basic_sstring&& x) noexcept {
#pragma GCC diagnostic push



#pragma GCC diagnostic ignored "-Wuninitialized"
        u = x.u;
#pragma GCC diagnostic pop
        x.u.internal.size = 0;
        x.u.internal.str[0] = '\0';
    }
    basic_sstring(initialized_later, size_t size) {
        if (size_type(size) != size) {
            internal::throw_sstring_overflow();
        }
        if (size + padding() <= sizeof(u.internal.str)) {
            if (NulTerminate) {
                u.internal.str[size] = '\0';
            }
            u.internal.size = size;
        } else {
            u.internal.size = -1;
            u.external.str = reinterpret_cast<char_type*>(std::malloc(size + padding()));
            if (!u.external.str) {
                internal::throw_bad_alloc();
            }
            u.external.size = size;
            if (NulTerminate) {
                u.external.str[size] = '\0';
            }
        }
    }
    basic_sstring(const char_type* x, size_t size) {
        if (size_type(size) != size) {
            internal::throw_sstring_overflow();
        }
        if (size + padding() <= sizeof(u.internal.str)) {
            std::copy(x, x + size, u.internal.str);
            if (NulTerminate) {
                u.internal.str[size] = '\0';
            }
            u.internal.size = size;
        } else {
            u.internal.size = -1;
            u.external.str = reinterpret_cast<char_type*>(std::malloc(size + padding()));
            if (!u.external.str) {
                internal::throw_bad_alloc();
            }
            u.external.size = size;
            std::copy(x, x + size, u.external.str);
            if (NulTerminate) {
                u.external.str[size] = '\0';
            }
        }
    }

    basic_sstring(size_t size, char_type x) : basic_sstring(initialized_later(), size) {
        memset(begin(), x, size);
    }

    basic_sstring(const char* x) : basic_sstring(reinterpret_cast<const char_type*>(x), std::strlen(x)) {}
    basic_sstring(std::basic_string<char_type>& x) : basic_sstring(x.c_str(), x.size()) {}
    basic_sstring(std::initializer_list<char_type> x) : basic_sstring(x.begin(), x.end() - x.begin()) {}
    basic_sstring(const char_type* b, const char_type* e) : basic_sstring(b, e - b) {}
    basic_sstring(const std::basic_string<char_type>& s)
        : basic_sstring(s.data(), s.size()) {}
    template <typename InputIterator>
    basic_sstring(InputIterator first, InputIterator last)
            : basic_sstring(initialized_later(), std::distance(first, last)) {
        std::copy(first, last, begin());
    }
    explicit basic_sstring(std::basic_string_view<char_type, traits_type> v)
            : basic_sstring(v.data(), v.size()) {
    }
    ~basic_sstring() noexcept {
        if (is_external()) {
            std::free(u.external.str);
        }
    }
    basic_sstring& operator=(const basic_sstring& x) {
        basic_sstring tmp(x);
        swap(tmp);
        return *this;
    }
    basic_sstring& operator=(basic_sstring&& x) noexcept {
        if (this != &x) {
            this->~basic_sstring();
            new (this) basic_sstring(std::move(x));
        }
        return *this;
    }
    operator std::basic_string<char_type>() const {
        return { str(), size() };
    }

    size_t size() const noexcept {
        return is_internal() ? u.internal.size : u.external.size;
    }

    size_t length() const noexcept {
        return size();
    }

    size_t find(char_type t, size_t pos = 0) const noexcept {
        const char_type* it = str() + pos;
        const char_type* end = str() + size();
        while (it < end) {
            if (*it == t) {
                return it - str();
            }
            it++;
        }
        return npos;
    }

    size_t find(const char_type* c_str, size_t pos, size_t len2) const noexcept {
        (static_cast <bool> (c_str != nullptr || len2 == 0) ? void (0) : __assert_fail ("c_str != nullptr || len2 == 0", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        if (pos > size()) {
            return npos;
        }

        if (len2 == 0) {
            return pos;
        }

        const char_type* it = str() + pos;
        const char_type* end = str() + size();
        size_t len1 = end - it;
        if (len1 < len2) {
            return npos;
        }

        char_type f2 = *c_str;
        while (true) {
            len1 = end - it;
            if (len1 < len2) {
                return npos;
            }


            it = traits_type::find(it, len1 - len2 + 1, f2);
            if (it == nullptr) {
                return npos;
            }

            if (traits_type::compare(it, c_str, len2) == 0) {
                return it - str();
            }

            ++it;
        }
    }

    constexpr size_t find(const char_type* s, size_t pos = 0) const noexcept {
        return find(s, pos, traits_type::length(s));
    }

    size_t find(const basic_sstring& s, size_t pos = 0) const noexcept {
        return find(s.str(), pos, s.size());
    }

    template<class StringViewLike,
             std::enable_if_t<std::is_convertible_v<StringViewLike,
                                                    std::basic_string_view<char_type, traits_type>>,
                              int> = 0>
    size_t find(const StringViewLike& sv_like, size_type pos = 0) const noexcept {
        std::basic_string_view<char_type, traits_type> sv = sv_like;
        return find(sv.data(), pos, sv.size());
    }







    size_t find_last_of (char_type c, size_t pos = npos) const noexcept {
        const char_type* str_start = str();
        if (size()) {
            if (pos >= size()) {
                pos = size() - 1;
            }
            const char_type* p = str_start + pos + 1;
            do {
                p--;
                if (*p == c) {
                    return (p - str_start);
                }
            } while (p != str_start);
        }
        return npos;
    }







    basic_sstring& append (const char_type* s, size_t n) {
        basic_sstring ret(initialized_later(), size() + n);
        std::copy(begin(), end(), ret.begin());
        std::copy(s, s + n, ret.begin() + size());
        *this = std::move(ret);
        return *this;
    }






    template <class Operation>
    requires std::is_invocable_r_v<size_t, Operation, char_type*, size_t>
    void resize_and_overwrite(size_t n, Operation op) {
        if (n > size()) {
            *this = basic_sstring(initialized_later(), n);
        }
        size_t r = std::move(op)(data(), n);
        (static_cast <bool> (r <= n) ? void (0) : __assert_fail ("r <= n", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        resize(r);
    }






    void resize(size_t n, const char_type c = '\0') {
        if (n > size()) {
            *this += basic_sstring(n - size(), c);
        } else if (n < size()) {
            if (is_internal()) {
                u.internal.size = n;
                if (NulTerminate) {
                    u.internal.str[n] = '\0';
                }
            } else if (n + padding() <= sizeof(u.internal.str)) {
                *this = basic_sstring(u.external.str, n);
            } else {
                u.external.size = n;
                if (NulTerminate) {
                    u.external.str[n] = '\0';
                }
            }
        }
    }





    basic_sstring& replace(size_type pos, size_type n1, const char_type* s,
             size_type n2) {
        if (pos > size()) {
            internal::throw_sstring_out_of_range();
        }

        if (n1 > size() - pos) {
            n1 = size() - pos;
        }

        if (n1 == n2) {
            if (n2) {
                std::copy(s, s + n2, begin() + pos);
            }
            return *this;
        }
        basic_sstring ret(initialized_later(), size() + n2 - n1);
        char_type* p= ret.begin();
        std::copy(begin(), begin() + pos, p);
        p += pos;
        if (n2) {
            std::copy(s, s + n2, p);
        }
        p += n2;
        std::copy(begin() + pos + n1, end(), p);
        *this = std::move(ret);
        return *this;
    }

    template <class InputIterator>
    basic_sstring& replace (const_iterator i1, const_iterator i2,
            InputIterator first, InputIterator last) {
        if (i1 < begin() || i1 > end() || i2 < begin()) {
            internal::throw_sstring_out_of_range();
        }
        if (i2 > end()) {
            i2 = end();
        }

        if (i2 - i1 == last - first) {

            std::copy(first, last, const_cast<char_type*>(i1));
            return *this;
        }
        basic_sstring ret(initialized_later(), size() + (last - first) - (i2 - i1));
        char_type* p = ret.begin();
        p = std::copy(cbegin(), i1, p);
        p = std::copy(first, last, p);
        std::copy(i2, cend(), p);
        *this = std::move(ret);
        return *this;
    }

    iterator erase(iterator first, iterator last) {
        size_t pos = first - begin();
        replace(pos, last - first, nullptr, 0);
        return begin() + pos;
    }





    template <class InputIterator>
    void insert(const_iterator p, InputIterator beg, InputIterator end) {
        replace(p, p, beg, end);
    }







    reference
    front() noexcept {
        (static_cast <bool> (!empty()) ? void (0) : __assert_fail ("!empty()", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        return *str();
    }






    const_reference
    front() const noexcept {
        (static_cast <bool> (!empty()) ? void (0) : __assert_fail ("!empty()", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        return *str();
    }






    reference
    back() noexcept {
        return operator[](size() - 1);
    }






    const_reference
    back() const noexcept {
        return operator[](size() - 1);
    }

    basic_sstring substr(size_t from, size_t len = npos) const {
        if (from > size()) {
            internal::throw_sstring_out_of_range();
        }
        if (len > size() - from) {
            len = size() - from;
        }
        if (len == 0) {
            return "";
        }
        return { str() + from , len };
    }

    const char_type& at(size_t pos) const {
        if (pos >= size()) {
            internal::throw_sstring_out_of_range();
        }
        return *(str() + pos);
    }

    char_type& at(size_t pos) {
        if (pos >= size()) {
            internal::throw_sstring_out_of_range();
        }
        return *(str() + pos);
    }

    bool empty() const noexcept {
        return u.internal.size == 0;
    }


    [[deprecated("Use = {}")]]
    void reset() noexcept {
        if (is_external()) {
            std::free(u.external.str);
        }
        u.internal.size = 0;
        if (NulTerminate) {
            u.internal.str[0] = '\0';
        }
    }
    temporary_buffer<char_type> release() && {
        if (is_external()) {
            auto ptr = u.external.str;
            auto size = u.external.size;
            u.external.str = nullptr;
            u.external.size = 0;
            return temporary_buffer<char_type>(ptr, size, make_free_deleter(ptr));
        } else {
            auto buf = temporary_buffer<char_type>(u.internal.size);
            std::copy(u.internal.str, u.internal.str + u.internal.size, buf.get_write());
            u.internal.size = 0;
            if (NulTerminate) {
                u.internal.str[0] = '\0';
            }
            return buf;
        }
    }
    int compare(std::basic_string_view<char_type, traits_type> x) const noexcept {
        auto n = traits_type::compare(begin(), x.begin(), std::min(size(), x.size()));
        if (n != 0) {
            return n;
        }
        if (size() < x.size()) {
            return -1;
        } else if (size() > x.size()) {
            return 1;
        } else {
            return 0;
        }
    }

    int compare(size_t pos, size_t sz, std::basic_string_view<char_type, traits_type> x) const {
        if (pos > size()) {
            internal::throw_sstring_out_of_range();
        }

        sz = std::min(size() - pos, sz);
        auto n = traits_type::compare(begin() + pos, x.begin(), std::min(sz, x.size()));
        if (n != 0) {
            return n;
        }
        if (sz < x.size()) {
            return -1;
        } else if (sz > x.size()) {
            return 1;
        } else {
            return 0;
        }
    }

    constexpr bool starts_with(std::basic_string_view<char_type, traits_type> sv) const noexcept {
        return size() >= sv.size() && compare(0, sv.size(), sv) == 0;
    }

    constexpr bool starts_with(char_type c) const noexcept {
        return !empty() && traits_type::eq(front(), c);
    }

    constexpr bool starts_with(const char_type* s) const noexcept {
        return starts_with(std::basic_string_view<char_type, traits_type>(s));
    }

    constexpr bool ends_with(std::basic_string_view<char_type, traits_type> sv) const noexcept {
        return size() >= sv.size() && compare(size() - sv.size(), npos, sv) == 0;
    }

    constexpr bool ends_with(char_type c) const noexcept {
        return !empty() && traits_type::eq(back(), c);
    }

    constexpr bool ends_with(const char_type* s) const noexcept {
        return ends_with(std::basic_string_view<char_type, traits_type>(s));
    }

    constexpr bool contains(std::basic_string_view<char_type, traits_type> sv) const noexcept {
        return find(sv) != npos;
    }

    constexpr bool contains(char_type c) const noexcept {
        return find(c) != npos;
    }

    constexpr bool contains(const char_type* s) const noexcept {
        return find(s) != npos;
    }

    void swap(basic_sstring& x) noexcept {
        contents tmp;
        tmp = x.u;
        x.u = u;
        u = tmp;
    }
    char_type* data() noexcept {
        return str();
    }
    const char_type* data() const noexcept {
        return str();
    }
    const char_type* c_str() const noexcept {
        return str();
    }
    const char_type* begin() const noexcept { return str(); }
    const char_type* end() const noexcept { return str() + size(); }
    const char_type* cbegin() const noexcept { return str(); }
    const char_type* cend() const noexcept { return str() + size(); }
    char_type* begin() noexcept { return str(); }
    char_type* end() noexcept { return str() + size(); }
    bool operator==(const basic_sstring& x) const noexcept {
        return size() == x.size() && std::equal(begin(), end(), x.begin());
    }
    bool operator!=(const basic_sstring& x) const noexcept {
        return !operator==(x);
    }
    constexpr bool operator==(const std::basic_string<char_type> x) const noexcept {
        return compare(x) == 0;
    }
    constexpr bool operator==(const char_type* x) const noexcept {
        return compare(x) == 0;
    }

    constexpr std::strong_ordering operator<=>(const auto& x) const noexcept {
        return compare(x) <=> 0;
    }





    basic_sstring operator+(const basic_sstring& x) const {
        basic_sstring ret(initialized_later(), size() + x.size());
        std::copy(begin(), end(), ret.begin());
        std::copy(x.begin(), x.end(), ret.begin() + size());
        return ret;
    }
    basic_sstring& operator+=(const basic_sstring& x) {
        return *this = *this + x;
    }
    char_type& operator[](size_type pos) noexcept {
        return str()[pos];
    }
    const char_type& operator[](size_type pos) const noexcept {
        return str()[pos];
    }

    operator std::basic_string_view<char_type>() const noexcept {
# 700 "/home/avi/scylla-maint/seastar/include/seastar/core/sstring.hh"
        static_assert(noexcept(std::basic_string_view<char_type>(str(), size())));
        return std::basic_string_view<char_type>(str(), size());
    }
};

namespace internal {
template <class T> struct is_sstring : std::false_type {};
template <typename char_type, typename Size, Size max_size, bool NulTerminate>
struct is_sstring<basic_sstring<char_type, Size, max_size, NulTerminate>> : std::true_type {};
}


template <typename string_type = sstring>
string_type uninitialized_string(size_t size) {
    if constexpr (internal::is_sstring<string_type>::value) {
        return string_type(typename string_type::initialized_later(), size);
    } else {
        string_type ret;

        ret.resize_and_overwrite(size, [](string_type::value_type*, string_type::size_type n) { return n; });



        return ret;
    }
}


template <typename char_type, typename size_type, size_type Max, size_type N, bool NulTerminate>
inline
basic_sstring<char_type, size_type, Max, NulTerminate>
operator+(const char(&s)[N], const basic_sstring<char_type, size_type, Max, NulTerminate>& t) {
    using sstring = basic_sstring<char_type, size_type, Max, NulTerminate>;

    sstring ret(typename sstring::initialized_later(), N-1 + t.size());
    auto p = std::copy(std::begin(s), std::end(s)-1, ret.begin());
    std::copy(t.begin(), t.end(), p);
    return ret;
}

template <typename T>
static inline
size_t constexpr str_len(const T& s) {
    return std::string_view(s).size();
}


template <typename char_type, typename size_type, size_type max_size>
inline
void swap(basic_sstring<char_type, size_type, max_size>& x,
          basic_sstring<char_type, size_type, max_size>& y) noexcept
{
    return x.swap(y);
}


template <typename char_type, typename size_type, size_type max_size, bool NulTerminate, typename char_traits>
inline
std::basic_ostream<char_type, char_traits>&
operator<<(std::basic_ostream<char_type, char_traits>& os,
        const basic_sstring<char_type, size_type, max_size, NulTerminate>& s) {
    return os.write(s.begin(), s.size());
}


template <typename char_type, typename size_type, size_type max_size, bool NulTerminate, typename char_traits>
inline
std::basic_istream<char_type, char_traits>&
operator>>(std::basic_istream<char_type, char_traits>& is,
        basic_sstring<char_type, size_type, max_size, NulTerminate>& s) {
    std::string tmp;
    is >> tmp;
    s = tmp;
    return is;
}

}

namespace std {


template <typename char_type, typename size_type, size_type max_size, bool NulTerminate>
struct hash<seastar::basic_sstring<char_type, size_type, max_size, NulTerminate>> {
    size_t operator()(const seastar::basic_sstring<char_type, size_type, max_size, NulTerminate>& s) const {
        return std::hash<std::basic_string_view<char_type>>()(s);
    }
};

}

namespace seastar {

template <typename T>
static inline
void copy_str_to(char*& dst, const T& s) {
    std::string_view v(s);
    dst = std::copy(v.begin(), v.end(), dst);
}

template <typename String = sstring, typename... Args>
static String make_sstring(Args&&... args)
{
    String ret = uninitialized_string<String>((str_len(args) + ...));
    auto dst = ret.data();
    (copy_str_to(dst, args), ...);
    return ret;
}

namespace internal {
template <typename string_type, typename T>
string_type to_sstring(T value) {
    auto size = fmt::formatted_size("{}", value);
    auto formatted = uninitialized_string<string_type>(size);
    fmt::format_to(formatted.data(), "{}", value);
    return formatted;
}

template <typename string_type>
string_type to_sstring(const char* value) {
    return string_type(value);
}

template <typename string_type>
string_type to_sstring(sstring value) {
    return value;
}

template <typename string_type>
string_type to_sstring(const temporary_buffer<char>& buf) {
    return string_type(buf.get(), buf.size());
}
}

template <typename string_type = sstring, typename T>
string_type to_sstring(T value) {
    return internal::to_sstring<string_type>(value);
}
}
# 889 "/home/avi/scylla-maint/seastar/include/seastar/core/sstring.hh"
template <typename char_type, typename Size, Size max_size, bool NulTerminate>
struct fmt::formatter<seastar::basic_sstring<char_type, Size, max_size, NulTerminate>>
    : public fmt::formatter<basic_string_view<char_type>> {
    using format_as_t = basic_string_view<char_type>;
    using base = fmt::formatter<format_as_t>;
    template <typename FormatContext>
    auto format(const ::seastar::basic_sstring<char_type, Size, max_size, NulTerminate>& s, FormatContext& ctx) const {
        return base::format(format_as_t{s.c_str(), s.size()}, ctx);
    }
};
# 31 "/home/avi/scylla-maint/seastar/include/seastar/core/scheduling.hh" 2
# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/function_traits.hh" 1
# 26 "/home/avi/scylla-maint/seastar/include/seastar/core/function_traits.hh"
namespace seastar {

template<typename T>
struct function_traits;

template<typename Ret, typename... Args>
struct function_traits<Ret(Args...)>
{
    using return_type = Ret;
    using args_as_tuple = std::tuple<Args...>;
    using signature = Ret (Args...);

    static constexpr std::size_t arity = sizeof...(Args);

    template <std::size_t N>
    struct arg
    {
        static_assert(N < arity, "no such parameter index.");
        using type = typename std::tuple_element<N, std::tuple<Args...>>::type;
    };
};

template<typename Ret, typename... Args>
struct function_traits<Ret(*)(Args...)> : public function_traits<Ret(Args...)>
{};

template <typename T, typename Ret, typename... Args>
struct function_traits<Ret(T::*)(Args...)> : public function_traits<Ret(Args...)>
{};

template <typename T, typename Ret, typename... Args>
struct function_traits<Ret(T::*)(Args...) const> : public function_traits<Ret(Args...)>
{};

template <typename T>
struct function_traits : public function_traits<decltype(&T::operator())>
{};

template<typename T>
struct function_traits<T&> : public function_traits<std::remove_reference_t<T>>
{};

}
# 32 "/home/avi/scylla-maint/seastar/include/seastar/core/scheduling.hh" 2




namespace seastar {


constexpr unsigned max_scheduling_groups() { return 18; }

template <typename T = void>
class future;

class reactor;

class scheduling_group;
class scheduling_group_key;

using sched_clock = std::chrono::steady_clock;


namespace internal {


unsigned scheduling_group_index(scheduling_group sg) noexcept;
scheduling_group scheduling_group_from_index(unsigned index) noexcept;

unsigned long scheduling_group_key_id(scheduling_group_key) noexcept;

template<typename T>
T* scheduling_group_get_specific_ptr(scheduling_group sg, scheduling_group_key key) noexcept;

}
# 77 "/home/avi/scylla-maint/seastar/include/seastar/core/scheduling.hh"
future<scheduling_group> create_scheduling_group(sstring name, float shares) noexcept;
# 92 "/home/avi/scylla-maint/seastar/include/seastar/core/scheduling.hh"
future<scheduling_group> create_scheduling_group(sstring name, sstring shortname, float shares) noexcept;
# 103 "/home/avi/scylla-maint/seastar/include/seastar/core/scheduling.hh"
future<> destroy_scheduling_group(scheduling_group sg) noexcept;
# 115 "/home/avi/scylla-maint/seastar/include/seastar/core/scheduling.hh"
future<> rename_scheduling_group(scheduling_group sg, sstring new_name) noexcept;
# 127 "/home/avi/scylla-maint/seastar/include/seastar/core/scheduling.hh"
future<> rename_scheduling_group(scheduling_group sg, sstring new_name, sstring new_shortname) noexcept;
# 143 "/home/avi/scylla-maint/seastar/include/seastar/core/scheduling.hh"
struct scheduling_group_key_config {



    scheduling_group_key_config() :
        scheduling_group_key_config(typeid(void)) {}
# 158 "/home/avi/scylla-maint/seastar/include/seastar/core/scheduling.hh"
    scheduling_group_key_config(const std::type_info& type_info) :
            type_index(type_info) {}

    size_t allocation_size;

    size_t alignment;

    std::type_index type_index;

    std::function<void (void*)> constructor;

    std::function<void (void*)> rename;


    std::function<void (void*)> destructor;

};
# 183 "/home/avi/scylla-maint/seastar/include/seastar/core/scheduling.hh"
class scheduling_group_key {
public:

    scheduling_group_key(const scheduling_group_key&) noexcept = default;
    scheduling_group_key(scheduling_group_key&&) noexcept = default;
private:
    scheduling_group_key(unsigned long id) noexcept :
        _id(id) {}
    unsigned long _id;
    unsigned long id() const noexcept {
        return _id;
    }
    friend future<scheduling_group_key> scheduling_group_key_create(scheduling_group_key_config cfg) noexcept;
    template<typename T>
    friend T* internal::scheduling_group_get_specific_ptr(scheduling_group sg, scheduling_group_key key) noexcept;
    template<typename T>
    friend T& scheduling_group_get_specific(scheduling_group_key key) noexcept;

    friend unsigned long internal::scheduling_group_key_id(scheduling_group_key key) noexcept;
};


namespace internal {

inline unsigned long scheduling_group_key_id(scheduling_group_key key) noexcept {
    return key.id();
}
# 229 "/home/avi/scylla-maint/seastar/include/seastar/core/scheduling.hh"
template<typename ConstructorType, typename Tuple, size_t...Idx>
void apply_constructor(void* pre_alocated_mem, Tuple args, std::index_sequence<Idx...>) {
    new (pre_alocated_mem) ConstructorType(std::get<Idx>(args)...);
}
}
# 246 "/home/avi/scylla-maint/seastar/include/seastar/core/scheduling.hh"
template <typename T, typename... ConstructorArgs>
scheduling_group_key_config
make_scheduling_group_key_config(ConstructorArgs... args) {
    scheduling_group_key_config sgkc(typeid(T));
    sgkc.allocation_size = sizeof(T);
    sgkc.alignment = alignof(T);
    sgkc.constructor = [args = std::make_tuple(args...)] (void* p) {
        internal::apply_constructor<T>(p, args, std::make_index_sequence<sizeof...(ConstructorArgs)>());
    };
    sgkc.destructor = [] (void* p) {
        static_cast<T*>(p)->~T();
    };
    return sgkc;
}
# 268 "/home/avi/scylla-maint/seastar/include/seastar/core/scheduling.hh"
future<scheduling_group_key> scheduling_group_key_create(scheduling_group_key_config cfg) noexcept;
# 277 "/home/avi/scylla-maint/seastar/include/seastar/core/scheduling.hh"
template<typename T>
T& scheduling_group_get_specific(scheduling_group sg, scheduling_group_key key);






class scheduling_group {
    unsigned _id;
private:
    explicit scheduling_group(unsigned id) noexcept : _id(id) {}
public:

    constexpr scheduling_group() noexcept : _id(0) {}
    bool active() const noexcept;
    const sstring& name() const noexcept;
    const sstring& short_name() const noexcept;
    bool operator==(scheduling_group x) const noexcept { return _id == x._id; }
    bool operator!=(scheduling_group x) const noexcept { return _id != x._id; }
    bool is_main() const noexcept { return _id == 0; }
    bool is_at_exit() const noexcept { return _id == 1; }
    template<typename T>






    T& get_specific(scheduling_group_key key) noexcept {
        return *internal::scheduling_group_get_specific_ptr<T>(*this, key);
    }
# 321 "/home/avi/scylla-maint/seastar/include/seastar/core/scheduling.hh"
    void set_shares(float shares) noexcept;





    float get_shares() const noexcept;
# 337 "/home/avi/scylla-maint/seastar/include/seastar/core/scheduling.hh"
    future<> update_io_bandwidth(uint64_t bandwidth) const;


    friend future<scheduling_group> create_scheduling_group(sstring name, sstring shortname, float shares) noexcept;
    friend future<> destroy_scheduling_group(scheduling_group sg) noexcept;
    friend future<> rename_scheduling_group(scheduling_group sg, sstring new_name, sstring new_shortname) noexcept;
    friend class reactor;
    friend unsigned internal::scheduling_group_index(scheduling_group sg) noexcept;
    friend scheduling_group internal::scheduling_group_from_index(unsigned index) noexcept;

    template<typename SpecificValType, typename Mapper, typename Reducer, typename Initial>
    requires requires(SpecificValType specific_val, Mapper mapper, Reducer reducer, Initial initial) {
        {reducer(initial, mapper(specific_val))} -> std::convertible_to<Initial>;
    }
    friend future<typename function_traits<Reducer>::return_type>
    map_reduce_scheduling_group_specific(Mapper mapper, Reducer reducer, Initial initial_val, scheduling_group_key key);

    template<typename SpecificValType, typename Reducer, typename Initial>
    requires requires(SpecificValType specific_val, Reducer reducer, Initial initial) {
        {reducer(initial, specific_val)} -> std::convertible_to<Initial>;
    }
    friend future<typename function_traits<Reducer>::return_type>
        reduce_scheduling_group_specific(Reducer reducer, Initial initial_val, scheduling_group_key key);


};



namespace internal {

inline
unsigned
scheduling_group_index(scheduling_group sg) noexcept {
    return sg._id;
}

inline
scheduling_group
scheduling_group_from_index(unsigned index) noexcept {
    return scheduling_group(index);
}





inline
scheduling_group*
current_scheduling_group_ptr() noexcept {

    static thread_local scheduling_group sg;
    return &sg;
}

}




inline
scheduling_group
current_scheduling_group() noexcept {
    return *internal::current_scheduling_group_ptr();
}

inline
scheduling_group
default_scheduling_group() noexcept {
    return scheduling_group();
}



inline
bool
scheduling_group::active() const noexcept {
    return *this == current_scheduling_group();
}

}

namespace std {


template <>
struct hash<seastar::scheduling_group> {
    size_t operator()(seastar::scheduling_group sg) const noexcept {
        return seastar::internal::scheduling_group_index(sg);
    }
};

}
# 25 "/home/avi/scylla-maint/seastar/include/seastar/core/task.hh" 2
# 1 "/home/avi/scylla-maint/seastar/include/seastar/util/backtrace.hh" 1
# 25 "/home/avi/scylla-maint/seastar/include/seastar/util/backtrace.hh"
# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/print.hh" 1
# 27 "/home/avi/scylla-maint/seastar/include/seastar/core/print.hh"
# 1 "/usr/include/fmt/ostream.h" 1 3 4
# 11 "/usr/include/fmt/ostream.h" 3 4
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/fstream" 1 3 4
# 37 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/fstream" 3






# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdio" 1 3
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdio" 3
# 44 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/fstream" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/basic_file.h" 1 3
# 38 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/basic_file.h" 3


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/c++io.h" 1 3
# 35 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/c++io.h" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdio" 1 3
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdio" 3
# 36 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/c++io.h" 2 3


namespace std __attribute__ ((__visibility__ ("default")))
{
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/c++io.h" 3
  typedef __gthread_mutex_t __c_lock;



  typedef FILE __c_file;


}
# 41 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/basic_file.h" 2 3



namespace std __attribute__ ((__visibility__ ("default")))
{



  template<typename _CharT>
    class __basic_file;


  template<>
    class __basic_file<char>
    {

      __c_file* _M_cfile;


      bool _M_cfile_created;

    public:
      __basic_file(__c_lock* __lock = 0) throw ();


      __basic_file(__basic_file&& __rv, __c_lock* = 0) noexcept
      : _M_cfile(__rv._M_cfile), _M_cfile_created(__rv._M_cfile_created)
      {
 __rv._M_cfile = nullptr;
 __rv._M_cfile_created = false;
      }

      __basic_file& operator=(const __basic_file&) = delete;
      __basic_file& operator=(__basic_file&&) = delete;

      void
      swap(__basic_file& __f) noexcept
      {
 std::swap(_M_cfile, __f._M_cfile);
 std::swap(_M_cfile_created, __f._M_cfile_created);
      }


      __basic_file*
      open(const char* __name, ios_base::openmode __mode, int __prot = 0664);






      __basic_file*
      sys_open(__c_file* __file, ios_base::openmode);

      __basic_file*
      sys_open(int __fd, ios_base::openmode __mode) throw ();

      __basic_file*
      close();

      __attribute__ ((__pure__)) bool
      is_open() const throw ();

      __attribute__ ((__pure__)) int
      fd() throw ();

      __attribute__ ((__pure__)) __c_file*
      file() throw ();

      ~__basic_file();

      streamsize
      xsputn(const char* __s, streamsize __n);

      streamsize
      xsputn_2(const char* __s1, streamsize __n1,
        const char* __s2, streamsize __n2);

      streamsize
      xsgetn(char* __s, streamsize __n);

      streamoff
      seekoff(streamoff __off, ios_base::seekdir __way) throw ();

      int
      sync();

      streamsize
      showmanyc();







      using native_handle_type = int;


      native_handle_type
      native_handle() const noexcept;

    };


}
# 45 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/fstream" 2 3





# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 51 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/fstream" 2 3






namespace std __attribute__ ((__visibility__ ("default")))
{




  template<typename _Path, typename _Result = _Path, typename _Path2
    = decltype(std::declval<_Path&>().make_preferred().filename())>
    using _If_fs_path = enable_if_t<is_same_v<_Path, _Path2>, _Result>;
# 89 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/fstream" 3
  template<typename _CharT, typename _Traits>
    class basic_filebuf : public basic_streambuf<_CharT, _Traits>
    {

      template<typename _Tp>
 using __chk_state = __and_<is_copy_assignable<_Tp>,
       is_copy_constructible<_Tp>,
       is_default_constructible<_Tp>>;

      static_assert(__chk_state<typename _Traits::state_type>::value,
      "state_type must be CopyAssignable, CopyConstructible"
      " and DefaultConstructible");

      static_assert(is_same<typename _Traits::pos_type,
       fpos<typename _Traits::state_type>>::value,
      "pos_type must be fpos<state_type>");

    public:

      typedef _CharT char_type;
      typedef _Traits traits_type;
      typedef typename traits_type::int_type int_type;
      typedef typename traits_type::pos_type pos_type;
      typedef typename traits_type::off_type off_type;

      typedef basic_streambuf<char_type, traits_type> __streambuf_type;
      typedef basic_filebuf<char_type, traits_type> __filebuf_type;
      typedef __basic_file<char> __file_type;
      typedef typename traits_type::state_type __state_type;
      typedef codecvt<char_type, char, __state_type> __codecvt_type;

      friend class ios_base;

    protected:


      __c_lock _M_lock;


      __file_type _M_file;


      ios_base::openmode _M_mode;


      __state_type _M_state_beg;




      __state_type _M_state_cur;



      __state_type _M_state_last;


      char_type* _M_buf;






      size_t _M_buf_size;


      bool _M_buf_allocated;
# 165 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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(); }
# 319 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/fstream" 3
      __filebuf_type*
      open(const char* __s, ios_base::openmode __mode);
# 340 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/fstream" 3
      __filebuf_type*
      open(const std::string& __s, ios_base::openmode __mode)
      { return open(__s.c_str(), __mode); }
# 351 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/fstream" 3
      template<typename _Path>
 _If_fs_path<_Path, __filebuf_type*>
 open(const _Path& __s, ios_base::openmode __mode)
 { return open(__s.c_str(), __mode); }
# 370 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/fstream" 3
      __filebuf_type*
      close();
# 403 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/fstream" 3
    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());
# 432 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/fstream" 3
      virtual int_type
      overflow(int_type __c = _Traits::eof());



      bool
      _M_convert_to_external(char_type*, streamsize);
# 452 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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();
# 498 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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);
      }
    };
# 531 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/fstream" 3
  template<typename _CharT, typename _Traits>
    class basic_ifstream : public basic_istream<_CharT, _Traits>
    {
    public:

      typedef _CharT char_type;
      typedef _Traits traits_type;
      typedef typename traits_type::int_type int_type;
      typedef typename traits_type::pos_type pos_type;
      typedef typename traits_type::off_type off_type;


      typedef basic_filebuf<char_type, traits_type> __filebuf_type;
      typedef basic_istream<char_type, traits_type> __istream_type;

    private:
      __filebuf_type _M_filebuf;

    public:
# 558 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/fstream" 3
      basic_ifstream() : __istream_type(), _M_filebuf()
      { this->init(&_M_filebuf); }
# 568 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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);
      }
# 601 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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);
      }
# 618 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/fstream" 3
      template<typename _Path, typename _Require = _If_fs_path<_Path>>
 basic_ifstream(const _Path& __s,
         ios_base::openmode __mode = ios_base::in)
 : basic_ifstream(__s.c_str(), __mode)
 { }


      basic_ifstream(const basic_ifstream&) = delete;

      basic_ifstream(basic_ifstream&& __rhs)
      : __istream_type(std::move(__rhs)),
      _M_filebuf(std::move(__rhs._M_filebuf))
      { __istream_type::set_rdbuf(&_M_filebuf); }
# 639 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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);
      }
# 671 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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(); }
# 697 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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();
      }
# 736 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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();
      }
# 756 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/fstream" 3
      template<typename _Path>
 _If_fs_path<_Path, void>
 open(const _Path& __s, ios_base::openmode __mode = ios_base::in)
 { open(__s.c_str(), __mode); }
# 769 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/fstream" 3
      void
      close()
      {
 if (!_M_filebuf.close())
   this->setstate(ios_base::failbit);
      }
# 784 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/fstream" 3
    };
# 801 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/fstream" 3
  template<typename _CharT, typename _Traits>
    class basic_ofstream : public basic_ostream<_CharT,_Traits>
    {
    public:

      typedef _CharT char_type;
      typedef _Traits traits_type;
      typedef typename traits_type::int_type int_type;
      typedef typename traits_type::pos_type pos_type;
      typedef typename traits_type::off_type off_type;


      typedef basic_filebuf<char_type, traits_type> __filebuf_type;
      typedef basic_ostream<char_type, traits_type> __ostream_type;

    private:
      __filebuf_type _M_filebuf;

    public:
# 828 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/fstream" 3
      basic_ofstream(): __ostream_type(), _M_filebuf()
      { this->init(&_M_filebuf); }
# 838 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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);
      }
# 873 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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);
      }
# 890 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/fstream" 3
      template<typename _Path, typename _Require = _If_fs_path<_Path>>
 basic_ofstream(const _Path& __s,
         ios_base::openmode __mode = ios_base::out)
 : basic_ofstream(__s.c_str(), __mode)
 { }


      basic_ofstream(const basic_ofstream&) = delete;

      basic_ofstream(basic_ofstream&& __rhs)
      : __ostream_type(std::move(__rhs)),
      _M_filebuf(std::move(__rhs._M_filebuf))
      { __ostream_type::set_rdbuf(&_M_filebuf); }
# 911 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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);
      }
# 943 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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(); }
# 969 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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();
      }
# 1008 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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();
      }
# 1028 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/fstream" 3
      template<typename _Path>
 _If_fs_path<_Path, void>
 open(const _Path& __s, ios_base::openmode __mode = ios_base::out)
 { open(__s.c_str(), __mode); }
# 1041 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/fstream" 3
      void
      close()
      {
 if (!_M_filebuf.close())
   this->setstate(ios_base::failbit);
      }
# 1056 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/fstream" 3
    };
# 1073 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/fstream" 3
  template<typename _CharT, typename _Traits>
    class basic_fstream : public basic_iostream<_CharT, _Traits>
    {
    public:

      typedef _CharT char_type;
      typedef _Traits traits_type;
      typedef typename traits_type::int_type int_type;
      typedef typename traits_type::pos_type pos_type;
      typedef typename traits_type::off_type off_type;


      typedef basic_filebuf<char_type, traits_type> __filebuf_type;
      typedef basic_ios<char_type, traits_type> __ios_type;
      typedef basic_iostream<char_type, traits_type> __iostream_type;

    private:
      __filebuf_type _M_filebuf;

    public:
# 1101 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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);
      }
# 1140 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/fstream" 3
      explicit
      basic_fstream(const std::string& __s,
      ios_base::openmode __mode = ios_base::in | ios_base::out)
      : __iostream_type(0), _M_filebuf()
      {
 this->init(&_M_filebuf);
 this->open(__s, __mode);
      }







      template<typename _Path, typename _Require = _If_fs_path<_Path>>
 basic_fstream(const _Path& __s,
        ios_base::openmode __mode = ios_base::in | ios_base::out)
 : basic_fstream(__s.c_str(), __mode)
 { }


      basic_fstream(const basic_fstream&) = delete;

      basic_fstream(basic_fstream&& __rhs)
      : __iostream_type(std::move(__rhs)),
      _M_filebuf(std::move(__rhs._M_filebuf))
      { __iostream_type::set_rdbuf(&_M_filebuf); }
# 1176 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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);
      }
# 1208 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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(); }
# 1234 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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();
      }
# 1275 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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();
      }
# 1296 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/fstream" 3
      template<typename _Path>
 _If_fs_path<_Path, void>
 open(const _Path& __s,
      ios_base::openmode __mode = ios_base::in | ios_base::out)
 { open(__s.c_str(), __mode); }
# 1310 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/fstream" 3
      void
      close()
      {
 if (!_M_filebuf.close())
   this->setstate(ios_base::failbit);
      }
# 1325 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/fstream" 3
    };



  template <class _CharT, class _Traits>
    inline void
    swap(basic_filebuf<_CharT, _Traits>& __x,
  basic_filebuf<_CharT, _Traits>& __y)
    { __x.swap(__y); }


  template <class _CharT, class _Traits>
    inline void
    swap(basic_ifstream<_CharT, _Traits>& __x,
  basic_ifstream<_CharT, _Traits>& __y)
    { __x.swap(__y); }


  template <class _CharT, class _Traits>
    inline void
    swap(basic_ofstream<_CharT, _Traits>& __x,
  basic_ofstream<_CharT, _Traits>& __y)
    { __x.swap(__y); }


  template <class _CharT, class _Traits>
    inline void
    swap(basic_fstream<_CharT, _Traits>& __x,
  basic_fstream<_CharT, _Traits>& __y)
    { __x.swap(__y); }



}

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/fstream.tcc" 1 3
# 38 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/fstream.tcc" 3



# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cerrno" 1 3
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cerrno" 3
# 42 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/fstream.tcc" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{


  template<typename _CharT, typename _Traits>
    void
    basic_filebuf<_CharT, _Traits>::
    _M_allocate_internal_buffer()
    {


      if (!_M_buf_allocated && !_M_buf)
 {
   _M_buf = new char_type[_M_buf_size];
   _M_buf_allocated = true;
 }
    }

  template<typename _CharT, typename _Traits>
    void
    basic_filebuf<_CharT, _Traits>::
    _M_destroy_internal_buffer() throw()
    {
      if (_M_buf_allocated)
 {
   delete [] _M_buf;
   _M_buf = 0;
   _M_buf_allocated = false;
 }
      delete [] _M_ext_buf;
      _M_ext_buf = 0;
      _M_ext_buf_size = 0;
      _M_ext_next = 0;
      _M_ext_end = 0;
    }

  template<typename _CharT, typename _Traits>
    basic_filebuf<_CharT, _Traits>::
    basic_filebuf() : __streambuf_type(), _M_lock(), _M_file(&_M_lock),
    _M_mode(ios_base::openmode(0)), _M_state_beg(), _M_state_cur(),
    _M_state_last(), _M_buf(0), _M_buf_size(8192),
    _M_buf_allocated(false), _M_reading(false), _M_writing(false), _M_pback(),
    _M_pback_cur_save(0), _M_pback_end_save(0), _M_pback_init(false),
    _M_codecvt(0), _M_ext_buf(0), _M_ext_buf_size(0), _M_ext_next(0),
    _M_ext_end(0)
    {
      _M_codecvt = std::__try_use_facet<__codecvt_type>(this->_M_buf_locale);
    }


  template<typename _CharT, typename _Traits>
    basic_filebuf<_CharT, _Traits>::
    basic_filebuf(basic_filebuf&& __rhs)
    : __streambuf_type(__rhs),
    _M_lock(), _M_file(std::move(__rhs._M_file), &_M_lock),
    _M_mode(std::__exchange(__rhs._M_mode, ios_base::openmode(0))),
    _M_state_beg(std::move(__rhs._M_state_beg)),
    _M_state_cur(std::move(__rhs._M_state_cur)),
    _M_state_last(std::move(__rhs._M_state_last)),
    _M_buf(std::__exchange(__rhs._M_buf, nullptr)),
    _M_buf_size(std::__exchange(__rhs._M_buf_size, 1)),
    _M_buf_allocated(std::__exchange(__rhs._M_buf_allocated, false)),
    _M_reading(std::__exchange(__rhs._M_reading, false)),
    _M_writing(std::__exchange(__rhs._M_writing, false)),
    _M_pback(__rhs._M_pback),
    _M_pback_cur_save(std::__exchange(__rhs._M_pback_cur_save, nullptr)),
    _M_pback_end_save(std::__exchange(__rhs._M_pback_end_save, nullptr)),
    _M_pback_init(std::__exchange(__rhs._M_pback_init, false)),
    _M_codecvt(__rhs._M_codecvt),
    _M_ext_buf(std::__exchange(__rhs._M_ext_buf, nullptr)),
    _M_ext_buf_size(std::__exchange(__rhs._M_ext_buf_size, 0)),
    _M_ext_next(std::__exchange(__rhs._M_ext_next, nullptr)),
    _M_ext_end(std::__exchange(__rhs._M_ext_end, nullptr))
    {
      __rhs._M_set_buffer(-1);
      __rhs._M_state_last = __rhs._M_state_cur = __rhs._M_state_beg;
    }

  template<typename _CharT, typename _Traits>
    basic_filebuf<_CharT, _Traits>&
    basic_filebuf<_CharT, _Traits>::
    operator=(basic_filebuf&& __rhs)
    {
      this->close();
      __streambuf_type::operator=(__rhs);
      _M_file.swap(__rhs._M_file);
      _M_mode = std::__exchange(__rhs._M_mode, ios_base::openmode(0));
      _M_state_beg = std::move(__rhs._M_state_beg);
      _M_state_cur = std::move(__rhs._M_state_cur);
      _M_state_last = std::move(__rhs._M_state_last);
      _M_buf = std::__exchange(__rhs._M_buf, nullptr);
      _M_buf_size = std::__exchange(__rhs._M_buf_size, 1);
      _M_buf_allocated = std::__exchange(__rhs._M_buf_allocated, false);
      _M_ext_buf = std::__exchange(__rhs._M_ext_buf, nullptr);
      _M_ext_buf_size = std::__exchange(__rhs._M_ext_buf_size, 0);
      _M_ext_next = std::__exchange(__rhs._M_ext_next, nullptr);
      _M_ext_end = std::__exchange(__rhs._M_ext_end, nullptr);
      _M_reading = std::__exchange(__rhs._M_reading, false);
      _M_writing = std::__exchange(__rhs._M_writing, false);
      _M_pback_cur_save = std::__exchange(__rhs._M_pback_cur_save, nullptr);
      _M_pback_end_save = std::__exchange(__rhs._M_pback_end_save, nullptr);
      _M_pback_init = std::__exchange(__rhs._M_pback_init, false);
      __rhs._M_set_buffer(-1);
      __rhs._M_state_last = __rhs._M_state_cur = __rhs._M_state_beg;
      return *this;
    }

  template<typename _CharT, typename _Traits>
    void
    basic_filebuf<_CharT, _Traits>::
    swap(basic_filebuf& __rhs)
    {
      __streambuf_type::swap(__rhs);
      _M_file.swap(__rhs._M_file);
      std::swap(_M_mode, __rhs._M_mode);
      std::swap(_M_state_beg, __rhs._M_state_beg);
      std::swap(_M_state_cur, __rhs._M_state_cur);
      std::swap(_M_state_last, __rhs._M_state_last);
      std::swap(_M_buf, __rhs._M_buf);
      std::swap(_M_buf_size, __rhs._M_buf_size);
      std::swap(_M_buf_allocated, __rhs._M_buf_allocated);
      std::swap(_M_ext_buf, __rhs._M_ext_buf);
      std::swap(_M_ext_buf_size, __rhs._M_ext_buf_size);
      std::swap(_M_ext_next, __rhs._M_ext_next);
      std::swap(_M_ext_end, __rhs._M_ext_end);
      std::swap(_M_reading, __rhs._M_reading);
      std::swap(_M_writing, __rhs._M_writing);
      std::swap(_M_pback_cur_save, __rhs._M_pback_cur_save);
      std::swap(_M_pback_end_save, __rhs._M_pback_end_save);
      std::swap(_M_pback_init, __rhs._M_pback_init);
    }


  template<typename _CharT, typename _Traits>
    typename basic_filebuf<_CharT, _Traits>::__filebuf_type*
    basic_filebuf<_CharT, _Traits>::
    open(const char* __s, ios_base::openmode __mode)
    {
      __filebuf_type *__ret = 0;
      if (!this->is_open())
 {
   _M_file.open(__s, __mode);
   if (this->is_open())
     {
       _M_allocate_internal_buffer();
       _M_mode = __mode;


       _M_reading = false;
       _M_writing = false;
       _M_set_buffer(-1);


       _M_state_last = _M_state_cur = _M_state_beg;


       if ((__mode & ios_base::ate)
    && this->seekoff(0, ios_base::end, __mode)
    == pos_type(off_type(-1)))
  this->close();
       else
  __ret = this;
     }
 }
      return __ret;
    }
# 246 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/fstream.tcc" 3
  template<typename _CharT, typename _Traits>
    typename basic_filebuf<_CharT, _Traits>::__filebuf_type*
    basic_filebuf<_CharT, _Traits>::
    close()
    {
      if (!this->is_open())
 return 0;

      bool __testfail = false;
      {

 struct __close_sentry
 {
   basic_filebuf *__fb;
   __close_sentry (basic_filebuf *__fbi): __fb(__fbi) { }
   ~__close_sentry ()
   {
     __fb->_M_mode = ios_base::openmode(0);
     __fb->_M_pback_init = false;
     __fb->_M_destroy_internal_buffer();
     __fb->_M_reading = false;
     __fb->_M_writing = false;
     __fb->_M_set_buffer(-1);
     __fb->_M_state_last = __fb->_M_state_cur = __fb->_M_state_beg;
   }
 } __cs (this);

 try
   {
     if (!_M_terminate_output())
       __testfail = true;
   }
 catch(...)
   {
     _M_file.close();
     throw;
   }
      }

      if (!_M_file.close())
 __testfail = true;

      if (__testfail)
 return 0;
      else
 return this;
    }

  template<typename _CharT, typename _Traits>
    streamsize
    basic_filebuf<_CharT, _Traits>::
    showmanyc()
    {
      streamsize __ret = -1;
      const bool __testin = _M_mode & ios_base::in;
      if (__testin && this->is_open())
 {


   __ret = this->egptr() - this->gptr();







   if (__check_facet(_M_codecvt).encoding() >= 0)

     __ret += _M_file.showmanyc() / _M_codecvt->max_length();
 }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    typename basic_filebuf<_CharT, _Traits>::int_type
    basic_filebuf<_CharT, _Traits>::
    underflow()
    {
      int_type __ret = traits_type::eof();
      const bool __testin = _M_mode & ios_base::in;
      if (__testin)
 {
   if (_M_writing)
     {
       if (overflow() == traits_type::eof())
  return __ret;
       _M_set_buffer(-1);
       _M_writing = false;
     }



   _M_destroy_pback();

   if (this->gptr() < this->egptr())
     return traits_type::to_int_type(*this->gptr());


   const size_t __buflen = _M_buf_size > 1 ? _M_buf_size - 1 : 1;


   bool __got_eof = false;

   streamsize __ilen = 0;
   codecvt_base::result __r = codecvt_base::ok;
   if (__check_facet(_M_codecvt).always_noconv())
     {
       __ilen = _M_file.xsgetn(reinterpret_cast<char*>(this->eback()),
          __buflen);
       if (__ilen == 0)
  __got_eof = true;
     }
   else
     {


       const int __enc = _M_codecvt->encoding();
       streamsize __blen;
       streamsize __rlen;
       if (__enc > 0)
  __blen = __rlen = __buflen * __enc;
       else
  {
    __blen = __buflen + _M_codecvt->max_length() - 1;
    __rlen = __buflen;
  }
       const streamsize __remainder = _M_ext_end - _M_ext_next;
       __rlen = __rlen > __remainder ? __rlen - __remainder : 0;



       if (_M_reading && this->egptr() == this->eback() && __remainder)
  __rlen = 0;



       if (_M_ext_buf_size < __blen)
  {
    char* __buf = new char[__blen];
    if (__remainder)
      __builtin_memcpy(__buf, _M_ext_next, __remainder);

    delete [] _M_ext_buf;
    _M_ext_buf = __buf;
    _M_ext_buf_size = __blen;
  }
       else if (__remainder)
  __builtin_memmove(_M_ext_buf, _M_ext_next, __remainder);

       _M_ext_next = _M_ext_buf;
       _M_ext_end = _M_ext_buf + __remainder;
       _M_state_last = _M_state_cur;

       do
  {
    if (__rlen > 0)
      {



        if (_M_ext_end - _M_ext_buf + __rlen > _M_ext_buf_size)
   {
     __throw_ios_failure(("basic_filebuf::underflow " "codecvt::max_length() " "is not valid"));


   }
        streamsize __elen = _M_file.xsgetn(_M_ext_end, __rlen);
        if (__elen == 0)
   __got_eof = true;
        else if (__elen == -1)
   break;
        _M_ext_end += __elen;
      }

    char_type* __iend = this->eback();
    if (_M_ext_next < _M_ext_end)
      __r = _M_codecvt->in(_M_state_cur, _M_ext_next,
      _M_ext_end, _M_ext_next,
      this->eback(),
      this->eback() + __buflen, __iend);
    if (__r == codecvt_base::noconv)
      {
        size_t __avail = _M_ext_end - _M_ext_buf;
        __ilen = std::min(__avail, __buflen);
        traits_type::copy(this->eback(),
     reinterpret_cast<char_type*>
     (_M_ext_buf), __ilen);
        _M_ext_next = _M_ext_buf + __ilen;
      }
    else
      __ilen = __iend - this->eback();




    if (__r == codecvt_base::error)
      break;

    __rlen = 1;
  }
       while (__ilen == 0 && !__got_eof);
     }

   if (__ilen > 0)
     {
       _M_set_buffer(__ilen);
       _M_reading = true;
       __ret = traits_type::to_int_type(*this->gptr());
     }
   else if (__got_eof)
     {



       _M_set_buffer(-1);
       _M_reading = false;


       if (__r == codecvt_base::partial)
  __throw_ios_failure(("basic_filebuf::underflow " "incomplete character in file"));

     }
   else if (__r == codecvt_base::error)
     __throw_ios_failure(("basic_filebuf::underflow " "invalid byte sequence in file"));

   else
     __throw_ios_failure(("basic_filebuf::underflow " "error reading the file"), (*__errno_location ()));

 }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    typename basic_filebuf<_CharT, _Traits>::int_type
    basic_filebuf<_CharT, _Traits>::
    pbackfail(int_type __i)
    {
      int_type __ret = traits_type::eof();
      const bool __testin = _M_mode & ios_base::in;
      if (__testin)
 {
   if (_M_writing)
     {
       if (overflow() == traits_type::eof())
  return __ret;
       _M_set_buffer(-1);
       _M_writing = false;
     }


   const bool __testpb = _M_pback_init;
   const bool __testeof = traits_type::eq_int_type(__i, __ret);
   int_type __tmp;
   if (this->eback() < this->gptr())
     {
       this->gbump(-1);
       __tmp = traits_type::to_int_type(*this->gptr());
     }
   else if (this->seekoff(-1, ios_base::cur) != pos_type(off_type(-1)))
     {
       __tmp = this->underflow();
       if (traits_type::eq_int_type(__tmp, __ret))
  return __ret;
     }
   else
     {





       return __ret;
     }



   if (!__testeof && traits_type::eq_int_type(__i, __tmp))
     __ret = __i;
   else if (__testeof)
     __ret = traits_type::not_eof(__i);
   else if (!__testpb)
     {
       _M_create_pback();
       _M_reading = true;
       *this->gptr() = traits_type::to_char_type(__i);
       __ret = __i;
     }
 }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    typename basic_filebuf<_CharT, _Traits>::int_type
    basic_filebuf<_CharT, _Traits>::
    overflow(int_type __c)
    {
      int_type __ret = traits_type::eof();
      const bool __testeof = traits_type::eq_int_type(__c, __ret);
      const bool __testout = (_M_mode & ios_base::out
         || _M_mode & ios_base::app);
      if (__testout)
 {
          if (_M_reading)
            {
              _M_destroy_pback();
              const int __gptr_off = _M_get_ext_pos(_M_state_last);
              if (_M_seek(__gptr_off, ios_base::cur, _M_state_last)
                  == pos_type(off_type(-1)))
                return __ret;
            }
   if (this->pbase() < this->pptr())
     {

       if (!__testeof)
  {
    *this->pptr() = traits_type::to_char_type(__c);
    this->pbump(1);
  }



       if (_M_convert_to_external(this->pbase(),
      this->pptr() - this->pbase()))
  {
    _M_set_buffer(0);
    __ret = traits_type::not_eof(__c);
  }
     }
   else if (_M_buf_size > 1)
     {



       _M_set_buffer(0);
       _M_writing = true;
       if (!__testeof)
  {
    *this->pptr() = traits_type::to_char_type(__c);
    this->pbump(1);
  }
       __ret = traits_type::not_eof(__c);
     }
   else
     {

       char_type __conv = traits_type::to_char_type(__c);
       if (__testeof || _M_convert_to_external(&__conv, 1))
  {
    _M_writing = true;
    __ret = traits_type::not_eof(__c);
  }
     }
 }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    bool
    basic_filebuf<_CharT, _Traits>::
    _M_convert_to_external(_CharT* __ibuf, streamsize __ilen)
    {

      streamsize __elen;
      streamsize __plen;
      if (__check_facet(_M_codecvt).always_noconv())
 {
   __elen = _M_file.xsputn(reinterpret_cast<char*>(__ibuf), __ilen);
   __plen = __ilen;
 }
      else
 {


   streamsize __blen = __ilen * _M_codecvt->max_length();
   char* __buf = static_cast<char*>(__builtin_alloca(__blen));

   char* __bend;
   const char_type* __iend;
   codecvt_base::result __r;
   __r = _M_codecvt->out(_M_state_cur, __ibuf, __ibuf + __ilen,
    __iend, __buf, __buf + __blen, __bend);

   if (__r == codecvt_base::ok || __r == codecvt_base::partial)
     __blen = __bend - __buf;
   else if (__r == codecvt_base::noconv)
     {

       __buf = reinterpret_cast<char*>(__ibuf);
       __blen = __ilen;
     }
   else
     __throw_ios_failure(("basic_filebuf::_M_convert_to_external " "conversion error"));


   __elen = _M_file.xsputn(__buf, __blen);
   __plen = __blen;


   if (__r == codecvt_base::partial && __elen == __plen)
     {
       const char_type* __iresume = __iend;
       streamsize __rlen = this->pptr() - __iend;
       __r = _M_codecvt->out(_M_state_cur, __iresume,
        __iresume + __rlen, __iend, __buf,
        __buf + __blen, __bend);
       if (__r != codecvt_base::error)
  {
    __rlen = __bend - __buf;
    __elen = _M_file.xsputn(__buf, __rlen);
    __plen = __rlen;
  }
       else
  __throw_ios_failure(("basic_filebuf::_M_convert_to_external " "conversion error"));

     }
 }
      return __elen == __plen;
    }

  template<typename _CharT, typename _Traits>
    streamsize
    basic_filebuf<_CharT, _Traits>::
    xsgetn(_CharT* __s, streamsize __n)
    {

      streamsize __ret = 0;
      if (_M_pback_init)
 {
   if (__n > 0 && this->gptr() == this->eback())
     {
       *__s++ = *this->gptr();
       this->gbump(1);
       __ret = 1;
       --__n;
     }
   _M_destroy_pback();
 }
      else if (_M_writing)
 {
   if (overflow() == traits_type::eof())
     return __ret;
   _M_set_buffer(-1);
   _M_writing = false;
 }




      const bool __testin = _M_mode & ios_base::in;
      const streamsize __buflen = _M_buf_size > 1 ? _M_buf_size - 1 : 1;

      if (__n > __buflen && __check_facet(_M_codecvt).always_noconv()
   && __testin)
 {

   const streamsize __avail = this->egptr() - this->gptr();
   if (__avail != 0)
     {
       traits_type::copy(__s, this->gptr(), __avail);
       __s += __avail;
       this->setg(this->eback(), this->gptr() + __avail, this->egptr());
       __ret += __avail;
       __n -= __avail;
     }



   streamsize __len;
   for (;;)
     {
       __len = _M_file.xsgetn(reinterpret_cast<char*>(__s), __n);
       if (__len == -1)
  __throw_ios_failure(("basic_filebuf::xsgetn " "error reading the file"), (*__errno_location ()));

       if (__len == 0)
  break;

       __n -= __len;
       __ret += __len;
       if (__n == 0)
  break;

       __s += __len;
     }

   if (__n == 0)
     {

       _M_reading = true;
     }
   else if (__len == 0)
     {



       _M_set_buffer(-1);
       _M_reading = false;
     }
 }
      else
 __ret += __streambuf_type::xsgetn(__s, __n);

      return __ret;
    }

  template<typename _CharT, typename _Traits>
    streamsize
    basic_filebuf<_CharT, _Traits>::
    xsputn(const _CharT* __s, streamsize __n)
    {
      streamsize __ret = 0;



      const bool __testout = (_M_mode & ios_base::out
         || _M_mode & ios_base::app);
      if (__check_facet(_M_codecvt).always_noconv()
   && __testout && !_M_reading)
 {
   streamsize __bufavail = this->epptr() - this->pptr();


   if (!_M_writing && _M_buf_size > 1)
     __bufavail = _M_buf_size - 1;

   if (__n >= __bufavail)
     {
       const streamsize __buffill = this->pptr() - this->pbase();
       const char* __buf = reinterpret_cast<const char*>(this->pbase());
       __ret = _M_file.xsputn_2(__buf, __buffill,
           reinterpret_cast<const char*>(__s),
           __n);
       if (__ret == __buffill + __n)
  {
    _M_set_buffer(0);
    _M_writing = true;
  }
       if (__ret > __buffill)
  __ret -= __buffill;
       else
  __ret = 0;
     }
   else
     __ret = __streambuf_type::xsputn(__s, __n);
 }
       else
  __ret = __streambuf_type::xsputn(__s, __n);
       return __ret;
    }

  template<typename _CharT, typename _Traits>
    typename basic_filebuf<_CharT, _Traits>::__streambuf_type*
    basic_filebuf<_CharT, _Traits>::
    setbuf(char_type* __s, streamsize __n)
    {
      if (!this->is_open())
 {
   if (__s == 0 && __n == 0)
     _M_buf_size = 1;
   else if (__s && __n > 0)
     {
# 816 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/fstream.tcc" 3
       _M_buf = __s;
       _M_buf_size = __n;
     }
 }
      return this;
    }




  template<typename _CharT, typename _Traits>
    typename basic_filebuf<_CharT, _Traits>::pos_type
    basic_filebuf<_CharT, _Traits>::
    seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode)
    {
      int __width = 0;
      if (_M_codecvt)
 __width = _M_codecvt->encoding();
      if (__width < 0)
 __width = 0;

      pos_type __ret = pos_type(off_type(-1));
      const bool __testfail = __off != 0 && __width <= 0;
      if (this->is_open() && !__testfail)
 {




   bool __no_movement = __way == ios_base::cur && __off == 0
     && (!_M_writing || _M_codecvt->always_noconv());


   if (!__no_movement)
     _M_destroy_pback();






   __state_type __state = _M_state_beg;
   off_type __computed_off = __off * __width;
   if (_M_reading && __way == ios_base::cur)
     {
       __state = _M_state_last;
       __computed_off += _M_get_ext_pos(__state);
     }
   if (!__no_movement)
     __ret = _M_seek(__computed_off, __way, __state);
   else
     {
       if (_M_writing)
  __computed_off = this->pptr() - this->pbase();

       off_type __file_off = _M_file.seekoff(0, ios_base::cur);
       if (__file_off != off_type(-1))
  {
    __ret = __file_off + __computed_off;
    __ret.state(__state);
  }
     }
 }
      return __ret;
    }





  template<typename _CharT, typename _Traits>
    typename basic_filebuf<_CharT, _Traits>::pos_type
    basic_filebuf<_CharT, _Traits>::
    seekpos(pos_type __pos, ios_base::openmode)
    {
      pos_type __ret = pos_type(off_type(-1));
      if (this->is_open())
 {

   _M_destroy_pback();
   __ret = _M_seek(off_type(__pos), ios_base::beg, __pos.state());
 }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    typename basic_filebuf<_CharT, _Traits>::pos_type
    basic_filebuf<_CharT, _Traits>::
    _M_seek(off_type __off, ios_base::seekdir __way, __state_type __state)
    {
      pos_type __ret = pos_type(off_type(-1));
      if (_M_terminate_output())
 {
   off_type __file_off = _M_file.seekoff(__off, __way);
   if (__file_off != off_type(-1))
     {
       _M_reading = false;
       _M_writing = false;
       _M_ext_next = _M_ext_end = _M_ext_buf;
       _M_set_buffer(-1);
       _M_state_cur = __state;
       __ret = __file_off;
       __ret.state(_M_state_cur);
     }
 }
      return __ret;
    }




  template<typename _CharT, typename _Traits>
    int basic_filebuf<_CharT, _Traits>::
    _M_get_ext_pos(__state_type& __state)
    {
      if (_M_codecvt->always_noconv())
        return this->gptr() - this->egptr();
      else
        {



          const int __gptr_off =
            _M_codecvt->length(__state, _M_ext_buf, _M_ext_next,
                               this->gptr() - this->eback());
          return _M_ext_buf + __gptr_off - _M_ext_end;
        }
    }

  template<typename _CharT, typename _Traits>
    bool
    basic_filebuf<_CharT, _Traits>::
    _M_terminate_output()
    {

      bool __testvalid = true;
      if (this->pbase() < this->pptr())
 {
   const int_type __tmp = this->overflow();
   if (traits_type::eq_int_type(__tmp, traits_type::eof()))
     __testvalid = false;
 }


      if (_M_writing && !__check_facet(_M_codecvt).always_noconv()
   && __testvalid)
 {



   const size_t __blen = 128;
   char __buf[__blen];
   codecvt_base::result __r;
   streamsize __ilen = 0;

   do
     {
       char* __next;
       __r = _M_codecvt->unshift(_M_state_cur, __buf,
     __buf + __blen, __next);
       if (__r == codecvt_base::error)
  __testvalid = false;
       else if (__r == codecvt_base::ok ||
         __r == codecvt_base::partial)
  {
    __ilen = __next - __buf;
    if (__ilen > 0)
      {
        const streamsize __elen = _M_file.xsputn(__buf, __ilen);
        if (__elen != __ilen)
   __testvalid = false;
      }
  }
     }
   while (__r == codecvt_base::partial && __ilen > 0 && __testvalid);

   if (__testvalid)
     {




       const int_type __tmp = this->overflow();
       if (traits_type::eq_int_type(__tmp, traits_type::eof()))
  __testvalid = false;
     }
 }
      return __testvalid;
    }

  template<typename _CharT, typename _Traits>
    int
    basic_filebuf<_CharT, _Traits>::
    sync()
    {


      int __ret = 0;
      if (this->pbase() < this->pptr())
 {
   const int_type __tmp = this->overflow();
   if (traits_type::eq_int_type(__tmp, traits_type::eof()))
     __ret = -1;
 }
      return __ret;
    }

  template<typename _CharT, typename _Traits>
    void
    basic_filebuf<_CharT, _Traits>::
    imbue(const locale& __loc)
    {
      bool __testvalid = true;

      const __codecvt_type* const _M_codecvt_tmp
 = __try_use_facet<__codecvt_type>(__loc);

      if (this->is_open())
 {

   if ((_M_reading || _M_writing)
       && __check_facet(_M_codecvt).encoding() == -1)
     __testvalid = false;
   else
     {
       if (_M_reading)
  {
    if (__check_facet(_M_codecvt).always_noconv())
      {
        if (_M_codecvt_tmp
     && !__check_facet(_M_codecvt_tmp).always_noconv())
   __testvalid = this->seekoff(0, ios_base::cur, _M_mode)
                 != pos_type(off_type(-1));
      }
    else
      {

        _M_ext_next = _M_ext_buf
   + _M_codecvt->length(_M_state_last, _M_ext_buf,
          _M_ext_next,
          this->gptr() - this->eback());
        const streamsize __remainder = _M_ext_end - _M_ext_next;
        if (__remainder)
   __builtin_memmove(_M_ext_buf, _M_ext_next, __remainder);

        _M_ext_next = _M_ext_buf;
        _M_ext_end = _M_ext_buf + __remainder;
        _M_set_buffer(-1);
        _M_state_last = _M_state_cur = _M_state_beg;
      }
  }
       else if (_M_writing && (__testvalid = _M_terminate_output()))
  _M_set_buffer(-1);
     }
 }

      if (__testvalid)
 _M_codecvt = _M_codecvt_tmp;
      else
 _M_codecvt = 0;
    }




  extern template class basic_filebuf<char>;
  extern template class basic_ifstream<char>;
  extern template class basic_ofstream<char>;
  extern template class basic_fstream<char>;


  extern template class basic_filebuf<wchar_t>;
  extern template class basic_ifstream<wchar_t>;
  extern template class basic_ofstream<wchar_t>;
  extern template class basic_fstream<wchar_t>;




}
# 1361 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/fstream" 2 3
# 12 "/usr/include/fmt/ostream.h" 2 3 4
# 23 "/usr/include/fmt/ostream.h" 3 4
namespace fmt { inline namespace v10 {
namespace detail {

template <typename Streambuf> class formatbuf : public Streambuf {
 private:
  using char_type = typename Streambuf::char_type;
  using streamsize = decltype(std::declval<Streambuf>().sputn(nullptr, 0));
  using int_type = typename Streambuf::int_type;
  using traits_type = typename Streambuf::traits_type;

  buffer<char_type>& buffer_;

 public:
  explicit formatbuf(buffer<char_type>& buf) : buffer_(buf) {}

 protected:






  auto overflow(int_type ch) -> int_type override {
    if (!traits_type::eq_int_type(ch, traits_type::eof()))
      buffer_.push_back(static_cast<char_type>(ch));
    return ch;
  }

  auto xsputn(const char_type* s, streamsize count) -> streamsize override {
    buffer_.append(s, s + count);
    return count;
  }
};



namespace {
struct file_access_tag {};
}
template <typename Tag, typename BufType, FILE* BufType::*FileMemberPtr>
class file_access {
  friend auto get_file(BufType& obj) -> FILE* { return obj.*FileMemberPtr; }
};







inline auto write_ostream_unicode(std::ostream& os, fmt::string_view data)
    -> bool {
  FILE* f = nullptr;
# 90 "/usr/include/fmt/ostream.h" 3 4
  ignore_unused(os, data, f);
# 101 "/usr/include/fmt/ostream.h" 3 4
  return false;
}
inline auto write_ostream_unicode(std::wostream&,
                                  fmt::basic_string_view<wchar_t>) -> bool {
  return false;
}



template <typename Char>
void write_buffer(std::basic_ostream<Char>& os, buffer<Char>& buf) {
  const Char* buf_data = buf.data();
  using unsigned_streamsize = std::make_unsigned<std::streamsize>::type;
  unsigned_streamsize size = buf.size();
  unsigned_streamsize max_size = to_unsigned(max_value<std::streamsize>());
  do {
    unsigned_streamsize n = size <= max_size ? size : max_size;
    os.write(buf_data, static_cast<std::streamsize>(n));
    buf_data += n;
    size -= n;
  } while (size != 0);
}

template <typename Char, typename T>
void format_value(buffer<Char>& buf, const T& value) {
  auto&& format_buf = formatbuf<std::basic_streambuf<Char>>(buf);
  auto&& output = std::basic_ostream<Char>(&format_buf);

  output.imbue(std::locale::classic());

  output << value;
  output.exceptions(std::ios_base::failbit | std::ios_base::badbit);
}

template <typename T> struct streamed_view {
  const T& value;
};

}


template <typename Char>
struct basic_ostream_formatter : formatter<basic_string_view<Char>, Char> {
  void set_debug_format() = delete;

  template <typename T, typename OutputIt>
  auto format(const T& value, basic_format_context<OutputIt, Char>& ctx) const
      -> OutputIt {
    auto buffer = basic_memory_buffer<Char>();
    detail::format_value(buffer, value);
    return formatter<basic_string_view<Char>, Char>::format(
        {buffer.data(), buffer.size()}, ctx);
  }
};

using ostream_formatter = basic_ostream_formatter<char>;

template <typename T, typename Char>
struct formatter<detail::streamed_view<T>, Char>
    : basic_ostream_formatter<Char> {
  template <typename OutputIt>
  auto format(detail::streamed_view<T> view,
              basic_format_context<OutputIt, Char>& ctx) const -> OutputIt {
    return basic_ostream_formatter<Char>::format(view.value, ctx);
  }
};
# 178 "/usr/include/fmt/ostream.h" 3 4
template <typename T>
constexpr auto streamed(const T& value) -> detail::streamed_view<T> {
  return {value};
}

namespace detail {

inline void vprint_directly(std::ostream& os, string_view format_str,
                            format_args args) {
  auto buffer = memory_buffer();
  detail::vformat_to(buffer, format_str, args);
  detail::write_buffer(os, buffer);
}

}

           template <typename Char>
void vprint(std::basic_ostream<Char>& os,
            basic_string_view<type_identity_t<Char>> format_str,
            basic_format_args<buffer_context<type_identity_t<Char>>> args) {
  auto buffer = basic_memory_buffer<Char>();
  detail::vformat_to(buffer, format_str, args);
  if (detail::write_ostream_unicode(os, {buffer.data(), buffer.size()})) return;
  detail::write_buffer(os, buffer);
}
# 213 "/usr/include/fmt/ostream.h" 3 4
           template <typename... T>
void print(std::ostream& os, format_string<T...> fmt, T&&... args) {
  const auto& vargs = fmt::make_format_args(args...);
  if (detail::is_utf8())
    vprint(os, fmt, vargs);
  else
    detail::vprint_directly(os, fmt, vargs);
}


template <typename... Args>
void print(std::wostream& os,
           basic_format_string<wchar_t, type_identity_t<Args>...> fmt,
           Args&&... args) {
  vprint(os, fmt, fmt::make_format_args<buffer_context<wchar_t>>(args...));
}

           template <typename... T>
void println(std::ostream& os, format_string<T...> fmt, T&&... args) {
  fmt::print(os, "{}\n", fmt::format(fmt, std::forward<T>(args)...));
}


template <typename... Args>
void println(std::wostream& os,
             basic_format_string<wchar_t, type_identity_t<Args>...> fmt,
             Args&&... args) {
  print(os, L"{}\n", fmt::format(fmt, std::forward<Args>(args)...));
}

} }
# 28 "/home/avi/scylla-maint/seastar/include/seastar/core/print.hh" 2
# 1 "/usr/include/fmt/printf.h" 1 3 4
# 16 "/usr/include/fmt/printf.h" 3 4
namespace fmt { inline namespace v10 {


template <typename T> struct printf_formatter {
  printf_formatter() = delete;
};

template <typename Char> class basic_printf_context {
 private:
  detail::buffer_appender<Char> out_;
  basic_format_args<basic_printf_context> args_;

  static_assert(std::is_same<Char, char>::value ||
                    std::is_same<Char, wchar_t>::value,
                "Unsupported code unit type.");

 public:
  using char_type = Char;
  using parse_context_type = basic_format_parse_context<Char>;
  template <typename T> using formatter_type = printf_formatter<T>;







  basic_printf_context(detail::buffer_appender<Char> out,
                       basic_format_args<basic_printf_context> args)
      : out_(out), args_(args) {}

  auto out() -> detail::buffer_appender<Char> { return out_; }
  void advance_to(detail::buffer_appender<Char>) {}

  auto locale() -> detail::locale_ref { return {}; }

  auto arg(int id) const -> basic_format_arg<basic_printf_context> {
    return args_.get(id);
  }

  constexpr void on_error(const char* message) {
    detail::error_handler().on_error(message);
  }
};

namespace detail {



template <bool IsSigned> struct int_checker {
  template <typename T> static auto fits_in_int(T value) -> bool {
    unsigned max = max_value<int>();
    return value <= max;
  }
  static auto fits_in_int(bool) -> bool { return true; }
};

template <> struct int_checker<true> {
  template <typename T> static auto fits_in_int(T value) -> bool {
    return value >= (std::numeric_limits<int>::min)() &&
           value <= max_value<int>();
  }
  static auto fits_in_int(int) -> bool { return true; }
};

struct printf_precision_handler {
  template <typename T, fmt::enable_if_t<(std::is_integral<T>::value), int> = 0>
  auto operator()(T value) -> int {
    if (!int_checker<std::numeric_limits<T>::is_signed>::fits_in_int(value))
      throw_format_error("number is too big");
    return (std::max)(static_cast<int>(value), 0);
  }

  template <typename T, fmt::enable_if_t<(!std::is_integral<T>::value), int> = 0>
  auto operator()(T) -> int {
    throw_format_error("precision is not integer");
    return 0;
  }
};


struct is_zero_int {
  template <typename T, fmt::enable_if_t<(std::is_integral<T>::value), int> = 0>
  auto operator()(T value) -> bool {
    return value == 0;
  }

  template <typename T, fmt::enable_if_t<(!std::is_integral<T>::value), int> = 0>
  auto operator()(T) -> bool {
    return false;
  }
};

template <typename T> struct make_unsigned_or_bool : std::make_unsigned<T> {};

template <> struct make_unsigned_or_bool<bool> {
  using type = bool;
};

template <typename T, typename Context> class arg_converter {
 private:
  using char_type = typename Context::char_type;

  basic_format_arg<Context>& arg_;
  char_type type_;

 public:
  arg_converter(basic_format_arg<Context>& arg, char_type type)
      : arg_(arg), type_(type) {}

  void operator()(bool value) {
    if (type_ != 's') operator()<bool>(value);
  }

  template <typename U, fmt::enable_if_t<(std::is_integral<U>::value), int> = 0>
  void operator()(U value) {
    bool is_signed = type_ == 'd' || type_ == 'i';
    using target_type = conditional_t<std::is_same<T, void>::value, U, T>;
    if (const_check(sizeof(target_type) <= sizeof(int))) {

      if (is_signed) {
        auto n = static_cast<int>(static_cast<target_type>(value));
        arg_ = detail::make_arg<Context>(n);
      } else {
        using unsigned_type = typename make_unsigned_or_bool<target_type>::type;
        auto n = static_cast<unsigned>(static_cast<unsigned_type>(value));
        arg_ = detail::make_arg<Context>(n);
      }
    } else {
      if (is_signed) {



        auto n = static_cast<long long>(value);
        arg_ = detail::make_arg<Context>(n);
      } else {
        auto n = static_cast<typename make_unsigned_or_bool<U>::type>(value);
        arg_ = detail::make_arg<Context>(n);
      }
    }
  }

  template <typename U, fmt::enable_if_t<(!std::is_integral<U>::value), int> = 0>
  void operator()(U) {}
};





template <typename T, typename Context, typename Char>
void convert_arg(basic_format_arg<Context>& arg, Char type) {
  visit_format_arg(arg_converter<T, Context>(arg, type), arg);
}


template <typename Context> class char_converter {
 private:
  basic_format_arg<Context>& arg_;

 public:
  explicit char_converter(basic_format_arg<Context>& arg) : arg_(arg) {}

  template <typename T, fmt::enable_if_t<(std::is_integral<T>::value), int> = 0>
  void operator()(T value) {
    auto c = static_cast<typename Context::char_type>(value);
    arg_ = detail::make_arg<Context>(c);
  }

  template <typename T, fmt::enable_if_t<(!std::is_integral<T>::value), int> = 0>
  void operator()(T) {}
};



template <typename Char> struct get_cstring {
  template <typename T> auto operator()(T) -> const Char* { return nullptr; }
  auto operator()(const Char* s) -> const Char* { return s; }
};



template <typename Char> class printf_width_handler {
 private:
  format_specs<Char>& specs_;

 public:
  explicit printf_width_handler(format_specs<Char>& specs) : specs_(specs) {}

  template <typename T, fmt::enable_if_t<(std::is_integral<T>::value), int> = 0>
  auto operator()(T value) -> unsigned {
    auto width = static_cast<uint32_or_64_or_128_t<T>>(value);
    if (detail::is_negative(value)) {
      specs_.align = align::left;
      width = 0 - width;
    }
    unsigned int_max = max_value<int>();
    if (width > int_max) throw_format_error("number is too big");
    return static_cast<unsigned>(width);
  }

  template <typename T, fmt::enable_if_t<(!std::is_integral<T>::value), int> = 0>
  auto operator()(T) -> unsigned {
    throw_format_error("width is not integer");
    return 0;
  }
};



template <typename Char>
auto make_arg_formatter(buffer_appender<Char> iter, format_specs<Char>& s)
    -> arg_formatter<Char> {
  return {iter, s, locale_ref()};
}


template <typename Char>
class printf_arg_formatter : public arg_formatter<Char> {
 private:
  using base = arg_formatter<Char>;
  using context_type = basic_printf_context<Char>;

  context_type& context_;

  void write_null_pointer(bool is_string = false) {
    auto s = this->specs;
    s.type = presentation_type::none;
    write_bytes(this->out, is_string ? "(null)" : "(nil)", s);
  }

 public:
  printf_arg_formatter(buffer_appender<Char> iter, format_specs<Char>& s,
                       context_type& ctx)
      : base(make_arg_formatter(iter, s)), context_(ctx) {}

  void operator()(monostate value) { base::operator()(value); }

  template <typename T, fmt::enable_if_t<(detail::is_integral<T>::value), int> = 0>
  void operator()(T value) {


    if (!std::is_same<T, Char>::value) {
      base::operator()(value);
      return;
    }
    format_specs<Char> fmt_specs = this->specs;
    if (fmt_specs.type != presentation_type::none &&
        fmt_specs.type != presentation_type::chr) {
      return (*this)(static_cast<int>(value));
    }
    fmt_specs.sign = sign::none;
    fmt_specs.alt = false;
    fmt_specs.fill[0] = ' ';


    if (fmt_specs.align == align::none || fmt_specs.align == align::numeric)
      fmt_specs.align = align::right;
    write<Char>(this->out, static_cast<Char>(value), fmt_specs);
  }

  template <typename T, fmt::enable_if_t<(std::is_floating_point<T>::value), int> = 0>
  void operator()(T value) {
    base::operator()(value);
  }


  void operator()(const char* value) {
    if (value)
      base::operator()(value);
    else
      write_null_pointer(this->specs.type != presentation_type::pointer);
  }


  void operator()(const wchar_t* value) {
    if (value)
      base::operator()(value);
    else
      write_null_pointer(this->specs.type != presentation_type::pointer);
  }

  void operator()(basic_string_view<Char> value) { base::operator()(value); }


  void operator()(const void* value) {
    if (value)
      base::operator()(value);
    else
      write_null_pointer();
  }


  void operator()(typename basic_format_arg<context_type>::handle handle) {
    auto parse_ctx = basic_format_parse_context<Char>({});
    handle.format(parse_ctx, context_);
  }
};

template <typename Char>
void parse_flags(format_specs<Char>& specs, const Char*& it, const Char* end) {
  for (; it != end; ++it) {
    switch (*it) {
    case '-':
      specs.align = align::left;
      break;
    case '+':
      specs.sign = sign::plus;
      break;
    case '0':
      specs.fill[0] = '0';
      break;
    case ' ':
      if (specs.sign != sign::plus) specs.sign = sign::space;
      break;
    case '#':
      specs.alt = true;
      break;
    default:
      return;
    }
  }
}

template <typename Char, typename GetArg>
auto parse_header(const Char*& it, const Char* end, format_specs<Char>& specs,
                  GetArg get_arg) -> int {
  int arg_index = -1;
  Char c = *it;
  if (c >= '0' && c <= '9') {


    int value = parse_nonnegative_int(it, end, -1);
    if (it != end && *it == '$') {
      ++it;
      arg_index = value != -1 ? value : max_value<int>();
    } else {
      if (c == '0') specs.fill[0] = '0';
      if (value != 0) {


        if (value == -1) throw_format_error("number is too big");
        specs.width = value;
        return arg_index;
      }
    }
  }
  parse_flags(specs, it, end);

  if (it != end) {
    if (*it >= '0' && *it <= '9') {
      specs.width = parse_nonnegative_int(it, end, -1);
      if (specs.width == -1) throw_format_error("number is too big");
    } else if (*it == '*') {
      ++it;
      specs.width = static_cast<int>(visit_format_arg(
          detail::printf_width_handler<Char>(specs), get_arg(-1)));
    }
  }
  return arg_index;
}

inline auto parse_printf_presentation_type(char c, type t)
    -> presentation_type {
  using pt = presentation_type;
  constexpr auto integral_set = sint_set | uint_set | bool_set | char_set;
  switch (c) {
  case 'd':
    return in(t, integral_set) ? pt::dec : pt::none;
  case 'o':
    return in(t, integral_set) ? pt::oct : pt::none;
  case 'x':
    return in(t, integral_set) ? pt::hex_lower : pt::none;
  case 'X':
    return in(t, integral_set) ? pt::hex_upper : pt::none;
  case 'a':
    return in(t, float_set) ? pt::hexfloat_lower : pt::none;
  case 'A':
    return in(t, float_set) ? pt::hexfloat_upper : pt::none;
  case 'e':
    return in(t, float_set) ? pt::exp_lower : pt::none;
  case 'E':
    return in(t, float_set) ? pt::exp_upper : pt::none;
  case 'f':
    return in(t, float_set) ? pt::fixed_lower : pt::none;
  case 'F':
    return in(t, float_set) ? pt::fixed_upper : pt::none;
  case 'g':
    return in(t, float_set) ? pt::general_lower : pt::none;
  case 'G':
    return in(t, float_set) ? pt::general_upper : pt::none;
  case 'c':
    return in(t, integral_set) ? pt::chr : pt::none;
  case 's':
    return in(t, string_set | cstring_set) ? pt::string : pt::none;
  case 'p':
    return in(t, pointer_set | cstring_set) ? pt::pointer : pt::none;
  default:
    return pt::none;
  }
}

template <typename Char, typename Context>
void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
             basic_format_args<Context> args) {
  using iterator = buffer_appender<Char>;
  auto out = iterator(buf);
  auto context = basic_printf_context<Char>(out, args);
  auto parse_ctx = basic_format_parse_context<Char>(format);



  auto get_arg = [&](int arg_index) {
    if (arg_index < 0)
      arg_index = parse_ctx.next_arg_id();
    else
      parse_ctx.check_arg_id(--arg_index);
    return detail::get_arg(context, arg_index);
  };

  const Char* start = parse_ctx.begin();
  const Char* end = parse_ctx.end();
  auto it = start;
  while (it != end) {
    if (!find<false, Char>(it, end, '%', it)) {
      it = end;
      break;
    }
    Char c = *it++;
    if (it != end && *it == c) {
      write(out, basic_string_view<Char>(start, to_unsigned(it - start)));
      start = ++it;
      continue;
    }
    write(out, basic_string_view<Char>(start, to_unsigned(it - 1 - start)));

    auto specs = format_specs<Char>();
    specs.align = align::right;


    int arg_index = parse_header(it, end, specs, get_arg);
    if (arg_index == 0) throw_format_error("argument not found");


    if (it != end && *it == '.') {
      ++it;
      c = it != end ? *it : 0;
      if ('0' <= c && c <= '9') {
        specs.precision = parse_nonnegative_int(it, end, 0);
      } else if (c == '*') {
        ++it;
        specs.precision = static_cast<int>(
            visit_format_arg(printf_precision_handler(), get_arg(-1)));
      } else {
        specs.precision = 0;
      }
    }

    auto arg = get_arg(arg_index);


    if (specs.precision >= 0 && arg.is_integral()) {

      specs.fill[0] = ' ';
    }
    if (specs.precision >= 0 && arg.type() == type::cstring_type) {
      auto str = visit_format_arg(get_cstring<Char>(), arg);
      auto str_end = str + specs.precision;
      auto nul = std::find(str, str_end, Char());
      auto sv = basic_string_view<Char>(
          str, to_unsigned(nul != str_end ? nul - str : specs.precision));
      arg = make_arg<basic_printf_context<Char>>(sv);
    }
    if (specs.alt && visit_format_arg(is_zero_int(), arg)) specs.alt = false;
    if (specs.fill[0] == '0') {
      if (arg.is_arithmetic() && specs.align != align::left)
        specs.align = align::numeric;
      else
        specs.fill[0] = ' ';

    }


    c = it != end ? *it++ : 0;
    Char t = it != end ? *it : 0;
    switch (c) {
    case 'h':
      if (t == 'h') {
        ++it;
        t = it != end ? *it : 0;
        convert_arg<signed char>(arg, t);
      } else {
        convert_arg<short>(arg, t);
      }
      break;
    case 'l':
      if (t == 'l') {
        ++it;
        t = it != end ? *it : 0;
        convert_arg<long long>(arg, t);
      } else {
        convert_arg<long>(arg, t);
      }
      break;
    case 'j':
      convert_arg<intmax_t>(arg, t);
      break;
    case 'z':
      convert_arg<size_t>(arg, t);
      break;
    case 't':
      convert_arg<std::ptrdiff_t>(arg, t);
      break;
    case 'L':


      break;
    default:
      --it;
      convert_arg<void>(arg, c);
    }


    if (it == end) throw_format_error("invalid format string");
    char type = static_cast<char>(*it++);
    if (arg.is_integral()) {

      switch (type) {
      case 'i':
      case 'u':
        type = 'd';
        break;
      case 'c':
        visit_format_arg(char_converter<basic_printf_context<Char>>(arg), arg);
        break;
      }
    }
    specs.type = parse_printf_presentation_type(type, arg.type());
    if (specs.type == presentation_type::none)
      throw_format_error("invalid format specifier");

    start = it;


    visit_format_arg(printf_arg_formatter<Char>(out, specs, context), arg);
  }
  write(out, basic_string_view<Char>(start, to_unsigned(it - start)));
}
}

using printf_context = basic_printf_context<char>;
using wprintf_context = basic_printf_context<wchar_t>;

using printf_args = basic_format_args<printf_context>;
using wprintf_args = basic_format_args<wprintf_context>;







template <typename... T>
inline auto make_printf_args(const T&... args)
    -> format_arg_store<printf_context, T...> {
  return {args...};
}


template <typename... T>
inline auto make_wprintf_args(const T&... args)
    -> format_arg_store<wprintf_context, T...> {
  return {args...};
}

template <typename Char>
inline auto vsprintf(
    basic_string_view<Char> fmt,
    basic_format_args<basic_printf_context<type_identity_t<Char>>> args)
    -> std::basic_string<Char> {
  auto buf = basic_memory_buffer<Char>();
  detail::vprintf(buf, fmt, args);
  return to_string(buf);
}
# 610 "/usr/include/fmt/printf.h" 3 4
template <typename S, typename... T,
          typename Char = enable_if_t<detail::is_string<S>::value, char_t<S>>>
inline auto sprintf(const S& fmt, const T&... args) -> std::basic_string<Char> {
  return vsprintf(detail::to_string_view(fmt),
                  fmt::make_format_args<basic_printf_context<Char>>(args...));
}

template <typename Char>
inline auto vfprintf(
    std::FILE* f, basic_string_view<Char> fmt,
    basic_format_args<basic_printf_context<type_identity_t<Char>>> args)
    -> int {
  auto buf = basic_memory_buffer<Char>();
  detail::vprintf(buf, fmt, args);
  size_t size = buf.size();
  return std::fwrite(buf.data(), sizeof(Char), size, f) < size
             ? -1
             : static_cast<int>(size);
}
# 639 "/usr/include/fmt/printf.h" 3 4
template <typename S, typename... T, typename Char = char_t<S>>
inline auto fprintf(std::FILE* f, const S& fmt, const T&... args) -> int {
  return vfprintf(f, detail::to_string_view(fmt),
                  fmt::make_format_args<basic_printf_context<Char>>(args...));
}

template <typename Char>
[[deprecated]] inline auto vprintf(
    basic_string_view<Char> fmt,
    basic_format_args<basic_printf_context<type_identity_t<Char>>> args)
    -> int {
  return vfprintf(stdout, fmt, args);
}
# 662 "/usr/include/fmt/printf.h" 3 4
template <typename... T>
inline auto printf(string_view fmt, const T&... args) -> int {
  return vfprintf(stdout, fmt, make_printf_args(args...));
}
template <typename... T>
[[deprecated]] inline auto printf(basic_string_view<wchar_t> fmt,
                                  const T&... args) -> int {
  return vfprintf(stdout, fmt, make_wprintf_args(args...));
}


} }
# 29 "/home/avi/scylla-maint/seastar/include/seastar/core/print.hh" 2
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/iostream" 1 3
# 37 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/iostream" 3







namespace std __attribute__ ((__visibility__ ("default")))
{
# 62 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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;
# 82 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/iostream" 3
  __extension__ __asm (".globl _ZSt21ios_base_library_initv");



}
# 30 "/home/avi/scylla-maint/seastar/include/seastar/core/print.hh" 2
# 47 "/home/avi/scylla-maint/seastar/include/seastar/core/print.hh"
inline
std::ostream&
operator<<(std::ostream&& os, const void* ptr) {
    return os << ptr;
}

namespace seastar {

template <typename... A>
[[deprecated("use std::format_to() or fmt::print()")]]
std::ostream&
fprint(std::ostream& os, const char* fmt, A&&... a) {
    ::fmt::fprintf(os, fmt, std::forward<A>(a)...);
    return os;
}

template <typename... A>
[[deprecated("use std::format_to() or fmt::print()")]]
void
print(const char* fmt, A&&... a) {
    ::fmt::printf(fmt, std::forward<A>(a)...);
}

template <typename... A>
[[deprecated("use std::format() or fmt::format()")]]
std::string
sprint(const char* fmt, A&&... a) {
    std::ostringstream os;
    ::fmt::fprintf(os, fmt, std::forward<A>(a)...);
    return os.str();
}

template <typename... A>
[[deprecated("use std::format() or fmt::format()")]]
std::string
sprint(const sstring& fmt, A&&... a) {
    std::ostringstream os;
    ::fmt::fprintf(os, fmt.c_str(), std::forward<A>(a)...);
    return os.str();
}

template <typename Iterator>
[[deprecated("use fmt::join()")]]
std::string
format_separated(Iterator b, Iterator e, const char* sep = ", ") {
    std::string ret;
    if (b == e) {
        return ret;
    }
    ret += *b++;
    while (b != e) {
        ret += sep;
        ret += *b++;
    }
    return ret;
}

template <typename TimePoint>
struct usecfmt_wrapper {
    TimePoint val;
};

template <typename TimePoint>
inline
usecfmt_wrapper<TimePoint>
usecfmt(TimePoint tp) {
    return { tp };
};

template <typename Clock, typename Rep, typename Period>
std::ostream&
operator<<(std::ostream& os, usecfmt_wrapper<std::chrono::time_point<Clock, std::chrono::duration<Rep, Period>>> tp) {
    auto usec = std::chrono::duration_cast<std::chrono::microseconds>(tp.val.time_since_epoch()).count();
    std::ostream tmp(os.rdbuf());
    tmp << std::setw(12) << (usec / 1000000) << "." << std::setw(6) << std::setfill('0') << (usec % 1000000);
    return os;
}

template <typename... A>
void
log(A&&... a) {
    std::cout << usecfmt(std::chrono::high_resolution_clock::now()) << " ";
    print(std::forward<A>(a)...);
}
# 141 "/home/avi/scylla-maint/seastar/include/seastar/core/print.hh"
template <typename... A>
sstring
format(const char* fmt, A&&... a) {
    fmt::memory_buffer out;

    fmt::format_to(fmt::appender(out), fmt::runtime(fmt), std::forward<A>(a)...);



    return sstring{out.data(), out.size()};
}


template <typename... A>
[[deprecated("use std::format() or fmt::print()")]]
std::ostream&
fmt_print(std::ostream& os, const char* format, A&&... a) {
    fmt::print(os, format, std::forward<A>(a)...);
    return os;
}

}
# 26 "/home/avi/scylla-maint/seastar/include/seastar/util/backtrace.hh" 2

# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/shared_ptr.hh" 1
# 24 "/home/avi/scylla-maint/seastar/include/seastar/core/shared_ptr.hh"
# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/shared_ptr_debug_helper.hh" 1
# 25 "/home/avi/scylla-maint/seastar/include/seastar/core/shared_ptr.hh" 2
# 1 "/home/avi/scylla-maint/seastar/include/seastar/util/is_smart_ptr.hh" 1
# 27 "/home/avi/scylla-maint/seastar/include/seastar/util/is_smart_ptr.hh"
namespace seastar {

template<typename T>
struct is_smart_ptr : std::false_type {};

template<typename T>
struct is_smart_ptr<std::unique_ptr<T>> : std::true_type {};

}
# 26 "/home/avi/scylla-maint/seastar/include/seastar/core/shared_ptr.hh" 2
# 1 "/home/avi/scylla-maint/seastar/include/seastar/util/indirect.hh" 1
# 26 "/home/avi/scylla-maint/seastar/include/seastar/util/indirect.hh"
namespace seastar {
# 38 "/home/avi/scylla-maint/seastar/include/seastar/util/indirect.hh"
template<typename Pointer, typename Equal = std::equal_to<typename std::pointer_traits<Pointer>::element_type>>
struct indirect_equal_to {
    Equal _eq;
    indirect_equal_to(Equal eq = Equal()) : _eq(std::move(eq)) {}
    bool operator()(const Pointer& i1, const Pointer& i2) const {
        if (bool(i1) ^ bool(i2)) {
            return false;
        }
        return !i1 || _eq(*i1, *i2);
    }
};

template<typename Pointer, typename Less = std::less<typename std::pointer_traits<Pointer>::element_type>>
struct indirect_less {
    Less _cmp;
    indirect_less(Less cmp = Less()) : _cmp(std::move(cmp)) {}
    bool operator()(const Pointer& i1, const Pointer& i2) const {
        if (i1 && i2) {
            return _cmp(*i1, *i2);
        }
        return !i1 && i2;
    }
};

template<typename Pointer, typename Hash = std::hash<typename std::pointer_traits<Pointer>::element_type>>
struct indirect_hash {
    Hash _h;
    indirect_hash(Hash h = Hash()) : _h(std::move(h)) {}
    size_t operator()(const Pointer& p) const {
        if (p) {
            return _h(*p);
        }
        return 0;
    }
};

}
# 27 "/home/avi/scylla-maint/seastar/include/seastar/core/shared_ptr.hh" 2


# 1 "/usr/include/boost/intrusive/parent_from_member.hpp" 1 3 4
# 15 "/usr/include/boost/intrusive/parent_from_member.hpp" 3 4
# 1 "/usr/include/boost/intrusive/detail/config_begin.hpp" 1 3 4
# 16 "/usr/include/boost/intrusive/parent_from_member.hpp" 2 3 4
# 25 "/usr/include/boost/intrusive/parent_from_member.hpp" 3 4
namespace boost {
namespace intrusive {





template<class Parent, class Member>
inline __attribute__ ((__always_inline__)) Parent *get_parent_from_member(Member *member, const Member Parent::* ptr_to_member) noexcept
{ return ::boost::intrusive::detail::parent_from_member(member, ptr_to_member); }





template<class Parent, class Member>
inline __attribute__ ((__always_inline__)) const Parent *get_parent_from_member(const Member *member, const Member Parent::* ptr_to_member) noexcept
{ return ::boost::intrusive::detail::parent_from_member(member, ptr_to_member); }

}
}

# 1 "/usr/include/boost/intrusive/detail/config_end.hpp" 1 3 4
# 48 "/usr/include/boost/intrusive/parent_from_member.hpp" 2 3 4
# 30 "/home/avi/scylla-maint/seastar/include/seastar/core/shared_ptr.hh" 2
# 42 "/home/avi/scylla-maint/seastar/include/seastar/core/shared_ptr.hh"
namespace seastar {
# 66 "/home/avi/scylla-maint/seastar/include/seastar/core/shared_ptr.hh"
using shared_ptr_counter_type = long;




template <typename T>
class lw_shared_ptr;

template <typename T>
class shared_ptr;

template <typename T>
class enable_lw_shared_from_this;

template <typename T>
class enable_shared_from_this;

template <typename T, typename... A>
lw_shared_ptr<T> make_lw_shared(A&&... a);

template <typename T>
lw_shared_ptr<T> make_lw_shared(T&& a);

template <typename T>
lw_shared_ptr<T> make_lw_shared(T& a);

template <typename T, typename... A>
shared_ptr<T> make_shared(A&&... a);

template <typename T>
shared_ptr<T> make_shared(T&& a);

template <typename T, typename U>
shared_ptr<T> static_pointer_cast(const shared_ptr<U>& p);

template <typename T, typename U>
shared_ptr<T> dynamic_pointer_cast(const shared_ptr<U>& p);

template <typename T, typename U>
shared_ptr<T> const_pointer_cast(const shared_ptr<U>& p);

struct lw_shared_ptr_counter_base {
    shared_ptr_counter_type _count = 0;
};



namespace internal {

template <class T, class U>
struct lw_shared_ptr_accessors;

template <class T>
struct lw_shared_ptr_accessors_esft;

template <class T>
struct lw_shared_ptr_accessors_no_esft;

}
# 147 "/home/avi/scylla-maint/seastar/include/seastar/core/shared_ptr.hh"
template <typename T>
class enable_lw_shared_from_this : private lw_shared_ptr_counter_base {
    using ctor = T;
protected:
    enable_lw_shared_from_this() noexcept {}
    enable_lw_shared_from_this(enable_lw_shared_from_this&&) noexcept {}
    enable_lw_shared_from_this(const enable_lw_shared_from_this&) noexcept {}
    enable_lw_shared_from_this& operator=(const enable_lw_shared_from_this&) noexcept { return *this; }
    enable_lw_shared_from_this& operator=(enable_lw_shared_from_this&&) noexcept { return *this; }
public:
    lw_shared_ptr<T> shared_from_this() noexcept;
    lw_shared_ptr<const T> shared_from_this() const noexcept;
    long use_count() const noexcept { return _count; }

    template <typename X>
    friend class lw_shared_ptr;
    template <typename X>
    friend struct internal::lw_shared_ptr_accessors_esft;
    template <typename X, class Y>
    friend struct internal::lw_shared_ptr_accessors;
};

template <typename T>
struct lw_shared_ptr_no_esft : private lw_shared_ptr_counter_base {
    T _value;

    lw_shared_ptr_no_esft() = default;
    lw_shared_ptr_no_esft(const T& x) : _value(x) {}
    lw_shared_ptr_no_esft(T&& x) : _value(std::move(x)) {}
    template <typename... A>
    lw_shared_ptr_no_esft(A&&... a) : _value(std::forward<A>(a)...) {}

    template <typename X>
    friend class lw_shared_ptr;
    template <typename X>
    friend struct internal::lw_shared_ptr_accessors_no_esft;
    template <typename X, class Y>
    friend struct internal::lw_shared_ptr_accessors;
};
# 196 "/home/avi/scylla-maint/seastar/include/seastar/core/shared_ptr.hh"
template <typename T>
struct lw_shared_ptr_deleter;

namespace internal {

template <typename T>
struct lw_shared_ptr_accessors_esft {
    using concrete_type = std::remove_const_t<T>;
    static T* to_value(lw_shared_ptr_counter_base* counter) {
        return static_cast<T*>(counter);
    }
    static void dispose(lw_shared_ptr_counter_base* counter) {
        dispose(static_cast<T*>(counter));
    }
    static void dispose(T* value_ptr) {
        delete value_ptr;
    }
    static void instantiate_to_value(lw_shared_ptr_counter_base*) {


    }
};

template <typename T>
struct lw_shared_ptr_accessors_no_esft {
    using concrete_type = lw_shared_ptr_no_esft<T>;
    static T* to_value(lw_shared_ptr_counter_base* counter) {
        return &static_cast<concrete_type*>(counter)->_value;
    }
    static void dispose(lw_shared_ptr_counter_base* counter) {
        delete static_cast<concrete_type*>(counter);
    }
    static void dispose(T* value_ptr) {
        delete boost::intrusive::get_parent_from_member(value_ptr, &concrete_type::_value);
    }
    static void instantiate_to_value(lw_shared_ptr_counter_base*) {


    }
};



template <typename T, typename U = void>
struct lw_shared_ptr_accessors : std::conditional_t<
         std::is_base_of_v<enable_lw_shared_from_this<T>, T>,
         lw_shared_ptr_accessors_esft<T>,
         lw_shared_ptr_accessors_no_esft<T>> {
};


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


template <typename T>
struct lw_shared_ptr_accessors<T, void_t<decltype(lw_shared_ptr_deleter<T>{})>> {
    using concrete_type = T;
    static T* to_value(lw_shared_ptr_counter_base* counter);
    static void dispose(lw_shared_ptr_counter_base* counter) {
        lw_shared_ptr_deleter<T>::dispose(to_value(counter));
    }
    static void instantiate_to_value(lw_shared_ptr_counter_base* p) {

        to_value(p);
    }
};

}


template <typename T>
class lw_shared_ptr {
    template <typename U>
    using accessors = internal::lw_shared_ptr_accessors<std::remove_const_t<U>>;

    mutable lw_shared_ptr_counter_base* _p = nullptr;
private:
    lw_shared_ptr(lw_shared_ptr_counter_base* p) noexcept : _p(p) {
        if (_p) {
            ++_p->_count;
        }
    }
    template <typename... A>
    static lw_shared_ptr make(A&&... a) {
        auto p = new typename accessors<T>::concrete_type(std::forward<A>(a)...);
        accessors<T>::instantiate_to_value(p);
        return lw_shared_ptr(p);
    }
public:
    using element_type = T;



    static void dispose(T* p) noexcept {
        accessors<T>::dispose(const_cast<std::remove_const_t<T>*>(p));
    }


    class disposer {
    public:
        void operator()(T* p) const noexcept {
            dispose(p);
        }
    };

    lw_shared_ptr() noexcept = default;
    lw_shared_ptr(std::nullptr_t) noexcept : lw_shared_ptr() {}
    lw_shared_ptr(const lw_shared_ptr& x) noexcept : _p(x._p) {
        if (_p) {
#pragma GCC diagnostic push



            ++_p->_count;
#pragma GCC diagnostic pop
        }
    }
    lw_shared_ptr(lw_shared_ptr&& x) noexcept : _p(x._p) {
        x._p = nullptr;
    }
    [[gnu::always_inline]]
    ~lw_shared_ptr() {
#pragma GCC diagnostic push



        if (_p && !--_p->_count) {
            accessors<T>::dispose(_p);
        }
#pragma GCC diagnostic pop
    }
    lw_shared_ptr& operator=(const lw_shared_ptr& x) noexcept {
        if (_p != x._p) {
            this->~lw_shared_ptr();
            new (this) lw_shared_ptr(x);
        }
        return *this;
    }
    lw_shared_ptr& operator=(lw_shared_ptr&& x) noexcept {
        if (_p != x._p) {
            this->~lw_shared_ptr();
            new (this) lw_shared_ptr(std::move(x));
        }
        return *this;
    }
    lw_shared_ptr& operator=(std::nullptr_t) noexcept {
        return *this = lw_shared_ptr();
    }
    [[deprecated("call make_lw_shared<> and assign the result instead")]]
    lw_shared_ptr& operator=(T&& x) noexcept {
        this->~lw_shared_ptr();
        new (this) lw_shared_ptr(make_lw_shared<T>(std::move(x)));
        return *this;
    }

    T& operator*() const noexcept { return *accessors<T>::to_value(_p); }
    T* operator->() const noexcept { return accessors<T>::to_value(_p); }
    T* get() const noexcept {
        if (_p) {
            return accessors<T>::to_value(_p);
        } else {
            return nullptr;
        }
    }
# 370 "/home/avi/scylla-maint/seastar/include/seastar/core/shared_ptr.hh"
    std::unique_ptr<T, disposer> release() noexcept {
        auto p = std::exchange(_p, nullptr);
        if (--p->_count) {
            return nullptr;
        } else {
            return std::unique_ptr<T, disposer>(accessors<T>::to_value(p));
        }
    }

    long int use_count() const noexcept {
        if (_p) {
            return _p->_count;
        } else {
            return 0;
        }
    }

    operator lw_shared_ptr<const T>() const noexcept {
        return lw_shared_ptr<const T>(_p);
    }

    explicit operator bool() const noexcept {
        return _p;
    }

    bool owned() const noexcept {
        return _p->_count == 1;
    }

    bool operator==(const lw_shared_ptr<const T>& x) const {
        return _p == x._p;
    }

    bool operator!=(const lw_shared_ptr<const T>& x) const {
        return !operator==(x);
    }

    bool operator==(const lw_shared_ptr<std::remove_const_t<T>>& x) const {
        return _p == x._p;
    }

    bool operator!=(const lw_shared_ptr<std::remove_const_t<T>>& x) const {
        return !operator==(x);
    }

    bool operator<(const lw_shared_ptr<const T>& x) const {
        return _p < x._p;
    }

    bool operator<(const lw_shared_ptr<std::remove_const_t<T>>& x) const {
        return _p < x._p;
    }

    template <typename U>
    friend class lw_shared_ptr;

    template <typename X, typename... A>
    friend lw_shared_ptr<X> make_lw_shared(A&&...);

    template <typename U>
    friend lw_shared_ptr<U> make_lw_shared(U&&);

    template <typename U>
    friend lw_shared_ptr<U> make_lw_shared(U&);

    template <typename U>
    friend class enable_lw_shared_from_this;
};

template <typename T, typename... A>
inline
lw_shared_ptr<T> make_lw_shared(A&&... a) {
    return lw_shared_ptr<T>::make(std::forward<A>(a)...);
}

template <typename T>
inline
lw_shared_ptr<T> make_lw_shared(T&& a) {
    return lw_shared_ptr<T>::make(std::move(a));
}

template <typename T>
inline
lw_shared_ptr<T> make_lw_shared(T& a) {
    return lw_shared_ptr<T>::make(a);
}


template <typename T>
inline
lw_shared_ptr<T>
enable_lw_shared_from_this<T>::shared_from_this() noexcept {
    return lw_shared_ptr<T>(this);
}

template <typename T>
inline
lw_shared_ptr<const T>
enable_lw_shared_from_this<T>::shared_from_this() const noexcept {
    return lw_shared_ptr<const T>(const_cast<enable_lw_shared_from_this*>(this));
}


template <typename T>
inline
std::ostream& operator<<(std::ostream& out, const lw_shared_ptr<T>& p) {
    if (!p) {
        return out << "null";
    }
    return out << *p;
}



struct shared_ptr_count_base {

    virtual ~shared_ptr_count_base() {}
    shared_ptr_counter_type count = 0;
};

template <typename T>
struct shared_ptr_count_for : shared_ptr_count_base {
    T data;
    template <typename... A>
    shared_ptr_count_for(A&&... a) : data(std::forward<A>(a)...) {}
};


template <typename T>
class enable_shared_from_this : private shared_ptr_count_base {
public:
    shared_ptr<T> shared_from_this() noexcept;
    shared_ptr<const T> shared_from_this() const noexcept;
    long use_count() const noexcept { return count; }

    template <typename U>
    friend class shared_ptr;

    template <typename U, bool esft>
    friend struct shared_ptr_make_helper;
};

template <typename T>
class shared_ptr {
    mutable shared_ptr_count_base* _b = nullptr;
    mutable T* _p = nullptr;
private:
    explicit shared_ptr(shared_ptr_count_for<T>* b) noexcept : _b(b), _p(&b->data) {
        ++_b->count;
    }
    shared_ptr(shared_ptr_count_base* b, T* p) noexcept : _b(b), _p(p) {
        if (_b) {
            ++_b->count;
        }
    }
    explicit shared_ptr(enable_shared_from_this<std::remove_const_t<T>>* p) noexcept : _b(p), _p(static_cast<T*>(p)) {
        if (_b) {
            ++_b->count;
        }
    }
public:
    using element_type = T;

    shared_ptr() noexcept = default;
    shared_ptr(std::nullptr_t) noexcept : shared_ptr() {}
    shared_ptr(const shared_ptr& x) noexcept
            : _b(x._b)
            , _p(x._p) {
        if (_b) {
            ++_b->count;
        }
    }
    shared_ptr(shared_ptr&& x) noexcept
            : _b(x._b)
            , _p(x._p) {
        x._b = nullptr;
        x._p = nullptr;
    }
    template <typename U, typename = std::enable_if_t<std::is_base_of_v<T, U>>>
    shared_ptr(const shared_ptr<U>& x) noexcept
            : _b(x._b)
            , _p(x._p) {
        if (_b) {
            ++_b->count;
        }
    }
    template <typename U, typename = std::enable_if_t<std::is_base_of_v<T, U>>>
    shared_ptr(shared_ptr<U>&& x) noexcept
            : _b(x._b)
            , _p(x._p) {
        x._b = nullptr;
        x._p = nullptr;
    }
    ~shared_ptr() {
#pragma GCC diagnostic push



        if (_b && !--_b->count) {
            delete _b;
        }
#pragma GCC diagnostic pop
    }
    shared_ptr& operator=(const shared_ptr& x) noexcept {
        if (this != &x) {
            this->~shared_ptr();
            new (this) shared_ptr(x);
        }
        return *this;
    }
    shared_ptr& operator=(shared_ptr&& x) noexcept {
        if (this != &x) {
            this->~shared_ptr();
            new (this) shared_ptr(std::move(x));
        }
        return *this;
    }
    shared_ptr& operator=(std::nullptr_t) noexcept {
        return *this = shared_ptr();
    }
    template <typename U, typename = std::enable_if_t<std::is_base_of_v<T, U>>>
    shared_ptr& operator=(const shared_ptr<U>& x) noexcept {
        if (*this != x) {
            this->~shared_ptr();
            new (this) shared_ptr(x);
        }
        return *this;
    }
    template <typename U, typename = std::enable_if_t<std::is_base_of_v<T, U>>>
    shared_ptr& operator=(shared_ptr<U>&& x) noexcept {
        if (*this != x) {
            this->~shared_ptr();
            new (this) shared_ptr(std::move(x));
        }
        return *this;
    }
    explicit operator bool() const noexcept {
        return _p;
    }
    T& operator*() const noexcept {
        return *_p;
    }
    T* operator->() const noexcept {
        return _p;
    }
    T* get() const noexcept {
        return _p;
    }
    long use_count() const noexcept {
        if (_b) {
            return _b->count;
        } else {
            return 0;
        }
    }

    template <bool esft>
    struct make_helper;

    template <typename U, typename... A>
    friend shared_ptr<U> make_shared(A&&... a);

    template <typename U>
    friend shared_ptr<U> make_shared(U&& a);

    template <typename V, typename U>
    friend shared_ptr<V> static_pointer_cast(const shared_ptr<U>& p);

    template <typename V, typename U>
    friend shared_ptr<V> dynamic_pointer_cast(const shared_ptr<U>& p);

    template <typename V, typename U>
    friend shared_ptr<V> const_pointer_cast(const shared_ptr<U>& p);

    template <bool esft, typename... A>
    static shared_ptr make(A&&... a);

    template <typename U>
    friend class enable_shared_from_this;

    template <typename U, bool esft>
    friend struct shared_ptr_make_helper;

    template <typename U>
    friend class shared_ptr;
};


template <typename U, bool esft>
struct shared_ptr_make_helper;

template <typename T>
struct shared_ptr_make_helper<T, false> {
    template <typename... A>
    static shared_ptr<T> make(A&&... a) {
        return shared_ptr<T>(new shared_ptr_count_for<T>(std::forward<A>(a)...));
    }
};

template <typename T>
struct shared_ptr_make_helper<T, true> {
    template <typename... A>
    static shared_ptr<T> make(A&&... a) {
        auto p = new T(std::forward<A>(a)...);
        return shared_ptr<T>(p, p);
    }
};


template <typename T, typename... A>
inline
shared_ptr<T>
make_shared(A&&... a) {
    using helper = shared_ptr_make_helper<T, std::is_base_of_v<shared_ptr_count_base, T>>;
    return helper::make(std::forward<A>(a)...);
}

template <typename T>
inline
shared_ptr<T>
make_shared(T&& a) {
    using helper = shared_ptr_make_helper<T, std::is_base_of_v<shared_ptr_count_base, T>>;
    return helper::make(std::forward<T>(a));
}

template <typename T, typename U>
inline
shared_ptr<T>
static_pointer_cast(const shared_ptr<U>& p) {
    return shared_ptr<T>(p._b, static_cast<T*>(p._p));
}

template <typename T, typename U>
inline
shared_ptr<T>
dynamic_pointer_cast(const shared_ptr<U>& p) {
    auto q = dynamic_cast<T*>(p._p);
    return shared_ptr<T>(q ? p._b : nullptr, q);
}

template <typename T, typename U>
inline
shared_ptr<T>
const_pointer_cast(const shared_ptr<U>& p) {
    return shared_ptr<T>(p._b, const_cast<T*>(p._p));
}


template <typename T>
inline
shared_ptr<T>
enable_shared_from_this<T>::shared_from_this() noexcept {
    auto unconst = reinterpret_cast<enable_shared_from_this<std::remove_const_t<T>>*>(this);
    return shared_ptr<T>(unconst);
}

template <typename T>
inline
shared_ptr<const T>
enable_shared_from_this<T>::shared_from_this() const noexcept {
    auto esft = const_cast<enable_shared_from_this*>(this);
    auto unconst = reinterpret_cast<enable_shared_from_this<std::remove_const_t<T>>*>(esft);
    return shared_ptr<const T>(unconst);
}


template <typename T, typename U>
inline
bool
operator==(const shared_ptr<T>& x, const shared_ptr<U>& y) {
    return x.get() == y.get();
}

template <typename T>
inline
bool
operator==(const shared_ptr<T>& x, std::nullptr_t) {
    return x.get() == nullptr;
}

template <typename T>
inline
bool
operator==(std::nullptr_t, const shared_ptr<T>& y) {
    return nullptr == y.get();
}

template <typename T>
inline
bool
operator==(const lw_shared_ptr<T>& x, std::nullptr_t) {
    return x.get() == nullptr;
}

template <typename T>
inline
bool
operator==(std::nullptr_t, const lw_shared_ptr<T>& y) {
    return nullptr == y.get();
}

template <typename T, typename U>
inline
bool
operator!=(const shared_ptr<T>& x, const shared_ptr<U>& y) {
    return x.get() != y.get();
}

template <typename T>
inline
bool
operator!=(const shared_ptr<T>& x, std::nullptr_t) {
    return x.get() != nullptr;
}

template <typename T>
inline
bool
operator!=(std::nullptr_t, const shared_ptr<T>& y) {
    return nullptr != y.get();
}

template <typename T>
inline
bool
operator!=(const lw_shared_ptr<T>& x, std::nullptr_t) {
    return x.get() != nullptr;
}

template <typename T>
inline
bool
operator!=(std::nullptr_t, const lw_shared_ptr<T>& y) {
    return nullptr != y.get();
}

template <typename T, typename U>
inline
bool
operator<(const shared_ptr<T>& x, const shared_ptr<U>& y) {
    return x.get() < y.get();
}

template <typename T>
inline
bool
operator<(const shared_ptr<T>& x, std::nullptr_t) {
    return x.get() < nullptr;
}

template <typename T>
inline
bool
operator<(std::nullptr_t, const shared_ptr<T>& y) {
    return nullptr < y.get();
}

template <typename T, typename U>
inline
bool
operator<=(const shared_ptr<T>& x, const shared_ptr<U>& y) {
    return x.get() <= y.get();
}

template <typename T>
inline
bool
operator<=(const shared_ptr<T>& x, std::nullptr_t) {
    return x.get() <= nullptr;
}

template <typename T>
inline
bool
operator<=(std::nullptr_t, const shared_ptr<T>& y) {
    return nullptr <= y.get();
}

template <typename T, typename U>
inline
bool
operator>(const shared_ptr<T>& x, const shared_ptr<U>& y) {
    return x.get() > y.get();
}

template <typename T>
inline
bool
operator>(const shared_ptr<T>& x, std::nullptr_t) {
    return x.get() > nullptr;
}

template <typename T>
inline
bool
operator>(std::nullptr_t, const shared_ptr<T>& y) {
    return nullptr > y.get();
}

template <typename T, typename U>
inline
bool
operator>=(const shared_ptr<T>& x, const shared_ptr<U>& y) {
    return x.get() >= y.get();
}

template <typename T>
inline
bool
operator>=(const shared_ptr<T>& x, std::nullptr_t) {
    return x.get() >= nullptr;
}

template <typename T>
inline
bool
operator>=(std::nullptr_t, const shared_ptr<T>& y) {
    return nullptr >= y.get();
}

template <typename T>
inline
std::ostream& operator<<(std::ostream& out, const shared_ptr<T>& p) {
    if (!p) {
        return out << "null";
    }
    return out << *p;
}

template<typename T>
using shared_ptr_equal_by_value = indirect_equal_to<shared_ptr<T>>;

template<typename T>
using shared_ptr_value_hash = indirect_hash<shared_ptr<T>>;


}

namespace std {


template <typename T>
struct hash<seastar::lw_shared_ptr<T>> : private hash<T*> {
    size_t operator()(const seastar::lw_shared_ptr<T>& p) const {
        return hash<T*>::operator()(p.get());
    }
};


template <typename T>
struct hash<seastar::shared_ptr<T>> : private hash<T*> {
    size_t operator()(const seastar::shared_ptr<T>& p) const {
        return hash<T*>::operator()(p.get());
    }
};

}


namespace fmt {

template<typename T>
const void* ptr(const seastar::lw_shared_ptr<T>& p) {
    return p.get();
}

template<typename T>
const void* ptr(const seastar::shared_ptr<T>& p) {
    return p.get();
}

template <typename T>
struct formatter<seastar::shared_ptr<T>> {
    constexpr auto parse(format_parse_context& ctx) { return ctx.begin(); }
    auto format(const seastar::shared_ptr<T>& p, fmt::format_context& ctx) const {
        if (!p) {
            return fmt::format_to(ctx.out(), "null");
        }
        return fmt::format_to(ctx.out(), "{}", *p);
    }
};

template <typename T>
struct formatter<seastar::lw_shared_ptr<T>> {
    constexpr auto parse(format_parse_context& ctx) { return ctx.begin(); }
    auto format(const seastar::lw_shared_ptr<T>& p, fmt::format_context& ctx) const {
        if (!p) {
            return fmt::format_to(ctx.out(), "null");
        }
        return fmt::format_to(ctx.out(), "{}", *p);
    }
};
}

namespace seastar {


template<typename T>
struct is_smart_ptr<shared_ptr<T>> : std::true_type {};


template<typename T>
struct is_smart_ptr<lw_shared_ptr<T>> : std::true_type {};

}
# 28 "/home/avi/scylla-maint/seastar/include/seastar/util/backtrace.hh" 2




# 1 "/usr/include/execinfo.h" 1 3 4
# 23 "/usr/include/execinfo.h" 3 4
extern "C" {



extern int backtrace (void **__array, int __size) __attribute__ ((__nonnull__ (1)));




extern char **backtrace_symbols (void *const *__array, int __size)
     noexcept (true) __attribute__ ((__nonnull__ (1)));




extern void backtrace_symbols_fd (void *const *__array, int __size, int __fd)
     noexcept (true) __attribute__ ((__nonnull__ (1)));

}
# 33 "/home/avi/scylla-maint/seastar/include/seastar/util/backtrace.hh" 2





# 1 "/usr/include/boost/container/static_vector.hpp" 1 3 4
# 22 "/usr/include/boost/container/static_vector.hpp" 3 4
# 1 "/usr/include/boost/container/detail/config_begin.hpp" 1 3 4
# 23 "/usr/include/boost/container/static_vector.hpp" 2 3 4
# 1 "/usr/include/boost/container/detail/workaround.hpp" 1 3 4
# 155 "/usr/include/boost/container/detail/workaround.hpp" 3 4
namespace boost {
namespace container {

template <typename T1>
inline __attribute__ ((__always_inline__)) constexpr void ignore(T1 const&)
{}

}}
# 24 "/usr/include/boost/container/static_vector.hpp" 2 3 4
# 1 "/usr/include/boost/container/detail/type_traits.hpp" 1 3 4
# 29 "/usr/include/boost/container/detail/type_traits.hpp" 3 4
namespace boost {
namespace container {
namespace dtl {

using ::boost::move_detail::enable_if;
using ::boost::move_detail::enable_if_and;
using ::boost::move_detail::is_same;
using ::boost::move_detail::is_different;
using ::boost::move_detail::is_pointer;
using ::boost::move_detail::add_reference;
using ::boost::move_detail::add_const;
using ::boost::move_detail::add_const_reference;
using ::boost::move_detail::remove_const;
using ::boost::move_detail::remove_reference;
using ::boost::move_detail::remove_cvref;
using ::boost::move_detail::make_unsigned;
using ::boost::move_detail::is_floating_point;
using ::boost::move_detail::is_integral;
using ::boost::move_detail::is_enum;
using ::boost::move_detail::is_pod;
using ::boost::move_detail::is_empty;
using ::boost::move_detail::is_trivially_destructible;
using ::boost::move_detail::is_trivially_default_constructible;
using ::boost::move_detail::is_trivially_copy_constructible;
using ::boost::move_detail::is_trivially_move_constructible;
using ::boost::move_detail::is_trivially_copy_assignable;
using ::boost::move_detail::is_trivially_move_assignable;
using ::boost::move_detail::is_nothrow_default_constructible;
using ::boost::move_detail::is_nothrow_copy_constructible;
using ::boost::move_detail::is_nothrow_move_constructible;
using ::boost::move_detail::is_nothrow_copy_assignable;
using ::boost::move_detail::is_nothrow_move_assignable;
using ::boost::move_detail::is_nothrow_swappable;
using ::boost::move_detail::alignment_of;
using ::boost::move_detail::aligned_storage;
using ::boost::move_detail::nat;
using ::boost::move_detail::nat2;
using ::boost::move_detail::nat3;
using ::boost::move_detail::natN;
using ::boost::move_detail::max_align_t;
using ::boost::move_detail::is_convertible;

}
}
}
# 25 "/usr/include/boost/container/static_vector.hpp" 2 3 4
# 1 "/usr/include/boost/container/vector.hpp" 1 3 4
# 22 "/usr/include/boost/container/vector.hpp" 3 4
# 1 "/usr/include/boost/container/detail/config_begin.hpp" 1 3 4
# 23 "/usr/include/boost/container/vector.hpp" 2 3 4



# 1 "/usr/include/boost/container/container_fwd.hpp" 1 3 4
# 63 "/usr/include/boost/container/container_fwd.hpp" 3 4
# 1 "/usr/include/boost/container/detail/std_fwd.hpp" 1 3 4
# 26 "/usr/include/boost/container/detail/std_fwd.hpp" 3 4
# 1 "/usr/include/boost/move/detail/std_ns_begin.hpp" 1 3 4
# 27 "/usr/include/boost/container/detail/std_fwd.hpp" 2 3 4
namespace std __attribute__ ((__visibility__ ("default"))) {

template<class T>
class allocator;

template<class T>
struct less;

template<class T>
struct equal_to;

template<class T1, class T2>
struct pair;

template<class T>
struct char_traits;

struct input_iterator_tag;
struct forward_iterator_tag;
struct bidirectional_iterator_tag;
struct random_access_iterator_tag;

template<class Container>
class insert_iterator;

struct allocator_arg_t;

struct piecewise_construct_t;

template <class Ptr>
struct pointer_traits;

 }
# 1 "/usr/include/boost/move/detail/std_ns_end.hpp" 1 3 4
# 61 "/usr/include/boost/container/detail/std_fwd.hpp" 2 3 4
# 64 "/usr/include/boost/container/container_fwd.hpp" 2 3 4


namespace boost{
namespace intrusive{
namespace detail{

}}}

namespace boost{ namespace container{ namespace dtl{
   namespace bi = boost::intrusive;
   namespace bid = boost::intrusive::detail;
}}}

namespace boost{ namespace container{ namespace pmr{
   namespace bi = boost::intrusive;
   namespace bid = boost::intrusive::detail;
}}}
# 90 "/usr/include/boost/container/container_fwd.hpp" 3 4
namespace boost {
namespace container {



template<class T>
class new_allocator;

template <class T
         ,class Allocator = void
         ,class Options = void>
class vector;

template <class T
         ,class Allocator = void >
class stable_vector;

template < class T
         , std::size_t Capacity
         , class Options = void>
class static_vector;

template < class T
         , class Allocator = void
         , class Options = void >
class small_vector_base;

template < class T
         , std::size_t N
         , class Allocator = void
         , class Options = void >
class small_vector;

template <class T
         ,class Allocator = void
         ,class Options = void>
class devector;

template <class T
         ,class Allocator = void
         ,class Options = void>
class deque;

template <class T
         ,class Allocator = void >
class list;

template <class T
         ,class Allocator = void >
class slist;

template <class Key
         ,class Compare = std::less<Key>
         ,class Allocator = void
         ,class Options = void>
class set;

template <class Key
         ,class Compare = std::less<Key>
         ,class Allocator = void
         ,class Options = void >
class multiset;

template <class Key
         ,class T
         ,class Compare = std::less<Key>
         ,class Allocator = void
         ,class Options = void >
class map;

template <class Key
         ,class T
         ,class Compare = std::less<Key>
         ,class Allocator = void
         ,class Options = void >
class multimap;

template <class Key
         ,class Compare = std::less<Key>
         ,class Allocator = void >
class flat_set;

template <class Key
         ,class Compare = std::less<Key>
         ,class Allocator = void >
class flat_multiset;

template <class Key
         ,class T
         ,class Compare = std::less<Key>
         ,class Allocator = void >
class flat_map;

template <class Key
         ,class T
         ,class Compare = std::less<Key>
         ,class Allocator = void >
class flat_multimap;





template < class Key
         , std::size_t N
         , class Compare = std::less<Key>
         , class SmallVectorAllocator = void
         , class SmallVectorOptions = void >
using small_flat_set = flat_set<Key, Compare, small_vector<Key, N, SmallVectorAllocator, SmallVectorOptions>>;

template < class Key
         , std::size_t N
         , class Compare = std::less<Key>
         , class SmallVectorAllocator = void
         , class SmallVectorOptions = void >
using small_flat_multiset = flat_multiset<Key, Compare, small_vector<Key, N, SmallVectorAllocator, SmallVectorOptions>>;

template < class Key
         , class T
         , std::size_t N
         , class Compare = std::less<Key>
         , class SmallVectorAllocator = void
         , class SmallVectorOptions = void >
using small_flat_map = flat_map<Key, T, Compare, small_vector<std::pair<Key, T>, N, SmallVectorAllocator, SmallVectorOptions>>;

template < class Key
         , class T
         , std::size_t N
         , class Compare = std::less<Key>
         , class SmallVectorAllocator = void
         , class SmallVectorOptions = void >
using small_flat_multimap = flat_multimap<Key, T, Compare, small_vector<std::pair<Key, T>, N, SmallVectorAllocator, SmallVectorOptions>>;





template < class Key
         , std::size_t N
         , class Compare = std::less<Key>
         , class SmallVectorAllocator = void
         , class SmallVectorOptions = void >
struct small_flat_set_of
{
   typedef flat_set<Key, Compare, small_vector<Key, N, SmallVectorAllocator, SmallVectorOptions> > type;
};


template < class Key
         , std::size_t N
         , class Compare = std::less<Key>
         , class SmallVectorAllocator = void
         , class SmallVectorOptions = void >
struct small_flat_multiset_of
{
   typedef flat_multiset<Key, Compare, small_vector<Key, N, SmallVectorAllocator, SmallVectorOptions> > type;
};


template < class Key
         , class T
         , std::size_t N
         , class Compare = std::less<Key>
         , class SmallVectorAllocator = void
         , class SmallVectorOptions = void >
struct small_flat_map_of
{
   typedef flat_map<Key, T, Compare, small_vector<std::pair<Key, T>, N, SmallVectorAllocator, SmallVectorOptions> > type;
};


template < class Key
         , class T
         , std::size_t N
         , class Compare = std::less<Key>
         , class SmallVectorAllocator = void
         , class SmallVectorOptions = void >
struct small_flat_multimap_of
{
   typedef flat_multimap<Key, T, Compare, small_vector<std::pair<Key, T>, N, SmallVectorAllocator, SmallVectorOptions> > type;
};

template <class CharT
         ,class Traits = std::char_traits<CharT>
         ,class Allocator = void >
class basic_string;

typedef basic_string <char> string;
typedef basic_string<wchar_t> wstring;

static const std::size_t ADP_nodes_per_block = 256u;
static const std::size_t ADP_max_free_blocks = 2u;
static const std::size_t ADP_overhead_percent = 1u;
static const std::size_t ADP_only_alignment = 0u;

template < class T
         , std::size_t NodesPerBlock = ADP_nodes_per_block
         , std::size_t MaxFreeBlocks = ADP_max_free_blocks
         , std::size_t OverheadPercent = ADP_overhead_percent
         , unsigned Version = 2
         >
class adaptive_pool;

template < class T
         , unsigned Version = 2
         , unsigned int AllocationDisableMask = 0>
class allocator;

static const std::size_t NodeAlloc_nodes_per_block = 256u;

template
   < class T
   , std::size_t NodesPerBlock = NodeAlloc_nodes_per_block
   , std::size_t Version = 2>
class node_allocator;

namespace pmr {

class memory_resource;

template<class T>
class polymorphic_allocator;

class monotonic_buffer_resource;

struct pool_options;

template <class Allocator>
class resource_adaptor_imp;

class unsynchronized_pool_resource;

class synchronized_pool_resource;

}





struct ordered_range_t
{};



static const ordered_range_t ordered_range = ordered_range_t();



struct ordered_unique_range_t
   : public ordered_range_t
{};



static const ordered_unique_range_t ordered_unique_range = ordered_unique_range_t();



struct default_init_t
{};



static const default_init_t default_init = default_init_t();




struct value_init_t
{};



static const value_init_t value_init = value_init_t();

namespace container_detail_really_deep_namespace {



struct dummy
{
   dummy()
   {
      (void)ordered_range;
      (void)ordered_unique_range;
      (void)default_init;
   }
};

}

typedef const std::piecewise_construct_t & piecewise_construct_t;



}}
# 27 "/usr/include/boost/container/vector.hpp" 2 3 4
# 1 "/usr/include/boost/container/allocator_traits.hpp" 1 3 4
# 27 "/usr/include/boost/container/allocator_traits.hpp" 3 4
# 1 "/usr/include/boost/container/detail/config_begin.hpp" 1 3 4
# 28 "/usr/include/boost/container/allocator_traits.hpp" 2 3 4




# 1 "/usr/include/boost/container/detail/mpl.hpp" 1 3 4
# 24 "/usr/include/boost/container/detail/mpl.hpp" 3 4
# 1 "/usr/include/boost/container/detail/config_begin.hpp" 1 3 4
# 25 "/usr/include/boost/container/detail/mpl.hpp" 2 3 4






namespace boost {
namespace container {
namespace dtl {

using boost::move_detail::integral_constant;
using boost::move_detail::true_type;
using boost::move_detail::false_type;
using boost::move_detail::enable_if_c;
using boost::move_detail::enable_if;
using boost::move_detail::enable_if_convertible;
using boost::move_detail::disable_if_c;
using boost::move_detail::disable_if;
using boost::move_detail::disable_if_convertible;
using boost::move_detail::is_convertible;
using boost::move_detail::if_c;
using boost::move_detail::if_;
using boost::move_detail::identity;
using boost::move_detail::bool_;
using boost::move_detail::true_;
using boost::move_detail::false_;
using boost::move_detail::yes_type;
using boost::move_detail::no_type;
using boost::move_detail::bool_;
using boost::move_detail::true_;
using boost::move_detail::false_;
using boost::move_detail::unvoid_ref;
using boost::move_detail::and_;
using boost::move_detail::or_;
using boost::move_detail::not_;
using boost::move_detail::enable_if_and;
using boost::move_detail::disable_if_and;
using boost::move_detail::enable_if_or;
using boost::move_detail::disable_if_or;
using boost::move_detail::remove_const;

template <class FirstType>
struct select1st
{
   typedef FirstType type;

   template<class T>
   inline __attribute__ ((__always_inline__)) const type& operator()(const T& x) const
   { return x.first; }

   template<class T>
   inline __attribute__ ((__always_inline__)) type& operator()(T& x)
   { return const_cast<type&>(x.first); }
};


template<typename T>
struct void_t { typedef void type; };

template <class T, class=void>
struct is_transparent_base
{
   static const bool value = false;
};

template <class T>
struct is_transparent_base<T, typename void_t<typename T::is_transparent>::type>
{
   static const bool value = true;
};

template <class T>
struct is_transparent
   : is_transparent_base<T>
{};

template <typename C, class , typename R>
struct enable_if_transparent
   : boost::move_detail::enable_if_c<dtl::is_transparent<C>::value, R>
{};




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


template<typename Allocator, typename = void>
struct is_allocator
{
   static const bool value = false;
};

template <typename T>
T&& ctad_declval();

template<typename Allocator>
struct is_allocator < Allocator,
   variadic_void_t< typename Allocator::value_type
                  , decltype(ctad_declval<Allocator&>().allocate(size_t{})) >>
{
   static const bool value = true;
};

template<class T>
using require_allocator_t = typename enable_if_c<is_allocator<T>::value, T>::type;

template<class T>
using require_nonallocator_t = typename enable_if_c<!is_allocator<T>::value, T>::type;



}
}
}

# 1 "/usr/include/boost/container/detail/config_end.hpp" 1 3 4
# 142 "/usr/include/boost/container/detail/mpl.hpp" 2 3 4
# 33 "/usr/include/boost/container/allocator_traits.hpp" 2 3 4

# 1 "/usr/include/boost/container/detail/placement_new.hpp" 1 3 4
# 15 "/usr/include/boost/container/detail/placement_new.hpp" 3 4
struct boost_container_new_t{};


inline void *operator new(std::size_t, void *p, boost_container_new_t)
{ return p; }

inline void operator delete(void *, void *, boost_container_new_t)
{}
# 35 "/usr/include/boost/container/allocator_traits.hpp" 2 3 4
# 62 "/usr/include/boost/container/allocator_traits.hpp" 3 4
# 1 "/usr/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 1 3 4
# 32 "/usr/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 3 4
# 1 "/usr/include/boost/move/detail/fwd_macros.hpp" 1 3 4
# 24 "/usr/include/boost/move/detail/fwd_macros.hpp" 3 4
namespace boost {
namespace move_detail {

template <typename T> struct unvoid { typedef T type; };
template <> struct unvoid<void> { struct type { }; };
template <> struct unvoid<const void> { struct type { }; };

}
}
# 33 "/usr/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 2 3 4

namespace boost_intrusive_hmfcw {

typedef char yes_type;
struct no_type{ char dummy[2]; };

struct dont_care
{
   dont_care(...);
};
# 77 "/usr/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 3 4
}
# 111 "/usr/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 3 4
namespace boost { namespace container { namespace dtl {



   template<typename Fun, class ...Args>
   struct has_member_function_callable_with_allocate
   {
      template<class U>
      static decltype(boost::move_detail::declval<U>().
         allocate(::boost::move_detail::declval<Args>()...)
            , boost_intrusive_hmfcw::yes_type()) Test(U* f);
      template<class U>
      static boost_intrusive_hmfcw::no_type Test(...);
      static const bool value = sizeof(Test<Fun>((Fun*)0)) == sizeof(boost_intrusive_hmfcw::yes_type);
   };
# 356 "/usr/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 3 4
}}}
# 63 "/usr/include/boost/container/allocator_traits.hpp" 2 3 4






# 1 "/usr/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 1 3 4
# 111 "/usr/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 3 4
namespace boost { namespace container { namespace dtl {



   template<typename Fun, class ...Args>
   struct has_member_function_callable_with_destroy
   {
      template<class U>
      static decltype(boost::move_detail::declval<U>().
         destroy(::boost::move_detail::declval<Args>()...)
            , boost_intrusive_hmfcw::yes_type()) Test(U* f);
      template<class U>
      static boost_intrusive_hmfcw::no_type Test(...);
      static const bool value = sizeof(Test<Fun>((Fun*)0)) == sizeof(boost_intrusive_hmfcw::yes_type);
   };
# 356 "/usr/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 3 4
}}}
# 70 "/usr/include/boost/container/allocator_traits.hpp" 2 3 4






# 1 "/usr/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 1 3 4
# 111 "/usr/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 3 4
namespace boost { namespace container { namespace dtl {



   template<typename Fun, class ...Args>
   struct has_member_function_callable_with_construct
   {
      template<class U>
      static decltype(boost::move_detail::declval<U>().
         construct(::boost::move_detail::declval<Args>()...)
            , boost_intrusive_hmfcw::yes_type()) Test(U* f);
      template<class U>
      static boost_intrusive_hmfcw::no_type Test(...);
      static const bool value = sizeof(Test<Fun>((Fun*)0)) == sizeof(boost_intrusive_hmfcw::yes_type);
   };
# 356 "/usr/include/boost/intrusive/detail/has_member_function_callable_with.hpp" 3 4
}}}
# 77 "/usr/include/boost/container/allocator_traits.hpp" 2 3 4







namespace boost {
namespace container {



template<class T, class VoidAllocator, class Options>
class small_vector_allocator;

namespace allocator_traits_detail {

template <typename U, typename Signature> class has_max_size { private: template<Signature> struct helper; template<typename T> static ::boost::intrusive::detail::yes_type test(helper<&T::max_size>*); template<typename T> static ::boost::intrusive::detail::no_type test(...); public: static const bool value = sizeof(test<U>(0)) == sizeof(::boost::intrusive::detail::yes_type); };
template <typename U, typename Signature> class has_select_on_container_copy_construction { private: template<Signature> struct helper; template<typename T> static ::boost::intrusive::detail::yes_type test(helper<&T::select_on_container_copy_construction>*); template<typename T> static ::boost::intrusive::detail::no_type test(...); public: static const bool value = sizeof(test<U>(0)) == sizeof(::boost::intrusive::detail::yes_type); };

}

namespace dtl {



template<class Allocator>
struct is_std_allocator
{ static const bool value = false; };

template<class T>
struct is_std_allocator< std::allocator<T> >
{ static const bool value = true; };

template<class T, class Options>
struct is_std_allocator< small_vector_allocator<T, std::allocator<T>, Options > >
{ static const bool value = true; };

template<class Allocator>
struct is_not_std_allocator
{ static const bool value = !is_std_allocator<Allocator>::value; };

template <typename T> struct boost_intrusive_has_type_pointer { template <typename X> static char test(int, typename X::pointer*); template <typename X> static int test(...); static const bool value = (1 == sizeof(test<T>(0, 0))); }; template <typename T, typename DefaultType> struct boost_intrusive_default_type_pointer { struct DefaultWrap { typedef DefaultType pointer; }; typedef typename ::boost::intrusive::detail::if_c < boost_intrusive_has_type_pointer<T>::value , T, DefaultWrap>::type::pointer type; };
template <typename T, typename DefaultType> struct boost_intrusive_eval_default_type_const_pointer { template <typename X> static char test(int, typename X::const_pointer*); template <typename X> static int test(...); struct DefaultWrap { typedef typename DefaultType::type const_pointer; }; static const bool value = (1 == sizeof(test<T>(0, 0))); typedef typename ::boost::intrusive::detail::eval_if_c < value , ::boost::intrusive::detail::identity<T> , ::boost::intrusive::detail::identity<DefaultWrap> >::type::const_pointer type; };
template <typename T> struct boost_intrusive_has_type_reference { template <typename X> static char test(int, typename X::reference*); template <typename X> static int test(...); static const bool value = (1 == sizeof(test<T>(0, 0))); }; template <typename T, typename DefaultType> struct boost_intrusive_default_type_reference { struct DefaultWrap { typedef DefaultType reference; }; typedef typename ::boost::intrusive::detail::if_c < boost_intrusive_has_type_reference<T>::value , T, DefaultWrap>::type::reference type; };
template <typename T> struct boost_intrusive_has_type_const_reference { template <typename X> static char test(int, typename X::const_reference*); template <typename X> static int test(...); static const bool value = (1 == sizeof(test<T>(0, 0))); }; template <typename T, typename DefaultType> struct boost_intrusive_default_type_const_reference { struct DefaultWrap { typedef DefaultType const_reference; }; typedef typename ::boost::intrusive::detail::if_c < boost_intrusive_has_type_const_reference<T>::value , T, DefaultWrap>::type::const_reference type; };
template <typename T, typename DefaultType> struct boost_intrusive_eval_default_type_void_pointer { template <typename X> static char test(int, typename X::void_pointer*); template <typename X> static int test(...); struct DefaultWrap { typedef typename DefaultType::type void_pointer; }; static const bool value = (1 == sizeof(test<T>(0, 0))); typedef typename ::boost::intrusive::detail::eval_if_c < value , ::boost::intrusive::detail::identity<T> , ::boost::intrusive::detail::identity<DefaultWrap> >::type::void_pointer type; };
template <typename T, typename DefaultType> struct boost_intrusive_eval_default_type_const_void_pointer { template <typename X> static char test(int, typename X::const_void_pointer*); template <typename X> static int test(...); struct DefaultWrap { typedef typename DefaultType::type const_void_pointer; }; static const bool value = (1 == sizeof(test<T>(0, 0))); typedef typename ::boost::intrusive::detail::eval_if_c < value , ::boost::intrusive::detail::identity<T> , ::boost::intrusive::detail::identity<DefaultWrap> >::type::const_void_pointer type; };
template <typename T> struct boost_intrusive_has_type_size_type { template <typename X> static char test(int, typename X::size_type*); template <typename X> static int test(...); static const bool value = (1 == sizeof(test<T>(0, 0))); }; template <typename T, typename DefaultType> struct boost_intrusive_default_type_size_type { struct DefaultWrap { typedef DefaultType size_type; }; typedef typename ::boost::intrusive::detail::if_c < boost_intrusive_has_type_size_type<T>::value , T, DefaultWrap>::type::size_type type; };
template <typename T> struct boost_intrusive_has_type_propagate_on_container_copy_assignment { template <typename X> static char test(int, typename X::propagate_on_container_copy_assignment*); template <typename X> static int test(...); static const bool value = (1 == sizeof(test<T>(0, 0))); }; template <typename T, typename DefaultType> struct boost_intrusive_default_type_propagate_on_container_copy_assignment { struct DefaultWrap { typedef DefaultType propagate_on_container_copy_assignment; }; typedef typename ::boost::intrusive::detail::if_c < boost_intrusive_has_type_propagate_on_container_copy_assignment<T>::value , T, DefaultWrap>::type::propagate_on_container_copy_assignment type; };
template <typename T> struct boost_intrusive_has_type_propagate_on_container_move_assignment { template <typename X> static char test(int, typename X::propagate_on_container_move_assignment*); template <typename X> static int test(...); static const bool value = (1 == sizeof(test<T>(0, 0))); }; template <typename T, typename DefaultType> struct boost_intrusive_default_type_propagate_on_container_move_assignment { struct DefaultWrap { typedef DefaultType propagate_on_container_move_assignment; }; typedef typename ::boost::intrusive::detail::if_c < boost_intrusive_has_type_propagate_on_container_move_assignment<T>::value , T, DefaultWrap>::type::propagate_on_container_move_assignment type; };
template <typename T> struct boost_intrusive_has_type_propagate_on_container_swap { template <typename X> static char test(int, typename X::propagate_on_container_swap*); template <typename X> static int test(...); static const bool value = (1 == sizeof(test<T>(0, 0))); }; template <typename T, typename DefaultType> struct boost_intrusive_default_type_propagate_on_container_swap { struct DefaultWrap { typedef DefaultType propagate_on_container_swap; }; typedef typename ::boost::intrusive::detail::if_c < boost_intrusive_has_type_propagate_on_container_swap<T>::value , T, DefaultWrap>::type::propagate_on_container_swap type; };
template <typename T> struct boost_intrusive_has_type_is_always_equal { template <typename X> static char test(int, typename X::is_always_equal*); template <typename X> static int test(...); static const bool value = (1 == sizeof(test<T>(0, 0))); }; template <typename T, typename DefaultType> struct boost_intrusive_default_type_is_always_equal { struct DefaultWrap { typedef DefaultType is_always_equal; }; typedef typename ::boost::intrusive::detail::if_c < boost_intrusive_has_type_is_always_equal<T>::value , T, DefaultWrap>::type::is_always_equal type; };
template <typename T> struct boost_intrusive_has_type_difference_type { template <typename X> static char test(int, typename X::difference_type*); template <typename X> static int test(...); static const bool value = (1 == sizeof(test<T>(0, 0))); }; template <typename T, typename DefaultType> struct boost_intrusive_default_type_difference_type { struct DefaultWrap { typedef DefaultType difference_type; }; typedef typename ::boost::intrusive::detail::if_c < boost_intrusive_has_type_difference_type<T>::value , T, DefaultWrap>::type::difference_type type; };
template <typename T> struct boost_intrusive_has_type_is_partially_propagable { template <typename X> static char test(int, typename X::is_partially_propagable*); template <typename X> static int test(...); static const bool value = (1 == sizeof(test<T>(0, 0))); }; template <typename T, typename DefaultType> struct boost_intrusive_default_type_is_partially_propagable { struct DefaultWrap { typedef DefaultType is_partially_propagable; }; typedef typename ::boost::intrusive::detail::if_c < boost_intrusive_has_type_is_partially_propagable<T>::value , T, DefaultWrap>::type::is_partially_propagable type; };

}





template <typename Allocator>
struct allocator_traits
{

   typedef Allocator allocator_type;

   typedef typename allocator_type::value_type value_type;
# 208 "/usr/include/boost/container/allocator_traits.hpp" 3 4
      typedef typename boost::container::dtl:: boost_intrusive_default_type_pointer< Allocator, value_type* >::type

            pointer;

      typedef typename boost::container::dtl:: boost_intrusive_eval_default_type_const_pointer< Allocator, typename boost::intrusive::pointer_traits<pointer>::template rebind_pointer<const value_type> >::type


               const_pointer;

      typedef typename boost::container::dtl:: boost_intrusive_default_type_reference< Allocator, typename dtl::unvoid_ref<value_type>::type >::type

            reference;

      typedef typename boost::container::dtl:: boost_intrusive_default_type_const_reference< Allocator, typename dtl::unvoid_ref<const value_type>::type >::type

               const_reference;

      typedef typename boost::container::dtl:: boost_intrusive_eval_default_type_void_pointer< Allocator, typename boost::intrusive::pointer_traits<pointer>::template rebind_pointer<void> >::type


               void_pointer;

      typedef typename boost::container::dtl:: boost_intrusive_eval_default_type_const_void_pointer< Allocator, typename boost::intrusive::pointer_traits<pointer>::template rebind_pointer<const void> >::type


               const_void_pointer;

      typedef typename boost::container::dtl:: boost_intrusive_default_type_difference_type< Allocator, std::ptrdiff_t >::type

            difference_type;

      typedef typename boost::container::dtl:: boost_intrusive_default_type_size_type< Allocator, std::size_t >::type

            size_type;

      typedef typename boost::container::dtl:: boost_intrusive_default_type_propagate_on_container_copy_assignment< Allocator, dtl::false_type >::type

            propagate_on_container_copy_assignment;

      typedef typename boost::container::dtl:: boost_intrusive_default_type_propagate_on_container_move_assignment< Allocator, dtl::false_type >::type

            propagate_on_container_move_assignment;

      typedef typename boost::container::dtl:: boost_intrusive_default_type_propagate_on_container_swap< Allocator, dtl::false_type >::type

            propagate_on_container_swap;

      typedef typename boost::container::dtl:: boost_intrusive_default_type_is_always_equal< Allocator, dtl::is_empty<Allocator> >::type

            is_always_equal;

      typedef typename boost::container::dtl:: boost_intrusive_default_type_is_partially_propagable< Allocator, dtl::false_type >::type

            is_partially_propagable;




         template <typename T> using rebind_alloc = typename boost::intrusive::pointer_rebind<Allocator, T>::type;
         template <typename T> using rebind_traits = allocator_traits< rebind_alloc<T> >;
# 294 "/usr/include/boost/container/allocator_traits.hpp" 3 4
      template <class T>
      struct portable_rebind_alloc
      { typedef typename boost::intrusive::pointer_rebind<Allocator, T>::type type; };




   inline __attribute__ ((__always_inline__)) static pointer allocate(Allocator &a, size_type n)
   { return a.allocate(n); }




   inline __attribute__ ((__always_inline__)) static void deallocate(Allocator &a, pointer p, size_type n)
   { a.deallocate(p, n); }



   inline __attribute__ ((__always_inline__)) static pointer allocate(Allocator &a, size_type n, const_void_pointer p)
   {
      const bool value = boost::container::dtl::
         has_member_function_callable_with_allocate
            <Allocator, const size_type, const const_void_pointer>::value;
      dtl::bool_<value> flag;
      return allocator_traits::priv_allocate(flag, a, n, p);
   }



   template<class T>
   inline __attribute__ ((__always_inline__)) static void destroy(Allocator &a, T*p) noexcept
   {
      typedef T* destroy_pointer;
      const bool value = boost::container::dtl::
         has_member_function_callable_with_destroy
            <Allocator, const destroy_pointer>::value;
      dtl::bool_<value> flag;
      allocator_traits::priv_destroy(flag, a, p);
   }



   inline __attribute__ ((__always_inline__)) static size_type max_size(const Allocator &a) noexcept
   {
      const bool value = allocator_traits_detail::has_max_size<Allocator, size_type (Allocator::*)() const>::value;
      dtl::bool_<value> flag;
      return allocator_traits::priv_max_size(flag, a);
   }



   inline __attribute__ ((__always_inline__)) static typename dtl::if_c < allocator_traits_detail::has_select_on_container_copy_construction<Allocator , Allocator (Allocator::*)() const>::value , Allocator , const Allocator & >::type



   select_on_container_copy_construction(const Allocator &a)
   {
      const bool value = allocator_traits_detail::has_select_on_container_copy_construction
         <Allocator, Allocator (Allocator::*)() const>::value;
      dtl::bool_<value> flag;
      return allocator_traits::priv_select_on_container_copy_construction(flag, a);
   }




      template <class T, class ...Args>
      inline __attribute__ ((__always_inline__)) static void construct(Allocator & a, T* p, Args &&... args)
      {
         static const bool value = ::boost::move_detail::and_
            < dtl::is_not_std_allocator<Allocator>
            , boost::container::dtl::has_member_function_callable_with_construct
                  < Allocator, T*, Args... >
            >::value;
         dtl::bool_<value> flag;
         allocator_traits::priv_construct(flag, a, p, ::boost::forward<Args>(args)...);
      }




   inline __attribute__ ((__always_inline__)) static bool storage_is_unpropagable(const Allocator &a, pointer p) noexcept
   {
      dtl::bool_<is_partially_propagable::value> flag;
      return allocator_traits::priv_storage_is_unpropagable(flag, a, p);
   }



   inline __attribute__ ((__always_inline__)) static bool equal(const Allocator &a, const Allocator &b) noexcept
   {
      dtl::bool_<is_always_equal::value> flag;
      return allocator_traits::priv_equal(flag, a, b);
   }


   private:
   inline __attribute__ ((__always_inline__)) static pointer priv_allocate(dtl::true_type, Allocator &a, size_type n, const_void_pointer p)
   { return a.allocate(n, p); }

   inline __attribute__ ((__always_inline__)) static pointer priv_allocate(dtl::false_type, Allocator &a, size_type n, const_void_pointer)
   { return a.allocate(n); }

   template<class T>
   inline __attribute__ ((__always_inline__)) static void priv_destroy(dtl::true_type, Allocator &a, T* p) noexcept
   { a.destroy(p); }

   template<class T>
   inline __attribute__ ((__always_inline__)) static void priv_destroy(dtl::false_type, Allocator &, T* p) noexcept
   { p->~T(); (void)p; }

   inline __attribute__ ((__always_inline__)) static size_type priv_max_size(dtl::true_type, const Allocator &a) noexcept
   { return a.max_size(); }

   inline __attribute__ ((__always_inline__)) static size_type priv_max_size(dtl::false_type, const Allocator &) noexcept
   { return size_type(-1)/sizeof(value_type); }

   inline __attribute__ ((__always_inline__)) static Allocator priv_select_on_container_copy_construction(dtl::true_type, const Allocator &a)
   { return a.select_on_container_copy_construction(); }

   inline __attribute__ ((__always_inline__)) static const Allocator &priv_select_on_container_copy_construction(dtl::false_type, const Allocator &a) noexcept
   { return a; }


      template<class T, class ...Args>
      inline __attribute__ ((__always_inline__)) static void priv_construct(dtl::true_type, Allocator &a, T *p, Args && ...args)
      { a.construct( p, ::boost::forward<Args>(args)...); }

      template<class T, class ...Args>
      inline __attribute__ ((__always_inline__)) static void priv_construct(dtl::false_type, Allocator &, T *p, Args && ...args)
      { ::new((void*)p, boost_container_new_t()) T(::boost::forward<Args>(args)...); }
# 462 "/usr/include/boost/container/allocator_traits.hpp" 3 4
   template<class T>
   inline __attribute__ ((__always_inline__)) static void priv_construct(dtl::false_type, Allocator &, T *p, const ::boost::container::default_init_t&)
   { ::new((void*)p, boost_container_new_t()) T; }

   inline __attribute__ ((__always_inline__)) static bool priv_storage_is_unpropagable(dtl::true_type, const Allocator &a, pointer p)
   { return a.storage_is_unpropagable(p); }

   inline __attribute__ ((__always_inline__)) static bool priv_storage_is_unpropagable(dtl::false_type, const Allocator &, pointer)
   { return false; }

   inline __attribute__ ((__always_inline__)) static bool priv_equal(dtl::true_type, const Allocator &, const Allocator &)
   { return true; }

   inline __attribute__ ((__always_inline__)) static bool priv_equal(dtl::false_type, const Allocator &a, const Allocator &b)
   { return a == b; }


};



template<class T, class AllocatorOrVoid>
struct real_allocator
{
   typedef AllocatorOrVoid type;
};

template<class T>
struct real_allocator<T, void>
{
   typedef new_allocator<T> type;
};



}
}

# 1 "/usr/include/boost/container/detail/config_end.hpp" 1 3 4
# 501 "/usr/include/boost/container/allocator_traits.hpp" 2 3 4
# 28 "/usr/include/boost/container/vector.hpp" 2 3 4
# 1 "/usr/include/boost/container/new_allocator.hpp" 1 3 4
# 22 "/usr/include/boost/container/new_allocator.hpp" 3 4
# 1 "/usr/include/boost/container/detail/config_begin.hpp" 1 3 4
# 23 "/usr/include/boost/container/new_allocator.hpp" 2 3 4

# 1 "/usr/include/boost/container/throw_exception.hpp" 1 3 4
# 22 "/usr/include/boost/container/throw_exception.hpp" 3 4
# 1 "/usr/include/boost/container/detail/config_begin.hpp" 1 3 4
# 23 "/usr/include/boost/container/throw_exception.hpp" 2 3 4
# 46 "/usr/include/boost/container/throw_exception.hpp" 3 4
namespace boost {
namespace container {

class __attribute__((__visibility__("default"))) exception
   : public ::std::exception
{
   typedef ::std::exception std_exception_t;

   public:


   explicit exception(const char *msg)
      : std_exception_t(), m_msg(msg)
   {}

   virtual const char *what() const noexcept override
   { return m_msg ? m_msg : "unknown boost::container exception"; }

   private:
   const char *m_msg;
};

class __attribute__((__visibility__("default"))) bad_alloc
   : public exception
{
   public:
   bad_alloc()
      : exception("boost::container::bad_alloc thrown")
   {}
};

typedef bad_alloc bad_alloc_t;

class __attribute__((__visibility__("default"))) out_of_range
   : public exception
{
   public:
   explicit out_of_range(const char *msg)
      : exception(msg)
   {}
};

typedef out_of_range out_of_range_t;

class __attribute__((__visibility__("default"))) length_error
   : public exception
{
   public:
   explicit length_error(const char *msg)
      : exception(msg)
   {}
};

typedef length_error length_error_t;

class __attribute__((__visibility__("default"))) logic_error
   : public exception
{
   public:
   explicit logic_error(const char *msg)
      : exception(msg)
   {}
};

typedef logic_error logic_error_t;

class __attribute__((__visibility__("default"))) runtime_error
   : public exception
{
   public:
   explicit runtime_error(const char *msg)
      : exception(msg)
   {}
};

typedef runtime_error runtime_error_t;

}
}







namespace boost {
namespace container {
# 201 "/usr/include/boost/container/throw_exception.hpp" 3 4
   __attribute__ ((__noreturn__)) inline void throw_bad_alloc()
   {
      throw bad_alloc_t();
   }
# 221 "/usr/include/boost/container/throw_exception.hpp" 3 4
   __attribute__ ((__noreturn__)) inline void throw_out_of_range(const char* str)
   {
      throw out_of_range_t(str);
   }
# 242 "/usr/include/boost/container/throw_exception.hpp" 3 4
   __attribute__ ((__noreturn__)) inline void throw_length_error(const char* str)
   {
      throw length_error_t(str);
   }
# 264 "/usr/include/boost/container/throw_exception.hpp" 3 4
   __attribute__ ((__noreturn__)) inline void throw_logic_error(const char* str)
   {
      throw logic_error_t(str);
   }
# 284 "/usr/include/boost/container/throw_exception.hpp" 3 4
   __attribute__ ((__noreturn__)) inline void throw_runtime_error(const char* str)
   {
      throw runtime_error_t(str);
   }



}}

# 1 "/usr/include/boost/container/detail/config_end.hpp" 1 3 4
# 294 "/usr/include/boost/container/throw_exception.hpp" 2 3 4
# 25 "/usr/include/boost/container/new_allocator.hpp" 2 3 4




namespace boost {
namespace container {



template<bool Value>
struct new_allocator_bool
{ static const bool value = Value; };

template<class T>
class new_allocator;




template<>
class new_allocator<void>
{
   public:
   typedef void value_type;
   typedef void * pointer;
   typedef const void* const_pointer;

   typedef new_allocator_bool<true> propagate_on_container_move_assignment;

   typedef new_allocator_bool<true> is_always_equal;




   template<class T2>
   struct rebind
   {
      typedef new_allocator< T2> other;
   };



   new_allocator() noexcept
   {}



   new_allocator(const new_allocator &) noexcept
   {}



   new_allocator& operator=(const new_allocator &) noexcept
   {
       return *this;
   }



   template<class T2>
   new_allocator(const new_allocator<T2> &) noexcept
   {}



   friend void swap(new_allocator &, new_allocator &) noexcept
   {}



   friend bool operator==(const new_allocator &, const new_allocator &) noexcept
   { return true; }



   friend bool operator!=(const new_allocator &, const new_allocator &) noexcept
   { return false; }
};



template<class T>
class new_allocator
{
   public:
   typedef T value_type;
   typedef T * pointer;
   typedef const T * const_pointer;
   typedef T & reference;
   typedef const T & const_reference;
   typedef std::size_t size_type;
   typedef std::ptrdiff_t difference_type;

   typedef new_allocator_bool<true> propagate_on_container_move_assignment;

   typedef new_allocator_bool<true> is_always_equal;



   template<class T2>
   struct rebind
   {
      typedef new_allocator<T2> other;
   };



   new_allocator() noexcept
   {}



   new_allocator(const new_allocator &) noexcept
   {}



   new_allocator& operator=(const new_allocator &) noexcept
   {
       return *this;
   }



   template<class T2>
   new_allocator(const new_allocator<T2> &) noexcept
   {}



   pointer allocate(size_type count)
   {
      const std::size_t max_count = std::size_t(-1)/(2*sizeof(T));
      if(__builtin_expect(count > max_count, 0))
         throw_bad_alloc();
      return static_cast<T*>(::operator new(count*sizeof(T)));
   }



   void deallocate(pointer ptr, size_type n) noexcept
   {
      (void)n;



      ::operator delete((void*)ptr);

   }



   size_type max_size() const noexcept
   { return std::size_t(-1)/(2*sizeof(T)); }



   friend void swap(new_allocator &, new_allocator &) noexcept
   {}



   friend bool operator==(const new_allocator &, const new_allocator &) noexcept
   { return true; }



   friend bool operator!=(const new_allocator &, const new_allocator &) noexcept
   { return false; }
};

}
}

# 1 "/usr/include/boost/container/detail/config_end.hpp" 1 3 4
# 200 "/usr/include/boost/container/new_allocator.hpp" 2 3 4
# 29 "/usr/include/boost/container/vector.hpp" 2 3 4

# 1 "/usr/include/boost/container/options.hpp" 1 3 4
# 24 "/usr/include/boost/container/options.hpp" 3 4
# 1 "/usr/include/boost/container/detail/config_begin.hpp" 1 3 4
# 25 "/usr/include/boost/container/options.hpp" 2 3 4




namespace boost {
namespace container {
# 42 "/usr/include/boost/container/options.hpp" 3 4
enum tree_type_enum
{
   red_black_tree,
   avl_tree,
   scapegoat_tree,
   splay_tree
};



template<tree_type_enum TreeType, bool OptimizeSize>
struct tree_opt
{
   static const boost::container::tree_type_enum tree_type = TreeType;
   static const bool optimize_size = OptimizeSize;
};

typedef tree_opt<red_black_tree, true> tree_assoc_defaults;





template< tree_type_enum TreeType> struct tree_type { static const tree_type_enum value = TreeType; template<class Base> struct pack : Base { static const tree_type_enum tree_type = TreeType; }; };



template< bool Enabled> struct optimize_size { static const bool value = Enabled; template<class Base> struct pack : Base { static const bool optimize_size = Enabled; }; };
# 78 "/usr/include/boost/container/options.hpp" 3 4
template<class O1 = void, class O2 = void, class O3 = void, class O4 = void>

struct tree_assoc_options
{

   typedef typename ::boost::intrusive::pack_options
      < tree_assoc_defaults,

      O1, O2, O3, O4



      >::type packed_options;
   typedef tree_opt<packed_options::tree_type, packed_options::optimize_size> implementation_defined;

   typedef implementation_defined type;
};





template<class ...Options>
using tree_assoc_options_t = typename boost::container::tree_assoc_options<Options...>::type;
# 116 "/usr/include/boost/container/options.hpp" 3 4
template<bool StoreHash, bool CacheBegin, bool LinearBuckets, bool FastmodBuckets>
struct hash_opt
{
   static const bool store_hash = StoreHash;
   static const bool cache_begin = CacheBegin;
   static const bool linear_buckets = LinearBuckets;
   static const bool fastmod_buckets = FastmodBuckets;
};

typedef hash_opt<false, false, false, false> hash_assoc_defaults;






template< bool Enabled> struct store_hash { static const bool value = Enabled; template<class Base> struct pack : Base { static const bool store_hash = Enabled; }; };




template< bool Enabled> struct cache_begin { static const bool value = Enabled; template<class Base> struct pack : Base { static const bool cache_begin = Enabled; }; };

template< bool Enabled> struct linear_buckets { static const bool value = Enabled; template<class Base> struct pack : Base { static const bool linear_buckets = Enabled; }; };

template< bool Enabled> struct fastmod_buckets { static const bool value = Enabled; template<class Base> struct pack : Base { static const bool fastmod_buckets = Enabled; }; };
# 150 "/usr/include/boost/container/options.hpp" 3 4
template<class O1 = void, class O2 = void, class O3 = void, class O4 = void>

struct hash_assoc_options
{

   typedef typename ::boost::intrusive::pack_options
      < hash_assoc_defaults,

      O1, O2, O3, O4



      >::type packed_options;
   typedef hash_opt<packed_options::store_hash
                   ,packed_options::cache_begin
                   ,packed_options::linear_buckets
                   ,packed_options::fastmod_buckets
                   > implementation_defined;

   typedef implementation_defined type;
};





template<class ...Options>
using hash_assoc_options_t = typename boost::container::hash_assoc_options<Options...>::type;
# 191 "/usr/include/boost/container/options.hpp" 3 4
template<class T, class Default>
struct default_if_void
{
   typedef T type;
};

template<class Default>
struct default_if_void<void, Default>
{
   typedef Default type;
};

template<std::size_t N, std::size_t DefaultN>
struct default_if_zero
{
   static const std::size_t value = N;
};

template<std::size_t DefaultN>
struct default_if_zero<0u, DefaultN>
{
   static const std::size_t value = DefaultN;
};







template<class AllocTraits, class StoredSizeType>
struct get_stored_size_type_with_alloctraits
{
   typedef StoredSizeType type;
};

template<class AllocTraits>
struct get_stored_size_type_with_alloctraits<AllocTraits, void>
{
   typedef typename AllocTraits::size_type type;
};

template<class GrowthType, class StoredSizeType>
struct vector_opt
{
   typedef GrowthType growth_factor_type;
   typedef StoredSizeType stored_size_type;

   template<class AllocTraits>
   struct get_stored_size_type
      : get_stored_size_type_with_alloctraits<AllocTraits, StoredSizeType>
   {};
};

class default_next_capacity;

typedef vector_opt<void, void> vector_null_opt;
# 282 "/usr/include/boost/container/options.hpp" 3 4
template< class GrowthFactor> struct growth_factor { template<class Base> struct pack : Base { typedef GrowthFactor growth_factor_type; }; };
# 309 "/usr/include/boost/container/options.hpp" 3 4
template< class StoredSizeType> struct stored_size { template<class Base> struct pack : Base { typedef StoredSizeType stored_size_type; }; };







template<class O1 = void, class O2 = void, class O3 = void, class O4 = void>

struct vector_options
{

   typedef typename ::boost::intrusive::pack_options
      < vector_null_opt,

      O1, O2, O3, O4



      >::type packed_options;
   typedef vector_opt< typename packed_options::growth_factor_type
                     , typename packed_options::stored_size_type> implementation_defined;

   typedef implementation_defined type;
};






template<class ...Options>
using vector_options_t = typename boost::container::vector_options<Options...>::type;
# 359 "/usr/include/boost/container/options.hpp" 3 4
template< std::size_t Alignment> struct inplace_alignment { static const std::size_t value = Alignment; template<class Base> struct pack : Base { static const std::size_t inplace_alignment = Alignment; }; };



template<class GrowthType, std::size_t InplaceAlignment>
struct small_vector_opt
{
   typedef GrowthType growth_factor_type;
   static const std::size_t inplace_alignment = InplaceAlignment;
};

typedef small_vector_opt<void, 0u> small_vector_null_opt;
# 380 "/usr/include/boost/container/options.hpp" 3 4
template<class O1 = void, class O2 = void, class O3 = void, class O4 = void>

struct small_vector_options
{

   typedef typename ::boost::intrusive::pack_options
      < small_vector_null_opt,

      O1, O2, O3, O4



      >::type packed_options;
   typedef small_vector_opt< typename packed_options::growth_factor_type
                           , packed_options::inplace_alignment> implementation_defined;

   typedef implementation_defined type;
};






template<class ...Options>
using small_vector_options_t = typename boost::container::small_vector_options<Options...>::type;
# 426 "/usr/include/boost/container/options.hpp" 3 4
template< bool ThrowOnOverflow> struct throw_on_overflow { static const bool value = ThrowOnOverflow; template<class Base> struct pack : Base { static const bool throw_on_overflow = ThrowOnOverflow; }; };



template<bool ThrowOnOverflow, std::size_t InplaceAlignment>
struct static_vector_opt
{
   static const bool throw_on_overflow = ThrowOnOverflow;
   static const std::size_t inplace_alignment = InplaceAlignment;
};

typedef static_vector_opt<true, 0u> static_vector_null_opt;
# 447 "/usr/include/boost/container/options.hpp" 3 4
template<class O1 = void, class O2 = void, class O3 = void, class O4 = void>

struct static_vector_options
{

   typedef typename ::boost::intrusive::pack_options
      < static_vector_null_opt,

      O1, O2, O3, O4



      >::type packed_options;
   typedef static_vector_opt< packed_options::throw_on_overflow
                            , packed_options::inplace_alignment> implementation_defined;

   typedef implementation_defined type;
};






template<class ...Options>
using static_vector_options_t = typename boost::container::static_vector_options<Options...>::type;
# 502 "/usr/include/boost/container/options.hpp" 3 4
template< std::size_t Fraction> struct relocate_on { static const std::size_t value = Fraction; template<class Base> struct pack : Base { static const std::size_t free_fraction = Fraction; }; };

struct relocate_on_66 : public relocate_on<3U>{};

struct relocate_on_75 : public relocate_on<4U> {};

struct relocate_on_80 : public relocate_on<5U> {};

struct relocate_on_85 : public relocate_on<7U> {};

struct relocate_on_90 : public relocate_on<10U> {};

template<class GrowthType, class StoredSizeType, std::size_t FreeFraction>
struct devector_opt
   : vector_opt<GrowthType, StoredSizeType>
{
   static const std::size_t free_fraction = FreeFraction;
};

typedef devector_opt<void, void, 0u> devector_null_opt;
# 565 "/usr/include/boost/container/options.hpp" 3 4
template<class O1 = void, class O2 = void, class O3 = void, class O4 = void>

struct devector_options
{

   typedef typename ::boost::intrusive::pack_options
      < devector_null_opt,

      O1, O2, O3, O4



      >::type packed_options;
   typedef devector_opt< typename packed_options::growth_factor_type
                       , typename packed_options::stored_size_type
                       , packed_options::free_fraction
                       > implementation_defined;

   typedef implementation_defined type;
};






template<class ...Options>
using devector_options_t = typename boost::container::devector_options<Options...>::type;
# 606 "/usr/include/boost/container/options.hpp" 3 4
template<std::size_t BlockBytes, std::size_t BlockSize>
struct deque_opt
{
   static const std::size_t block_bytes = BlockBytes;
   static const std::size_t block_size = BlockSize;
   static_assert(!(block_bytes && block_size), "block_bytes and block_size can't be specified at the same time");
};

typedef deque_opt<0u, 0u> deque_null_opt;
# 624 "/usr/include/boost/container/options.hpp" 3 4
template<class O1 = void, class O2 = void, class O3 = void, class O4 = void>

struct deque_options
{

   typedef typename ::boost::intrusive::pack_options
      < deque_null_opt,

      O1, O2, O3, O4



      >::type packed_options;
   typedef deque_opt< packed_options::block_bytes, packed_options::block_size > implementation_defined;

   typedef implementation_defined type;
};






template<class ...Options>
using deque_options_t = typename boost::container::deque_options<Options...>::type;
# 657 "/usr/include/boost/container/options.hpp" 3 4
template< std::size_t BlockBytes> struct block_bytes { static const std::size_t value = BlockBytes; template<class Base> struct pack : Base { static const std::size_t block_bytes = BlockBytes; }; };






template< std::size_t BlockSize> struct block_size { static const std::size_t value = BlockSize; template<class Base> struct pack : Base { static const std::size_t block_size = BlockSize; }; };

}
}

# 1 "/usr/include/boost/container/detail/config_end.hpp" 1 3 4
# 670 "/usr/include/boost/container/options.hpp" 2 3 4
# 31 "/usr/include/boost/container/vector.hpp" 2 3 4

# 1 "/usr/include/boost/container/detail/advanced_insert_int.hpp" 1 3 4
# 22 "/usr/include/boost/container/detail/advanced_insert_int.hpp" 3 4
# 1 "/usr/include/boost/container/detail/config_begin.hpp" 1 3 4
# 23 "/usr/include/boost/container/detail/advanced_insert_int.hpp" 2 3 4





# 1 "/usr/include/boost/container/detail/copy_move_algo.hpp" 1 3 4
# 24 "/usr/include/boost/container/detail/copy_move_algo.hpp" 3 4
# 1 "/usr/include/boost/container/detail/iterator.hpp" 1 3 4
# 28 "/usr/include/boost/container/detail/iterator.hpp" 3 4
namespace boost {
namespace container {

using ::boost::intrusive::iterator_traits;
using ::boost::intrusive::iter_difference;
using ::boost::intrusive::iter_category;
using ::boost::intrusive::iter_value;
using ::boost::intrusive::iter_size;
using ::boost::intrusive::iterator_distance;
using ::boost::intrusive::iterator_udistance;
using ::boost::intrusive::iterator_advance;
using ::boost::intrusive::iterator_uadvance;
using ::boost::intrusive::make_iterator_advance;
using ::boost::intrusive::make_iterator_uadvance;
using ::boost::intrusive::iterator;
using ::boost::intrusive::iterator_enable_if_tag;
using ::boost::intrusive::iterator_disable_if_tag;
using ::boost::intrusive::iterator_arrow_result;

template <class Container>
class back_emplacer
{
   private:
   Container& container;

   public:
   typedef std::output_iterator_tag iterator_category;
   typedef void value_type;
   typedef void difference_type;
   typedef void pointer;
   typedef void reference;

   back_emplacer(Container& x)
      : container(x)
   {}

   template<class U>
   back_emplacer& operator=(U && value)
   {
      container.emplace_back(boost::forward<U>(value));
      return *this;
   }
   back_emplacer& operator*() { return *this; }
   back_emplacer& operator++() { return *this; }
   back_emplacer& operator++(int){ return *this; }
};



template<class InputIterator>
using it_based_non_const_first_type_t = typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type;

template<class InputIterator>
using it_based_const_first_type_t = const typename dtl::remove_const<typename iterator_traits<InputIterator>::value_type::first_type>::type;

template<class InputIterator>
using it_based_second_type_t = typename iterator_traits<InputIterator>::value_type::second_type;

template<class InputIterator>
using it_based_value_type_t = typename iterator_traits<InputIterator>::value_type;



}
}
# 25 "/usr/include/boost/container/detail/copy_move_algo.hpp" 2 3 4
# 1 "/usr/include/boost/move/detail/iterator_to_raw_pointer.hpp" 1 3 4
# 25 "/usr/include/boost/move/detail/iterator_to_raw_pointer.hpp" 3 4
namespace boost {
namespace movelib {
namespace detail {

template <class T>
inline __attribute__ ((__always_inline__)) T* iterator_to_pointer(T* i)
{ return i; }

template <class Iterator>
inline __attribute__ ((__always_inline__)) typename boost::movelib::iterator_traits<Iterator>::pointer
   iterator_to_pointer(const Iterator &i)
{ return i.operator->(); }

template <class Iterator>
struct iterator_to_element_ptr
{
   typedef typename boost::movelib::iterator_traits<Iterator>::pointer pointer;
   typedef typename boost::movelib::pointer_element<pointer>::type element_type;
   typedef element_type* type;
};

}

template <class Iterator>
inline __attribute__ ((__always_inline__)) typename boost::movelib::detail::iterator_to_element_ptr<Iterator>::type
   iterator_to_raw_pointer(const Iterator &i)
{
   return ::boost::movelib::to_raw_pointer
      ( ::boost::movelib::detail::iterator_to_pointer(i) );
}

}
}
# 26 "/usr/include/boost/container/detail/copy_move_algo.hpp" 2 3 4


# 1 "/usr/include/boost/container/detail/construct_in_place.hpp" 1 3 4
# 25 "/usr/include/boost/container/detail/construct_in_place.hpp" 3 4
# 1 "/usr/include/boost/container/detail/iterators.hpp" 1 3 4
# 25 "/usr/include/boost/container/detail/iterators.hpp" 3 4
# 1 "/usr/include/boost/container/detail/config_begin.hpp" 1 3 4
# 26 "/usr/include/boost/container/detail/iterators.hpp" 2 3 4



# 1 "/usr/include/boost/container/detail/value_init.hpp" 1 3 4
# 24 "/usr/include/boost/container/detail/value_init.hpp" 3 4
# 1 "/usr/include/boost/container/detail/config_begin.hpp" 1 3 4
# 25 "/usr/include/boost/container/detail/value_init.hpp" 2 3 4


namespace boost {
namespace container {
namespace dtl {

template<class T>
struct value_init
{
   value_init()
      : m_t()
   {}

   operator T &() { return m_t; }

   T &get() { return m_t; }

   T m_t;
};

}
}
}

# 1 "/usr/include/boost/container/detail/config_end.hpp" 1 3 4
# 50 "/usr/include/boost/container/detail/value_init.hpp" 2 3 4
# 30 "/usr/include/boost/container/detail/iterators.hpp" 2 3 4







# 1 "/usr/include/boost/container/detail/variadic_templates_tools.hpp" 1 3 4
# 22 "/usr/include/boost/container/detail/variadic_templates_tools.hpp" 3 4
# 1 "/usr/include/boost/container/detail/config_begin.hpp" 1 3 4
# 23 "/usr/include/boost/container/detail/variadic_templates_tools.hpp" 2 3 4






namespace boost {
namespace container {
namespace dtl {

template<typename... Values>
class tuple;

template<> class tuple<>
{};

template<typename Head, typename... Tail>
class tuple<Head, Tail...>
   : private tuple<Tail...>
{
   typedef tuple<Tail...> inherited;

   public:
   tuple()
      : inherited(), m_head()
   {}

   template<class U, class ...Args>
   tuple(U &&u, Args && ...args)
      : inherited(::boost::forward<Args>(args)...), m_head(::boost::forward<U>(u))
   {}


   template<typename... VValues>
   tuple(const tuple<VValues...>& other)
      : inherited(other.tail()), m_head(other.head())
   {}

   template<typename... VValues>
   tuple& operator=(const tuple<VValues...>& other)
   {
      m_head = other.head();
      tail() = other.tail();
      return this;
   }

   typename add_reference<Head>::type head() { return m_head; }
   typename add_reference<const Head>::type head() const { return m_head; }

   inherited& tail() { return *this; }
   const inherited& tail() const { return *this; }

   protected:
   Head m_head;
};


template<typename... Values>
tuple<Values&&...> forward_as_tuple_impl(Values&&... values)
{ return tuple<Values&&...>(::boost::forward<Values>(values)...); }

template<int I, typename Tuple>
struct tuple_element;

template<int I, typename Head, typename... Tail>
struct tuple_element<I, tuple<Head, Tail...> >
{
   typedef typename tuple_element<I-1, tuple<Tail...> >::type type;
};

template<typename Head, typename... Tail>
struct tuple_element<0, tuple<Head, Tail...> >
{
   typedef Head type;
};

template<int I, typename Tuple>
class get_impl;

template<int I, typename Head, typename... Values>
class get_impl<I, tuple<Head, Values...> >
{
   typedef typename tuple_element<I-1, tuple<Values...> >::type Element;
   typedef get_impl<I-1, tuple<Values...> > Next;

   public:
   typedef typename add_reference<Element>::type type;
   typedef typename add_const_reference<Element>::type const_type;
   static type get(tuple<Head, Values...>& t) { return Next::get(t.tail()); }
   static const_type get(const tuple<Head, Values...>& t) { return Next::get(t.tail()); }
};

template<typename Head, typename... Values>
class get_impl<0, tuple<Head, Values...> >
{
   public:
   typedef typename add_reference<Head>::type type;
   typedef typename add_const_reference<Head>::type const_type;
   static type get(tuple<Head, Values...>& t) { return t.head(); }
   static const_type get(const tuple<Head, Values...>& t){ return t.head(); }
};

template<int I, typename... Values>
typename get_impl<I, tuple<Values...> >::type get(tuple<Values...>& t)
{ return get_impl<I, tuple<Values...> >::get(t); }

template<int I, typename... Values>
typename get_impl<I, tuple<Values...> >::const_type get(const tuple<Values...>& t)
{ return get_impl<I, tuple<Values...> >::get(t); }







template<std::size_t...> struct index_tuple{ typedef index_tuple type; };

template<class S1, class S2> struct concat_index_tuple;

template<std::size_t... I1, std::size_t... I2>
struct concat_index_tuple<index_tuple<I1...>, index_tuple<I2...>>
  : index_tuple<I1..., (sizeof...(I1)+I2)...>{};

template<std::size_t N> struct build_number_seq;

template<std::size_t N>
struct build_number_seq
   : concat_index_tuple<typename build_number_seq<N/2>::type
                       ,typename build_number_seq<N - N/2 >::type
   >::type
{};

template<> struct build_number_seq<0> : index_tuple<>{};
template<> struct build_number_seq<1> : index_tuple<0>{};

}}}

# 1 "/usr/include/boost/container/detail/config_end.hpp" 1 3 4
# 162 "/usr/include/boost/container/detail/variadic_templates_tools.hpp" 2 3 4
# 38 "/usr/include/boost/container/detail/iterators.hpp" 2 3 4



namespace boost {
namespace container {

template <class T>
class constant_iterator
  : public ::boost::container::iterator
      <std::random_access_iterator_tag, T, std::ptrdiff_t, const T*, const T &>
{
   typedef constant_iterator<T> this_type;

   public:
   inline __attribute__ ((__always_inline__)) explicit constant_iterator(const T &ref, std::size_t range_size)
      : m_ptr(&ref), m_num(range_size){}


   inline __attribute__ ((__always_inline__)) constant_iterator()
      : m_ptr(0), m_num(0){}

   inline __attribute__ ((__always_inline__)) constant_iterator& operator++()
   { increment(); return *this; }

   inline __attribute__ ((__always_inline__)) constant_iterator operator++(int)
   {
      constant_iterator result (*this);
      increment();
      return result;
   }

   inline __attribute__ ((__always_inline__)) constant_iterator& operator--()
   { decrement(); return *this; }

   inline __attribute__ ((__always_inline__)) constant_iterator operator--(int)
   {
      constant_iterator result (*this);
      decrement();
      return result;
   }

   inline __attribute__ ((__always_inline__)) friend bool operator== (const constant_iterator& i, const constant_iterator& i2)
   { return i.equal(i2); }

   inline __attribute__ ((__always_inline__)) friend bool operator!= (const constant_iterator& i, const constant_iterator& i2)
   { return !(i == i2); }

   inline __attribute__ ((__always_inline__)) friend bool operator< (const constant_iterator& i, const constant_iterator& i2)
   { return i.less(i2); }

   inline __attribute__ ((__always_inline__)) friend bool operator> (const constant_iterator& i, const constant_iterator& i2)
   { return i2 < i; }

   inline __attribute__ ((__always_inline__)) friend bool operator<= (const constant_iterator& i, const constant_iterator& i2)
   { return !(i > i2); }

   inline __attribute__ ((__always_inline__)) friend bool operator>= (const constant_iterator& i, const constant_iterator& i2)
   { return !(i < i2); }

   inline __attribute__ ((__always_inline__)) friend std::ptrdiff_t operator- (const constant_iterator& i, const constant_iterator& i2)
   { return i2.distance_to(i); }


   inline __attribute__ ((__always_inline__)) constant_iterator& operator+=(std::ptrdiff_t off)
   { this->advance(off); return *this; }

   inline __attribute__ ((__always_inline__)) constant_iterator operator+(std::ptrdiff_t off) const
   {
      constant_iterator other(*this);
      other.advance(off);
      return other;
   }

   inline __attribute__ ((__always_inline__)) friend constant_iterator operator+(std::ptrdiff_t off, const constant_iterator& right)
   { return right + off; }

   inline __attribute__ ((__always_inline__)) constant_iterator& operator-=(std::ptrdiff_t off)
   { this->advance(-off); return *this; }

   inline __attribute__ ((__always_inline__)) constant_iterator operator-(std::ptrdiff_t off) const
   { return *this + (-off); }

   inline __attribute__ ((__always_inline__)) const T& operator[] (std::ptrdiff_t ) const
   { return dereference(); }

   inline __attribute__ ((__always_inline__)) const T& operator*() const
   { return dereference(); }

   inline __attribute__ ((__always_inline__)) const T* operator->() const
   { return &(dereference()); }


   inline __attribute__ ((__always_inline__)) constant_iterator& operator+=(std::size_t off)
   { return *this += std::ptrdiff_t(off); }

   inline __attribute__ ((__always_inline__)) constant_iterator operator+(std::size_t off) const
   { return *this + std::ptrdiff_t(off); }

   inline __attribute__ ((__always_inline__)) friend constant_iterator operator+(std::size_t off, const constant_iterator& right)
   { return std::ptrdiff_t(off) + right; }

   inline __attribute__ ((__always_inline__)) constant_iterator& operator-=(std::size_t off)
   { return *this -= std::ptrdiff_t(off); }

   inline __attribute__ ((__always_inline__)) constant_iterator operator-(std::size_t off) const
   { return *this - std::ptrdiff_t(off); }

   inline __attribute__ ((__always_inline__)) const T& operator[] (std::size_t off) const
   { return (*this)[std::ptrdiff_t(off)]; }

   private:
   const T * m_ptr;
   std::size_t m_num;

   inline __attribute__ ((__always_inline__)) void increment()
   { --m_num; }

   inline __attribute__ ((__always_inline__)) void decrement()
   { ++m_num; }

   inline __attribute__ ((__always_inline__)) bool equal(const this_type &other) const
   { return m_num == other.m_num; }

   inline __attribute__ ((__always_inline__)) bool less(const this_type &other) const
   { return other.m_num < m_num; }

   inline __attribute__ ((__always_inline__)) const T & dereference() const
   { return *m_ptr; }

   inline __attribute__ ((__always_inline__)) void advance(std::ptrdiff_t n)
   { m_num = std::size_t(std::ptrdiff_t(m_num) - n); }

   inline __attribute__ ((__always_inline__)) std::ptrdiff_t distance_to(const this_type &other)const
   { return std::ptrdiff_t(m_num - other.m_num); }
};

template <class T>
class value_init_construct_iterator
  : public ::boost::container::iterator
      <std::random_access_iterator_tag, T, std::ptrdiff_t, const T*, const T &>
{
   typedef value_init_construct_iterator<T> this_type;

   public:
   inline __attribute__ ((__always_inline__)) explicit value_init_construct_iterator(std::size_t range_size)
      : m_num(range_size){}


   inline __attribute__ ((__always_inline__)) value_init_construct_iterator()
      : m_num(0){}

   inline __attribute__ ((__always_inline__)) value_init_construct_iterator& operator++()
   { increment(); return *this; }

   inline __attribute__ ((__always_inline__)) value_init_construct_iterator operator++(int)
   {
      value_init_construct_iterator result (*this);
      increment();
      return result;
   }

   inline __attribute__ ((__always_inline__)) value_init_construct_iterator& operator--()
   { decrement(); return *this; }

   inline __attribute__ ((__always_inline__)) value_init_construct_iterator operator--(int)
   {
      value_init_construct_iterator result (*this);
      decrement();
      return result;
   }

   inline __attribute__ ((__always_inline__)) friend bool operator== (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
   { return i.equal(i2); }

   inline __attribute__ ((__always_inline__)) friend bool operator!= (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
   { return !(i == i2); }

   inline __attribute__ ((__always_inline__)) friend bool operator< (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
   { return i.less(i2); }

   inline __attribute__ ((__always_inline__)) friend bool operator> (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
   { return i2 < i; }

   inline __attribute__ ((__always_inline__)) friend bool operator<= (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
   { return !(i > i2); }

   inline __attribute__ ((__always_inline__)) friend bool operator>= (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
   { return !(i < i2); }

   inline __attribute__ ((__always_inline__)) friend std::ptrdiff_t operator- (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
   { return i2.distance_to(i); }


   inline __attribute__ ((__always_inline__)) value_init_construct_iterator& operator+=(std::ptrdiff_t off)
   { this->advance(off); return *this; }

   inline __attribute__ ((__always_inline__)) value_init_construct_iterator operator+(std::ptrdiff_t off) const
   {
      value_init_construct_iterator other(*this);
      other.advance(off);
      return other;
   }

   inline __attribute__ ((__always_inline__)) friend value_init_construct_iterator operator+(std::ptrdiff_t off, const value_init_construct_iterator& right)
   { return right + off; }

   inline __attribute__ ((__always_inline__)) value_init_construct_iterator& operator-=(std::ptrdiff_t off)
   { this->advance(-off); return *this; }

   inline __attribute__ ((__always_inline__)) value_init_construct_iterator operator-(std::ptrdiff_t off) const
   { return *this + (-off); }
# 257 "/usr/include/boost/container/detail/iterators.hpp" 3 4
   private:
   std::size_t m_num;

   inline __attribute__ ((__always_inline__)) void increment()
   { --m_num; }

   inline __attribute__ ((__always_inline__)) void decrement()
   { ++m_num; }

   inline __attribute__ ((__always_inline__)) bool equal(const this_type &other) const
   { return m_num == other.m_num; }

   inline __attribute__ ((__always_inline__)) bool less(const this_type &other) const
   { return other.m_num < m_num; }

   inline __attribute__ ((__always_inline__)) const T & dereference() const
   {
      static T dummy;
      return dummy;
   }

   inline __attribute__ ((__always_inline__)) void advance(std::ptrdiff_t n)
   { m_num = std::size_t(std::ptrdiff_t(m_num) - n); }

   inline __attribute__ ((__always_inline__)) std::ptrdiff_t distance_to(const this_type &other)const
   { return std::ptrdiff_t(m_num - other.m_num); }
};

template <class T>
class default_init_construct_iterator
  : public ::boost::container::iterator
      <std::random_access_iterator_tag, T, std::ptrdiff_t, const T*, const T &>
{
   typedef default_init_construct_iterator<T> this_type;

   public:
   inline __attribute__ ((__always_inline__)) explicit default_init_construct_iterator(std::size_t range_size)
      : m_num(range_size){}


   inline __attribute__ ((__always_inline__)) default_init_construct_iterator()
      : m_num(0){}

   inline __attribute__ ((__always_inline__)) default_init_construct_iterator& operator++()
   { increment(); return *this; }

   inline __attribute__ ((__always_inline__)) default_init_construct_iterator operator++(int)
   {
      default_init_construct_iterator result (*this);
      increment();
      return result;
   }

   inline __attribute__ ((__always_inline__)) default_init_construct_iterator& operator--()
   { decrement(); return *this; }

   inline __attribute__ ((__always_inline__)) default_init_construct_iterator operator--(int)
   {
      default_init_construct_iterator result (*this);
      decrement();
      return result;
   }

   inline __attribute__ ((__always_inline__)) friend bool operator== (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
   { return i.equal(i2); }

   inline __attribute__ ((__always_inline__)) friend bool operator!= (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
   { return !(i == i2); }

   inline __attribute__ ((__always_inline__)) friend bool operator< (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
   { return i.less(i2); }

   inline __attribute__ ((__always_inline__)) friend bool operator> (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
   { return i2 < i; }

   inline __attribute__ ((__always_inline__)) friend bool operator<= (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
   { return !(i > i2); }

   inline __attribute__ ((__always_inline__)) friend bool operator>= (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
   { return !(i < i2); }

   inline __attribute__ ((__always_inline__)) friend std::ptrdiff_t operator- (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
   { return i2.distance_to(i); }


   inline __attribute__ ((__always_inline__)) default_init_construct_iterator& operator+=(std::ptrdiff_t off)
   { this->advance(off); return *this; }

   inline __attribute__ ((__always_inline__)) default_init_construct_iterator operator+(std::ptrdiff_t off) const
   {
      default_init_construct_iterator other(*this);
      other.advance(off);
      return other;
   }

   inline __attribute__ ((__always_inline__)) friend default_init_construct_iterator operator+(std::ptrdiff_t off, const default_init_construct_iterator& right)
   { return right + off; }

   inline __attribute__ ((__always_inline__)) default_init_construct_iterator& operator-=(std::ptrdiff_t off)
   { this->advance(-off); return *this; }

   inline __attribute__ ((__always_inline__)) default_init_construct_iterator operator-(std::ptrdiff_t off) const
   { return *this + (-off); }
# 368 "/usr/include/boost/container/detail/iterators.hpp" 3 4
   private:
   std::size_t m_num;

   inline __attribute__ ((__always_inline__)) void increment()
   { --m_num; }

   inline __attribute__ ((__always_inline__)) void decrement()
   { ++m_num; }

   inline __attribute__ ((__always_inline__)) bool equal(const this_type &other) const
   { return m_num == other.m_num; }

   inline __attribute__ ((__always_inline__)) bool less(const this_type &other) const
   { return other.m_num < m_num; }

   inline __attribute__ ((__always_inline__)) const T & dereference() const
   {
      static T dummy;
      return dummy;
   }

   inline __attribute__ ((__always_inline__)) void advance(std::ptrdiff_t n)
   { m_num = std::size_t(std::ptrdiff_t(m_num) - n); }

   inline __attribute__ ((__always_inline__)) std::ptrdiff_t distance_to(const this_type &other) const
   { return std::ptrdiff_t(m_num - other.m_num); }
};


template <class T>
class repeat_iterator
  : public ::boost::container::iterator
      <std::random_access_iterator_tag, T, std::ptrdiff_t, T*, T&>
{
   typedef repeat_iterator<T> this_type;
   public:
   inline __attribute__ ((__always_inline__)) explicit repeat_iterator(T &ref, std::size_t range_size)
      : m_ptr(&ref), m_num(range_size){}


   inline __attribute__ ((__always_inline__)) repeat_iterator()
      : m_ptr(0), m_num(0){}

   inline __attribute__ ((__always_inline__)) this_type& operator++()
   { increment(); return *this; }

   inline __attribute__ ((__always_inline__)) this_type operator++(int)
   {
      this_type result (*this);
      increment();
      return result;
   }

   inline __attribute__ ((__always_inline__)) this_type& operator--()
   { increment(); return *this; }

   inline __attribute__ ((__always_inline__)) this_type operator--(int)
   {
      this_type result (*this);
      increment();
      return result;
   }

   inline __attribute__ ((__always_inline__)) friend bool operator== (const this_type& i, const this_type& i2)
   { return i.equal(i2); }

   inline __attribute__ ((__always_inline__)) friend bool operator!= (const this_type& i, const this_type& i2)
   { return !(i == i2); }

   inline __attribute__ ((__always_inline__)) friend bool operator< (const this_type& i, const this_type& i2)
   { return i.less(i2); }

   inline __attribute__ ((__always_inline__)) friend bool operator> (const this_type& i, const this_type& i2)
   { return i2 < i; }

   inline __attribute__ ((__always_inline__)) friend bool operator<= (const this_type& i, const this_type& i2)
   { return !(i > i2); }

   inline __attribute__ ((__always_inline__)) friend bool operator>= (const this_type& i, const this_type& i2)
   { return !(i < i2); }

   inline __attribute__ ((__always_inline__)) friend std::ptrdiff_t operator- (const this_type& i, const this_type& i2)
   { return i2.distance_to(i); }


   inline __attribute__ ((__always_inline__)) this_type& operator+=(std::ptrdiff_t off)
   { this->advance(off); return *this; }

   inline __attribute__ ((__always_inline__)) this_type operator+(std::ptrdiff_t off) const
   {
      this_type other(*this);
      other.advance(off);
      return other;
   }

   inline __attribute__ ((__always_inline__)) friend this_type operator+(std::ptrdiff_t off, const this_type& right)
   { return right + off; }

   inline __attribute__ ((__always_inline__)) this_type& operator-=(std::ptrdiff_t off)
   { this->advance(-off); return *this; }

   inline __attribute__ ((__always_inline__)) this_type operator-(std::ptrdiff_t off) const
   { return *this + (-off); }

   inline __attribute__ ((__always_inline__)) T& operator*() const
   { return dereference(); }

   inline __attribute__ ((__always_inline__)) T& operator[] (std::ptrdiff_t ) const
   { return dereference(); }

   inline __attribute__ ((__always_inline__)) T *operator->() const
   { return &(dereference()); }

   private:
   T * m_ptr;
   std::size_t m_num;

   inline __attribute__ ((__always_inline__)) void increment()
   { --m_num; }

   inline __attribute__ ((__always_inline__)) void decrement()
   { ++m_num; }

   inline __attribute__ ((__always_inline__)) bool equal(const this_type &other) const
   { return m_num == other.m_num; }

   inline __attribute__ ((__always_inline__)) bool less(const this_type &other) const
   { return other.m_num < m_num; }

   inline __attribute__ ((__always_inline__)) T & dereference() const
   { return *m_ptr; }

   inline __attribute__ ((__always_inline__)) void advance(std::ptrdiff_t n)
   { m_num = std::size_t(std::ptrdiff_t(m_num - n)); }

   inline __attribute__ ((__always_inline__)) std::ptrdiff_t distance_to(const this_type &other)const
   { return std::ptrdiff_t(m_num - other.m_num); }
};

template <class T, class EmplaceFunctor>
class emplace_iterator
  : public ::boost::container::iterator
      <std::random_access_iterator_tag, T, std::ptrdiff_t, const T*, const T &>
{
   typedef emplace_iterator this_type;

   public:
   typedef std::ptrdiff_t difference_type;
   inline __attribute__ ((__always_inline__)) explicit emplace_iterator(EmplaceFunctor&e)
      : m_num(1), m_pe(&e){}

   inline __attribute__ ((__always_inline__)) emplace_iterator()
      : m_num(0), m_pe(0){}

   inline __attribute__ ((__always_inline__)) this_type& operator++()
   { increment(); return *this; }

   inline __attribute__ ((__always_inline__)) this_type operator++(int)
   {
      this_type result (*this);
      increment();
      return result;
   }

   inline __attribute__ ((__always_inline__)) this_type& operator--()
   { decrement(); return *this; }

   inline __attribute__ ((__always_inline__)) this_type operator--(int)
   {
      this_type result (*this);
      decrement();
      return result;
   }

   inline __attribute__ ((__always_inline__)) friend bool operator== (const this_type& i, const this_type& i2)
   { return i.equal(i2); }

   inline __attribute__ ((__always_inline__)) friend bool operator!= (const this_type& i, const this_type& i2)
   { return !(i == i2); }

   inline __attribute__ ((__always_inline__)) friend bool operator< (const this_type& i, const this_type& i2)
   { return i.less(i2); }

   inline __attribute__ ((__always_inline__)) friend bool operator> (const this_type& i, const this_type& i2)
   { return i2 < i; }

   inline __attribute__ ((__always_inline__)) friend bool operator<= (const this_type& i, const this_type& i2)
   { return !(i > i2); }

   inline __attribute__ ((__always_inline__)) friend bool operator>= (const this_type& i, const this_type& i2)
   { return !(i < i2); }

   inline __attribute__ ((__always_inline__)) friend difference_type operator- (const this_type& i, const this_type& i2)
   { return i2.distance_to(i); }


   inline __attribute__ ((__always_inline__)) this_type& operator+=(difference_type off)
   { this->advance(off); return *this; }

   inline __attribute__ ((__always_inline__)) this_type operator+(difference_type off) const
   {
      this_type other(*this);
      other.advance(off);
      return other;
   }

   inline __attribute__ ((__always_inline__)) friend this_type operator+(difference_type off, const this_type& right)
   { return right + off; }

   inline __attribute__ ((__always_inline__)) this_type& operator-=(difference_type off)
   { this->advance(-off); return *this; }

   inline __attribute__ ((__always_inline__)) this_type operator-(difference_type off) const
   { return *this + (-off); }

   private:



   const T& operator*() const;
   const T& operator[](difference_type) const;
   const T* operator->() const;

   public:
   template<class Allocator>
   inline __attribute__ ((__always_inline__)) void construct_in_place(Allocator &a, T* ptr)
   { (*m_pe)(a, ptr); }

   template<class DestIt>
   inline __attribute__ ((__always_inline__)) void assign_in_place(DestIt dest)
   { (*m_pe)(dest); }

   private:
   std::size_t m_num;
   EmplaceFunctor * m_pe;

   inline __attribute__ ((__always_inline__)) void increment()
   { --m_num; }

   inline __attribute__ ((__always_inline__)) void decrement()
   { ++m_num; }

   inline __attribute__ ((__always_inline__)) bool equal(const this_type &other) const
   { return m_num == other.m_num; }

   inline __attribute__ ((__always_inline__)) bool less(const this_type &other) const
   { return other.m_num < m_num; }

   inline __attribute__ ((__always_inline__)) const T & dereference() const
   {
      static T dummy;
      return dummy;
   }

   inline __attribute__ ((__always_inline__)) void advance(difference_type n)
   { m_num -= n; }

   inline __attribute__ ((__always_inline__)) difference_type distance_to(const this_type &other)const
   { return difference_type(m_num - other.m_num); }
};



template<class ...Args>
struct emplace_functor
{
   typedef typename dtl::build_number_seq<sizeof...(Args)>::type index_tuple_t;

   inline __attribute__ ((__always_inline__)) emplace_functor(Args &&... args)
      : args_(args...)
   {}

   template<class Allocator, class T>
   inline __attribute__ ((__always_inline__)) void operator()(Allocator &a, T *ptr)
   { emplace_functor::inplace_impl(a, ptr, index_tuple_t()); }

   template<class DestIt>
   inline __attribute__ ((__always_inline__)) void operator()(DestIt dest)
   { emplace_functor::inplace_impl(dest, index_tuple_t()); }

   private:
   template<class Allocator, class T, std::size_t ...IdxPack>
   inline __attribute__ ((__always_inline__)) void inplace_impl(Allocator &a, T* ptr, const dtl::index_tuple<IdxPack...>&)
   {
      allocator_traits<Allocator>::construct
         (a, ptr, ::boost::forward<Args>(dtl::get<IdxPack>(args_))...);
   }

   template<class DestIt, std::size_t ...IdxPack>
   inline __attribute__ ((__always_inline__)) void inplace_impl(DestIt dest, const dtl::index_tuple<IdxPack...>&)
   {
      typedef typename boost::container::iterator_traits<DestIt>::value_type value_type;
      value_type && tmp= value_type(::boost::forward<Args>(dtl::get<IdxPack>(args_))...);
      *dest = ::boost::move(tmp);
   }

   dtl::tuple<Args&...> args_;
};

template<class ...Args>
struct emplace_functor_type
{
   typedef emplace_functor<Args...> type;
};
# 714 "/usr/include/boost/container/detail/iterators.hpp" 3 4
namespace dtl {

template<class T>
struct has_iterator_category
{
   struct two { char _[2]; };

   template <typename X>
   static char test(int, typename X::iterator_category*);

   template <typename X>
   static two test(int, ...);

   static const bool value = (1 == sizeof(test<T>(0, 0)));
};


template<class T, bool = has_iterator_category<T>::value >
struct is_input_iterator
{
   static const bool value = is_same<typename T::iterator_category, std::input_iterator_tag>::value;
};

template<class T>
struct is_input_iterator<T, false>
{
   static const bool value = false;
};

template<class T>
struct is_not_input_iterator
{
   static const bool value = !is_input_iterator<T>::value;
};

template<class T, bool = has_iterator_category<T>::value >
struct is_forward_iterator
{
   static const bool value = is_same<typename T::iterator_category, std::forward_iterator_tag>::value;
};

template<class T>
struct is_forward_iterator<T, false>
{
   static const bool value = false;
};

template<class T, bool = has_iterator_category<T>::value >
struct is_bidirectional_iterator
{
   static const bool value = is_same<typename T::iterator_category, std::bidirectional_iterator_tag>::value;
};

template<class T>
struct is_bidirectional_iterator<T, false>
{
   static const bool value = false;
};

template<class IINodeType>
struct iiterator_node_value_type {
  typedef typename IINodeType::value_type type;
};

template<class IIterator>
struct iiterator_types
{
   typedef typename IIterator::value_type it_value_type;
   typedef typename iiterator_node_value_type<it_value_type>::type value_type;
   typedef typename boost::container::iterator_traits<IIterator>::pointer it_pointer;
   typedef typename boost::container::iterator_traits<IIterator>::difference_type difference_type;
   typedef typename ::boost::intrusive::pointer_traits<it_pointer>::
      template rebind_pointer<value_type>::type pointer;
   typedef typename ::boost::intrusive::pointer_traits<it_pointer>::
      template rebind_pointer<const value_type>::type const_pointer;
   typedef typename ::boost::intrusive::
      pointer_traits<pointer>::reference reference;
   typedef typename ::boost::intrusive::
      pointer_traits<const_pointer>::reference const_reference;
   typedef typename IIterator::iterator_category iterator_category;
};

template<class IIterator, bool IsConst>
struct iterator_types
{
   typedef typename ::boost::container::iterator
      < typename iiterator_types<IIterator>::iterator_category
      , typename iiterator_types<IIterator>::value_type
      , typename iiterator_types<IIterator>::difference_type
      , typename iiterator_types<IIterator>::const_pointer
      , typename iiterator_types<IIterator>::const_reference> type;
};

template<class IIterator>
struct iterator_types<IIterator, false>
{
   typedef typename ::boost::container::iterator
      < typename iiterator_types<IIterator>::iterator_category
      , typename iiterator_types<IIterator>::value_type
      , typename iiterator_types<IIterator>::difference_type
      , typename iiterator_types<IIterator>::pointer
      , typename iiterator_types<IIterator>::reference> type;
};

template<class IIterator, bool IsConst>
class iterator_from_iiterator
{
   typedef typename iterator_types<IIterator, IsConst>::type types_t;
   class nat
   {
      public:
      IIterator get() const
      { return IIterator(); }
   };
   typedef typename dtl::if_c< IsConst
                             , iterator_from_iiterator<IIterator, false>
                             , nat>::type nonconst_iterator;

   public:
   typedef typename types_t::pointer pointer;
   typedef typename types_t::reference reference;
   typedef typename types_t::difference_type difference_type;
   typedef typename types_t::iterator_category iterator_category;
   typedef typename types_t::value_type value_type;

   inline __attribute__ ((__always_inline__)) iterator_from_iiterator()
      : m_iit()
   {}

   inline __attribute__ ((__always_inline__)) explicit iterator_from_iiterator(IIterator iit) noexcept
      : m_iit(iit)
   {}

   inline __attribute__ ((__always_inline__)) iterator_from_iiterator(const iterator_from_iiterator& other) noexcept
      : m_iit(other.get())
   {}

   inline __attribute__ ((__always_inline__)) iterator_from_iiterator(const nonconst_iterator& other) noexcept
      : m_iit(other.get())
   {}

   inline __attribute__ ((__always_inline__)) iterator_from_iiterator& operator=(const iterator_from_iiterator& other) noexcept
   { m_iit = other.get(); return *this; }

   inline __attribute__ ((__always_inline__)) iterator_from_iiterator& operator++() noexcept
   { ++this->m_iit; return *this; }

   inline __attribute__ ((__always_inline__)) iterator_from_iiterator operator++(int) noexcept
   {
      iterator_from_iiterator result (*this);
      ++this->m_iit;
      return result;
   }

   inline __attribute__ ((__always_inline__)) iterator_from_iiterator& operator--() noexcept
   {

      static_assert((is_bidirectional_iterator<iterator_from_iiterator>::value), "(is_bidirectional_iterator<iterator_from_iiterator>::value)");
      --this->m_iit; return *this;
   }

   inline __attribute__ ((__always_inline__)) iterator_from_iiterator operator--(int) noexcept
   {
      iterator_from_iiterator result (*this);
      --this->m_iit;
      return result;
   }

   inline __attribute__ ((__always_inline__)) friend bool operator== (const iterator_from_iiterator& l, const iterator_from_iiterator& r) noexcept
   { return l.m_iit == r.m_iit; }

   inline __attribute__ ((__always_inline__)) friend bool operator!= (const iterator_from_iiterator& l, const iterator_from_iiterator& r) noexcept
   { return l.m_iit != r.m_iit; }

   inline __attribute__ ((__always_inline__)) reference operator*() const noexcept
   { return this->m_iit->get_data(); }

   inline __attribute__ ((__always_inline__)) pointer operator->() const noexcept
   { return ::boost::intrusive::pointer_traits<pointer>::pointer_to(this->operator*()); }

   inline __attribute__ ((__always_inline__)) const IIterator &get() const noexcept
   { return this->m_iit; }

   private:
   IIterator m_iit;
};

}

using ::boost::intrusive::reverse_iterator;

}
}

# 1 "/usr/include/boost/container/detail/config_end.hpp" 1 3 4
# 909 "/usr/include/boost/container/detail/iterators.hpp" 2 3 4
# 26 "/usr/include/boost/container/detail/construct_in_place.hpp" 2 3 4


namespace boost {
namespace container {



struct iterator_arg_t{};

template<class Allocator, class T, class InpIt>
inline __attribute__ ((__always_inline__)) void construct_in_place(Allocator &a, T* dest, InpIt source)
{ boost::container::allocator_traits<Allocator>::construct(a, dest, *source); }

template<class Allocator, class T, class U>
inline __attribute__ ((__always_inline__)) void construct_in_place(Allocator &a, T *dest, value_init_construct_iterator<U>)
{
   boost::container::allocator_traits<Allocator>::construct(a, dest);
}

template <class T>
class default_init_construct_iterator;

template<class Allocator, class T, class U>
inline __attribute__ ((__always_inline__)) void construct_in_place(Allocator &a, T *dest, default_init_construct_iterator<U>)
{
   boost::container::allocator_traits<Allocator>::construct(a, dest, default_init);
}

template <class T, class EmplaceFunctor>
class emplace_iterator;

template<class Allocator, class T, class U, class EF>
inline __attribute__ ((__always_inline__)) void construct_in_place(Allocator &a, T *dest, emplace_iterator<U, EF> ei)
{
   ei.construct_in_place(a, dest);
}



template<class DstIt, class InpIt>
inline __attribute__ ((__always_inline__)) void assign_in_place(DstIt dest, InpIt source)
{ *dest = *source; }

template<class DstIt, class U>
inline __attribute__ ((__always_inline__)) void assign_in_place(DstIt dest, value_init_construct_iterator<U>)
{
   dtl::value_init<U> val;
   *dest = boost::move(val.get());
}

template <class DstIt>
class default_init_construct_iterator;

template<class DstIt, class U, class D>
inline __attribute__ ((__always_inline__)) void assign_in_place(DstIt dest, default_init_construct_iterator<U>)
{
   U u;
   *dest = boost::move(u);
}

template <class T, class EmplaceFunctor>
class emplace_iterator;

template<class DstIt, class U, class EF>
inline __attribute__ ((__always_inline__)) void assign_in_place(DstIt dest, emplace_iterator<U, EF> ei)
{
   ei.assign_in_place(dest);
}

}
}
# 29 "/usr/include/boost/container/detail/copy_move_algo.hpp" 2 3 4
# 1 "/usr/include/boost/container/detail/destroyers.hpp" 1 3 4
# 24 "/usr/include/boost/container/detail/destroyers.hpp" 3 4
# 1 "/usr/include/boost/container/detail/config_begin.hpp" 1 3 4
# 25 "/usr/include/boost/container/detail/destroyers.hpp" 2 3 4




# 1 "/usr/include/boost/container/detail/version_type.hpp" 1 3 4
# 27 "/usr/include/boost/container/detail/version_type.hpp" 3 4
# 1 "/usr/include/boost/container/detail/config_begin.hpp" 1 3 4
# 28 "/usr/include/boost/container/detail/version_type.hpp" 2 3 4





namespace boost{
namespace container {
namespace dtl {

template <class T, unsigned V>
struct version_type
    : public dtl::integral_constant<unsigned, V>
{
    typedef T type;
};

namespace impl{

template <class T>
struct extract_version
{
   typedef typename T::version type;
};

template <class T>
struct has_version
{
   private:
   struct two {char _[2];};
   template <class U> static two test(...);
   template <class U> static char test(const typename U::version*);
   public:
   static const bool value = sizeof(test<T>(0)) == 1;
   void dummy(){}
};

template <class T, bool = has_version<T>::value>
struct version
{
   static const unsigned value = 1;
};

template <class T>
struct version<T, true>
{
   static const unsigned value = extract_version<T>::type::value;
};

}

template <class T>
struct version
   : public dtl::integral_constant<unsigned, impl::version<T>::value>
{};

template<class T, unsigned N>
struct is_version
{
   static const bool value =
      is_same< typename version<T>::type, integral_constant<unsigned, N> >::value;
};

}

typedef dtl::integral_constant<unsigned, 0> version_0;
typedef dtl::integral_constant<unsigned, 1> version_1;
typedef dtl::integral_constant<unsigned, 2> version_2;

}
}

# 1 "/usr/include/boost/container/detail/config_end.hpp" 1 3 4
# 100 "/usr/include/boost/container/detail/version_type.hpp" 2 3 4
# 30 "/usr/include/boost/container/detail/destroyers.hpp" 2 3 4


namespace boost {
namespace container {
namespace dtl {



template <class Allocator>
struct scoped_deallocator
{
   typedef allocator_traits<Allocator> allocator_traits_type;
   typedef typename allocator_traits_type::pointer pointer;
   typedef dtl::integral_constant<unsigned,
      boost::container::dtl::
         version<Allocator>::value> alloc_version;

   private:
   void priv_deallocate(version_1)
   { m_alloc.deallocate(m_ptr, 1); }

   void priv_deallocate(version_2)
   { m_alloc.deallocate_one(m_ptr); }

   public: scoped_deallocator(scoped_deallocator const &) = delete; scoped_deallocator& operator=(scoped_deallocator const &) = delete; public: typedef int boost_move_no_copy_constructor_or_assign; private: public: typedef int boost_move_emulation_t; private:

   public:

   pointer m_ptr;
   Allocator& m_alloc;

   scoped_deallocator(pointer p, Allocator& a)
      : m_ptr(p), m_alloc(a)
   {}

   ~scoped_deallocator()
   { if (m_ptr)priv_deallocate(alloc_version()); }

   scoped_deallocator(scoped_deallocator && o)
      : m_ptr(o.m_ptr), m_alloc(o.m_alloc)
   { o.release(); }

   pointer get() const
   { return m_ptr; }

   void set(const pointer &p)
   { m_ptr = p; }

   void release()
   { m_ptr = 0; }
};

template <class Allocator>
struct null_scoped_deallocator
{
   typedef boost::container::allocator_traits<Allocator> AllocTraits;
   typedef typename AllocTraits::pointer pointer;

   null_scoped_deallocator(pointer, Allocator&, std::size_t)
   {}

   void release()
   {}

   pointer get() const
   { return pointer(); }

   void set(const pointer &)
   {}
};



template <class Allocator>
struct scoped_array_deallocator
{
   typedef boost::container::allocator_traits<Allocator> AllocTraits;
   typedef typename AllocTraits::pointer pointer;
   typedef typename AllocTraits::size_type size_type;

   scoped_array_deallocator(pointer p, Allocator& a, std::size_t length)
      : m_ptr(p), m_alloc(a), m_length(length) {}

   ~scoped_array_deallocator()
   { if (m_ptr) m_alloc.deallocate(m_ptr, size_type(m_length)); }

   void release()
   { m_ptr = 0; }

   private:
   pointer m_ptr;
   Allocator& m_alloc;
   std::size_t m_length;
};

template <class Allocator>
struct null_scoped_array_deallocator
{
   typedef boost::container::allocator_traits<Allocator> AllocTraits;
   typedef typename AllocTraits::pointer pointer;

   null_scoped_array_deallocator(pointer, Allocator&, std::size_t)
   {}

   void release()
   {}
};

template <class Allocator>
struct scoped_node_destroy_deallocator
{
   typedef boost::container::allocator_traits<Allocator> AllocTraits;
   typedef typename AllocTraits::pointer pointer;
   typedef dtl::integral_constant<unsigned,
      boost::container::dtl::
         version<Allocator>::value> alloc_version;

   scoped_node_destroy_deallocator(pointer p, Allocator& a)
      : m_ptr(p), m_alloc(a) {}

   ~scoped_node_destroy_deallocator()
   {
      if(m_ptr){
         boost::movelib::to_raw_pointer(m_ptr)->destructor(m_alloc);
         priv_deallocate(m_ptr, alloc_version());
      }
   }

   void release()
   { m_ptr = 0; }

   private:

   void priv_deallocate(const pointer &p, version_1)
   { AllocTraits::deallocate(m_alloc, p, 1); }

   void priv_deallocate(const pointer &p, version_2)
   { m_alloc.deallocate_one(p); }

   pointer m_ptr;
   Allocator& m_alloc;
};




template <class Allocator, class Ptr = typename allocator_traits<Allocator>::pointer>
struct scoped_destructor_n
{
   typedef boost::container::allocator_traits<Allocator> AllocTraits;
   typedef Ptr pointer;
   typedef typename AllocTraits::value_type value_type;

   inline __attribute__ ((__always_inline__)) scoped_destructor_n(Ptr p, Allocator& a, std::size_t n)
      : m_p(p), m_n(n), m_a(a)
   {}

   inline __attribute__ ((__always_inline__)) void release()
   { m_p = Ptr(); m_n = 0; }

   inline __attribute__ ((__always_inline__)) void increment_size(std::size_t inc)
   { m_n += inc; }

   inline __attribute__ ((__always_inline__)) void increment_size_backwards(std::size_t inc)
   { m_n += inc; m_p -= std::ptrdiff_t(inc); }

   inline __attribute__ ((__always_inline__)) void shrink_forward(std::size_t inc)
   { m_n -= inc; m_p += std::ptrdiff_t(inc); }

   inline __attribute__ ((__always_inline__)) void set_size(std::size_t sz)
   { m_n = sz; }

   ~scoped_destructor_n()
   {
      if(m_n){
         value_type *raw_ptr = boost::movelib::iterator_to_raw_pointer(m_p);
         do {
            --m_n;
            AllocTraits::destroy(m_a, raw_ptr);
            ++raw_ptr;
         } while(m_n);
      }
   }

   private:
   pointer m_p;
   std::size_t m_n;
   Allocator& m_a;
};



template <class Allocator, class Ptr = typename allocator_traits<Allocator>::pointer>
struct null_scoped_destructor_n
{
   typedef boost::container::allocator_traits<Allocator> AllocTraits;
   typedef Ptr pointer;

   inline __attribute__ ((__always_inline__)) null_scoped_destructor_n(Ptr, Allocator&, std::size_t)
   {}

   inline __attribute__ ((__always_inline__)) void increment_size(std::size_t)
   {}

   inline __attribute__ ((__always_inline__)) void increment_size_backwards(std::size_t)
   {}

   inline __attribute__ ((__always_inline__)) void set_size(std::size_t )
   {}

   inline __attribute__ ((__always_inline__)) void shrink_forward(std::size_t)
   {}

   inline __attribute__ ((__always_inline__)) void release()
   {}
};




template <class Allocator>
struct scoped_destructor_range
{
   typedef boost::container::allocator_traits<Allocator> AllocTraits;
   typedef typename AllocTraits::pointer pointer;
   typedef typename AllocTraits::value_type value_type;

   inline __attribute__ ((__always_inline__)) scoped_destructor_range(pointer p, pointer e, Allocator& a)
      : m_p(p), m_e(e), m_a(a)
   {}

   inline __attribute__ ((__always_inline__)) void release()
   { m_p = pointer(); m_e = pointer(); }

   inline __attribute__ ((__always_inline__)) void set_end(pointer e)
   { m_e = e; }

   inline __attribute__ ((__always_inline__)) void set_begin(pointer b)
   { m_p = b; }

   inline __attribute__ ((__always_inline__)) void set_range(pointer b, pointer e)
   { m_p = b; m_e = e; }

   ~scoped_destructor_range()
   {
      while(m_p != m_e){
         value_type *raw_ptr = boost::movelib::to_raw_pointer(m_p);
         AllocTraits::destroy(m_a, raw_ptr);
         ++m_p;
      }
   }

   private:
   pointer m_p;
   pointer m_e;
   Allocator & m_a;
};



template <class Allocator>
struct null_scoped_destructor_range
{
   typedef boost::container::allocator_traits<Allocator> AllocTraits;
   typedef typename AllocTraits::pointer pointer;

   inline __attribute__ ((__always_inline__)) null_scoped_destructor_range(pointer, pointer, Allocator&)
   {}

   inline __attribute__ ((__always_inline__)) void release()
   {}

   inline __attribute__ ((__always_inline__)) void set_end(pointer)
   {}

   inline __attribute__ ((__always_inline__)) void set_begin(pointer)
   {}

   inline __attribute__ ((__always_inline__)) void set_range(pointer, pointer)
   {}
};


template<class Allocator>
class scoped_destructor
{
   typedef boost::container::allocator_traits<Allocator> AllocTraits;
   public:
   typedef typename Allocator::value_type value_type;
   inline __attribute__ ((__always_inline__)) scoped_destructor(Allocator &a, value_type *pv)
      : pv_(pv), a_(a)
   {}

   inline __attribute__ ((__always_inline__)) ~scoped_destructor()
   {
      if(pv_){
         AllocTraits::destroy(a_, pv_);
      }
   }

   inline __attribute__ ((__always_inline__)) void release()
   { pv_ = 0; }


   inline __attribute__ ((__always_inline__)) void set(value_type *ptr) { pv_ = ptr; }

   inline __attribute__ ((__always_inline__)) value_type *get() const { return pv_; }

   private:
   value_type *pv_;
   Allocator &a_;
};

template<class Allocator>
class null_scoped_destructor
{
   typedef boost::container::allocator_traits<Allocator> AllocTraits;
   public:
   typedef typename Allocator::value_type value_type;
   inline __attribute__ ((__always_inline__)) null_scoped_destructor(Allocator &, value_type *)
   {}

   inline __attribute__ ((__always_inline__)) ~null_scoped_destructor()
   {}

   inline __attribute__ ((__always_inline__)) void release()
   {}

   inline __attribute__ ((__always_inline__)) void set(value_type *) { }

   inline __attribute__ ((__always_inline__)) value_type *get() const { return 0; }
};



template<class Allocator, class Value = typename Allocator::value_type>
class value_destructor
{
   typedef boost::container::allocator_traits<Allocator> AllocTraits;
   public:
   typedef Value value_type;
   inline __attribute__ ((__always_inline__)) value_destructor(Allocator &a, value_type &rv)
      : rv_(rv), a_(a)
   {}

   inline __attribute__ ((__always_inline__)) ~value_destructor()
   {
      AllocTraits::destroy(a_, &rv_);
   }

   private:
   value_type &rv_;
   Allocator &a_;
};

template <class Allocator>
class allocator_node_destroyer
{
   typedef boost::container::allocator_traits<Allocator> AllocTraits;
   typedef typename AllocTraits::value_type value_type;
   typedef typename AllocTraits::pointer pointer;
   typedef dtl::integral_constant<unsigned,
      boost::container::dtl::
         version<Allocator>::value> alloc_version;

   private:
   Allocator & a_;

   private:
   inline __attribute__ ((__always_inline__)) void priv_deallocate(const pointer &p, version_1)
   { AllocTraits::deallocate(a_,p, 1); }

   inline __attribute__ ((__always_inline__)) void priv_deallocate(const pointer &p, version_2)
   { a_.deallocate_one(p); }

   public:
   inline __attribute__ ((__always_inline__)) explicit allocator_node_destroyer(Allocator &a)
      : a_(a)
   {}

   inline __attribute__ ((__always_inline__)) void operator()(const pointer &p)
   {
      boost::movelib::to_raw_pointer(p)->destructor(a_);
      this->priv_deallocate(p, alloc_version());
   }
};

template<class Allocator>
class scoped_node_destructor
{
   typedef boost::container::allocator_traits<Allocator> AllocTraits;
   public:
   typedef typename Allocator::value_type value_type;
   inline __attribute__ ((__always_inline__)) scoped_node_destructor(Allocator &a, value_type *pv)
      : pv_(pv), a_(a)
   {}

   inline __attribute__ ((__always_inline__)) ~scoped_node_destructor()
   {
      if(pv_){
         pv_->destructor(a_);
      }
   }

   inline __attribute__ ((__always_inline__)) void release()
   { pv_ = 0; }


   inline __attribute__ ((__always_inline__)) void set(value_type *ptr) { pv_ = ptr; }

   inline __attribute__ ((__always_inline__)) value_type *get() const { return pv_; }

   private:
   value_type *pv_;
   Allocator &a_;
};



template <class Allocator>
class allocator_node_destroyer_and_chain_builder
{
   typedef allocator_traits<Allocator> allocator_traits_type;
   typedef typename allocator_traits_type::value_type value_type;
   typedef typename Allocator::multiallocation_chain multiallocation_chain;

   Allocator & a_;
   multiallocation_chain &c_;

   public:
   inline __attribute__ ((__always_inline__)) allocator_node_destroyer_and_chain_builder(Allocator &a, multiallocation_chain &c)
      : a_(a), c_(c)
   {}

   inline __attribute__ ((__always_inline__)) void operator()(const typename Allocator::pointer &p)
   {
      boost::movelib::to_raw_pointer(p)->destructor(a_);
      c_.push_back(p);
   }
};

template <class Allocator>
class allocator_multialloc_chain_node_deallocator
{
   typedef allocator_traits<Allocator> allocator_traits_type;
   typedef typename allocator_traits_type::value_type value_type;
   typedef typename Allocator::multiallocation_chain multiallocation_chain;
   typedef allocator_node_destroyer_and_chain_builder<Allocator> chain_builder;

   Allocator & a_;
   multiallocation_chain c_;

   public:
   inline __attribute__ ((__always_inline__)) allocator_multialloc_chain_node_deallocator(Allocator &a)
      : a_(a), c_()
   {}

   inline __attribute__ ((__always_inline__)) chain_builder get_chain_builder()
   { return chain_builder(a_, c_); }

   inline __attribute__ ((__always_inline__)) ~allocator_multialloc_chain_node_deallocator()
   {
      a_.deallocate_individual(c_);
   }
};

}
}
}

# 1 "/usr/include/boost/container/detail/config_end.hpp" 1 3 4
# 501 "/usr/include/boost/container/detail/destroyers.hpp" 2 3 4
# 30 "/usr/include/boost/container/detail/copy_move_algo.hpp" 2 3 4


# 1 "/usr/include/boost/move/adl_move_swap.hpp" 1 3 4
# 185 "/usr/include/boost/move/adl_move_swap.hpp" 3 4
namespace boost_move_adl_swap{

template<class T>
inline __attribute__ ((__always_inline__)) void swap_proxy(T& x, T& y)
{
   using std::swap;
   swap(x, y);
}

}



namespace boost_move_adl_swap{

template<class T, std::size_t N>
void swap_proxy(T (& x)[N], T (& y)[N])
{
   for (std::size_t i = 0; i < N; ++i){
      ::boost_move_adl_swap::swap_proxy(x[i], y[i]);
   }
}

}



namespace boost{
# 224 "/usr/include/boost/move/adl_move_swap.hpp" 3 4
template<class T>
inline __attribute__ ((__always_inline__)) void adl_move_swap(T& x, T& y)
{
   ::boost_move_adl_swap::swap_proxy(x, y);
}
# 244 "/usr/include/boost/move/adl_move_swap.hpp" 3 4
template<class ForwardIt1, class ForwardIt2>
ForwardIt2 adl_move_swap_ranges(ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2)
{
    while (first1 != last1) {
      ::boost::adl_move_swap(*first1, *first2);
      ++first1;
      ++first2;
    }
   return first2;
}

template<class BidirIt1, class BidirIt2>
BidirIt2 adl_move_swap_ranges_backward(BidirIt1 first1, BidirIt1 last1, BidirIt2 last2)
{
   while (first1 != last1) {
      ::boost::adl_move_swap(*(--last1), *(--last2));
   }
   return last2;
}

template<class ForwardIt1, class ForwardIt2>
void adl_move_iter_swap(ForwardIt1 a, ForwardIt2 b)
{
   boost::adl_move_swap(*a, *b);
}

}
# 33 "/usr/include/boost/container/detail/copy_move_algo.hpp" 2 3 4
# 1 "/usr/include/boost/move/iterator.hpp" 1 3 4
# 25 "/usr/include/boost/move/iterator.hpp" 3 4
# 1 "/usr/include/boost/move/detail/config_begin.hpp" 1 3 4
# 26 "/usr/include/boost/move/iterator.hpp" 2 3 4




namespace boost {
# 43 "/usr/include/boost/move/iterator.hpp" 3 4
template <class It>
class move_iterator
{
   public:
   typedef It iterator_type;
   typedef typename boost::movelib::iterator_traits<iterator_type>::value_type value_type;

   typedef value_type && reference;






   typedef It pointer;
   typedef typename boost::movelib::iterator_traits<iterator_type>::difference_type difference_type;
   typedef typename boost::movelib::iterator_traits<iterator_type>::iterator_category iterator_category;

   inline __attribute__ ((__always_inline__)) move_iterator()
      : m_it()
   {}

   inline __attribute__ ((__always_inline__)) explicit move_iterator(const It &i)
      : m_it(i)
   {}

   template <class U>
   inline __attribute__ ((__always_inline__)) move_iterator(const move_iterator<U>& u)
      : m_it(u.m_it)
   {}

   inline __attribute__ ((__always_inline__)) reference operator*() const
   {



      return ::boost::move(*m_it);

   }

   inline __attribute__ ((__always_inline__)) pointer operator->() const
   { return m_it; }

   inline __attribute__ ((__always_inline__)) move_iterator& operator++()
   { ++m_it; return *this; }

   inline __attribute__ ((__always_inline__)) move_iterator<iterator_type> operator++(int)
   { move_iterator<iterator_type> tmp(*this); ++(*this); return tmp; }

   inline __attribute__ ((__always_inline__)) move_iterator& operator--()
   { --m_it; return *this; }

   inline __attribute__ ((__always_inline__)) move_iterator<iterator_type> operator--(int)
   { move_iterator<iterator_type> tmp(*this); --(*this); return tmp; }

   move_iterator<iterator_type> operator+ (difference_type n) const
   { return move_iterator<iterator_type>(m_it + n); }

   inline __attribute__ ((__always_inline__)) move_iterator& operator+=(difference_type n)
   { m_it += n; return *this; }

   inline __attribute__ ((__always_inline__)) move_iterator<iterator_type> operator- (difference_type n) const
   { return move_iterator<iterator_type>(m_it - n); }

   inline __attribute__ ((__always_inline__)) move_iterator& operator-=(difference_type n)
   { m_it -= n; return *this; }

   inline __attribute__ ((__always_inline__)) reference operator[](difference_type n) const
   {



      return ::boost::move(m_it[n]);

   }

   inline __attribute__ ((__always_inline__)) friend bool operator==(const move_iterator& x, const move_iterator& y)
   { return x.m_it == y.m_it; }

   inline __attribute__ ((__always_inline__)) friend bool operator!=(const move_iterator& x, const move_iterator& y)
   { return x.m_it != y.m_it; }

   inline __attribute__ ((__always_inline__)) friend bool operator< (const move_iterator& x, const move_iterator& y)
   { return x.m_it < y.m_it; }

   inline __attribute__ ((__always_inline__)) friend bool operator<=(const move_iterator& x, const move_iterator& y)
   { return x.m_it <= y.m_it; }

   inline __attribute__ ((__always_inline__)) friend bool operator> (const move_iterator& x, const move_iterator& y)
   { return x.m_it > y.m_it; }

   inline __attribute__ ((__always_inline__)) friend bool operator>=(const move_iterator& x, const move_iterator& y)
   { return x.m_it >= y.m_it; }

   inline __attribute__ ((__always_inline__)) friend difference_type operator-(const move_iterator& x, const move_iterator& y)
   { return x.m_it - y.m_it; }

   inline __attribute__ ((__always_inline__)) friend move_iterator operator+(difference_type n, const move_iterator& x)
   { return move_iterator(x.m_it + n); }

   private:
   It m_it;
};


namespace move_detail {

template <class I>
struct is_move_iterator
{
   static const bool value = false;
};

template <class I>
struct is_move_iterator< ::boost::move_iterator<I> >
{
   static const bool value = true;
};

}
# 172 "/usr/include/boost/move/iterator.hpp" 3 4
template<class It>
inline __attribute__ ((__always_inline__)) move_iterator<It> make_move_iterator(const It &it)
{ return move_iterator<It>(it); }
# 185 "/usr/include/boost/move/iterator.hpp" 3 4
template <typename C>
class back_move_insert_iterator
{
   C* container_m;

   public:
   typedef C container_type;
   typedef typename C::value_type value_type;
   typedef typename C::reference reference;
   typedef typename C::pointer pointer;
   typedef typename C::difference_type difference_type;
   typedef std::output_iterator_tag iterator_category;

   explicit back_move_insert_iterator(C& x) : container_m(&x) { }

   back_move_insert_iterator& operator=(reference x)
   { container_m->push_back(boost::move(x)); return *this; }

   back_move_insert_iterator& operator=(value_type && x)
   { reference rx = x; return this->operator=(rx); }

   back_move_insert_iterator& operator*() { return *this; }
   back_move_insert_iterator& operator++() { return *this; }
   back_move_insert_iterator& operator++(int) { return *this; }
};



template <typename C>
inline back_move_insert_iterator<C> back_move_inserter(C& x)
{
   return back_move_insert_iterator<C>(x);
}
# 227 "/usr/include/boost/move/iterator.hpp" 3 4
template <typename C>
class front_move_insert_iterator
{
   C* container_m;

public:
   typedef C container_type;
   typedef typename C::value_type value_type;
   typedef typename C::reference reference;
   typedef typename C::pointer pointer;
   typedef typename C::difference_type difference_type;
   typedef std::output_iterator_tag iterator_category;

   explicit front_move_insert_iterator(C& x) : container_m(&x) { }

   front_move_insert_iterator& operator=(reference x)
   { container_m->push_front(boost::move(x)); return *this; }

   front_move_insert_iterator& operator=(value_type && x)
   { reference rx = x; return this->operator=(rx); }

   front_move_insert_iterator& operator*() { return *this; }
   front_move_insert_iterator& operator++() { return *this; }
   front_move_insert_iterator& operator++(int) { return *this; }
};



template <typename C>
inline front_move_insert_iterator<C> front_move_inserter(C& x)
{
   return front_move_insert_iterator<C>(x);
}






template <typename C>
class move_insert_iterator
{
   C* container_m;
   typename C::iterator pos_;

   public:
   typedef C container_type;
   typedef typename C::value_type value_type;
   typedef typename C::reference reference;
   typedef typename C::pointer pointer;
   typedef typename C::difference_type difference_type;
   typedef std::output_iterator_tag iterator_category;

   explicit move_insert_iterator(C& x, typename C::iterator pos)
      : container_m(&x), pos_(pos)
   {}

   move_insert_iterator& operator=(reference x)
   {
      pos_ = container_m->insert(pos_, ::boost::move(x));
      ++pos_;
      return *this;
   }

   move_insert_iterator& operator=(value_type && x)
   { reference rx = x; return this->operator=(rx); }

   move_insert_iterator& operator*() { return *this; }
   move_insert_iterator& operator++() { return *this; }
   move_insert_iterator& operator++(int) { return *this; }
};



template <typename C>
inline move_insert_iterator<C> move_inserter(C& x, typename C::iterator it)
{
   return move_insert_iterator<C>(x, it);
}

}

# 1 "/usr/include/boost/move/detail/config_end.hpp" 1 3 4
# 310 "/usr/include/boost/move/iterator.hpp" 2 3 4
# 34 "/usr/include/boost/container/detail/copy_move_algo.hpp" 2 3 4

# 1 "/usr/include/boost/move/traits.hpp" 1 3 4
# 25 "/usr/include/boost/move/traits.hpp" 3 4
# 1 "/usr/include/boost/move/detail/config_begin.hpp" 1 3 4
# 26 "/usr/include/boost/move/traits.hpp" 2 3 4







namespace boost {
# 44 "/usr/include/boost/move/traits.hpp" 3 4
template <class T>
struct has_trivial_destructor_after_move
   : ::boost::move_detail::is_trivially_destructible<T>
{};





template <class T>
struct has_nothrow_move
{
   static const bool value = boost::move_detail::is_nothrow_move_constructible<T>::value &&
                             boost::move_detail::is_nothrow_move_assignable<T>::value;
};

namespace move_detail {

template <class T>
struct is_nothrow_move_constructible_or_uncopyable
{


   static const bool value = is_nothrow_move_constructible<T>::value ||
                             has_nothrow_move<T>::value ||
                            !is_copy_constructible<T>::value;
};

}
}

# 1 "/usr/include/boost/move/detail/config_end.hpp" 1 3 4
# 76 "/usr/include/boost/move/traits.hpp" 2 3 4
# 36 "/usr/include/boost/container/detail/copy_move_algo.hpp" 2 3 4

# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 58 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 59 "/usr/include/boost/assert.hpp" 2 3 4
# 38 "/usr/include/boost/container/detail/copy_move_algo.hpp" 2 3 4

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 1 3 4
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 3


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 43 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 2 3
# 40 "/usr/include/boost/container/detail/copy_move_algo.hpp" 2 3 4
# 55 "/usr/include/boost/container/detail/copy_move_algo.hpp" 3 4
namespace boost {
namespace container {
namespace dtl {

template<class I>
struct are_elements_contiguous
{
   static const bool value = false;
};





template<class T>
struct are_elements_contiguous<T*>
{
   static const bool value = true;
};





template<class It>
struct are_elements_contiguous< ::boost::move_iterator<It> >
   : are_elements_contiguous<It>
{};

}





template <class Pointer, bool IsConst>
class vec_iterator;

}

namespace interprocess {

template <class PointedType, class DifferenceType, class OffsetType, std::size_t OffsetAlignment>
class offset_ptr;

}

namespace container {

namespace dtl {





template <class Pointer, bool IsConst>
struct are_elements_contiguous<boost::container::vec_iterator<Pointer, IsConst> >
{
   static const bool value = true;
};






template <class PointedType, class DifferenceType, class OffsetType, std::size_t OffsetAlignment>
struct are_elements_contiguous< ::boost::interprocess::offset_ptr<PointedType, DifferenceType, OffsetType, OffsetAlignment> >
{
   static const bool value = true;
};

template <typename I, typename O>
struct are_contiguous_and_same
   : boost::move_detail::and_
      < are_elements_contiguous<I>
      , are_elements_contiguous<O>
      , is_same< typename remove_const< typename ::boost::container::iter_value<I>::type >::type
               , typename ::boost::container::iterator_traits<O>::value_type
               >
      >
{};

template <typename I, typename O>
struct is_memtransfer_copy_assignable
   : boost::move_detail::and_
      < are_contiguous_and_same<I, O>
      , dtl::is_trivially_copy_assignable< typename ::boost::container::iter_value<I>::type >
      >
{};

template <typename I, typename O>
struct is_memtransfer_copy_constructible
   : boost::move_detail::and_
      < are_contiguous_and_same<I, O>
      , dtl::is_trivially_copy_constructible< typename ::boost::container::iter_value<I>::type >
      >
{};

template <typename I, typename O, typename R>
struct enable_if_memtransfer_copy_constructible
   : enable_if<dtl::is_memtransfer_copy_constructible<I, O>, R>
{};

template <typename I, typename O, typename R>
struct disable_if_memtransfer_copy_constructible
   : disable_if<dtl::is_memtransfer_copy_constructible<I, O>, R>
{};

template <typename I, typename O, typename R>
struct enable_if_memtransfer_copy_assignable
   : enable_if<dtl::is_memtransfer_copy_assignable<I, O>, R>
{};

template <typename I, typename O, typename R>
struct disable_if_memtransfer_copy_assignable
   : disable_if<dtl::is_memtransfer_copy_assignable<I, O>, R>
{};

template <class T>
struct has_single_value
{
private:
   struct two { char array_[2]; };
   template<bool Arg> struct wrapper;
   template <class U> static two test(int, ...);
   template <class U> static char test(int, const wrapper<U::single_value>*);
public:
   static const bool value = sizeof(test<T>(0, 0)) == 1;
   void dummy() {}
};

template<class InsertionProxy, bool = has_single_value<InsertionProxy>::value>
struct is_single_value_proxy_impl
{
   static const bool value = InsertionProxy::single_value;
};

template<class InsertionProxy>
struct is_single_value_proxy_impl<InsertionProxy, false>
{
   static const bool value = false;
};

template<class InsertionProxy>
struct is_single_value_proxy
   : is_single_value_proxy_impl<InsertionProxy>
{};

template <typename P, typename R = void>
struct enable_if_single_value_proxy
   : enable_if<is_single_value_proxy<P>, R>
{};

template <typename P, typename R = void>
struct disable_if_single_value_proxy
   : disable_if<is_single_value_proxy<P>, R>
{};

template
   <typename I,
    typename F>
inline __attribute__ ((__always_inline__)) F memmove(I f, I l, F r) noexcept
{
   typedef typename boost::container::iter_value<I>::type value_type;
   typedef typename boost::container::iterator_traits<F>::difference_type r_difference_type;
   value_type *const dest_raw = boost::movelib::iterator_to_raw_pointer(r);
   const value_type *const beg_raw = boost::movelib::iterator_to_raw_pointer(f);
   const value_type *const end_raw = boost::movelib::iterator_to_raw_pointer(l);
   if(__builtin_expect(beg_raw != end_raw && dest_raw && beg_raw, 1)){
      const std::size_t n = std::size_t(end_raw - beg_raw) ;
      std::memmove(dest_raw, beg_raw, sizeof(value_type)*n);
      r += static_cast<r_difference_type>(n);
   }
   return r;
}

template
   <typename I,
    typename F>
inline __attribute__ ((__always_inline__)) F memmove_n(I f, std::size_t n, F r) noexcept
{
   typedef typename boost::container::iter_value<I>::type value_type;
   typedef typename boost::container::iterator_traits<F>::difference_type r_difference_type;
   if(__builtin_expect(n != 0, 1)){
      void *dst = boost::movelib::iterator_to_raw_pointer(r);
      const void *src = boost::movelib::iterator_to_raw_pointer(f);
      if (dst && src)
         std::memmove(dst, src, sizeof(value_type)*n);
      r += static_cast<r_difference_type>(n);
   }

   return r;
}

template
   <typename I,
    typename F>
inline __attribute__ ((__always_inline__)) I memmove_n_source(I f, std::size_t n, F r) noexcept
{
   if(__builtin_expect(n != 0, 1)){
      typedef typename boost::container::iter_value<I>::type value_type;
      typedef typename boost::container::iterator_traits<I>::difference_type i_difference_type;
      void *dst = boost::movelib::iterator_to_raw_pointer(r);
      const void *src = boost::movelib::iterator_to_raw_pointer(f);
      if (dst && src)
         std::memmove(dst, src, sizeof(value_type)*n);
      f += static_cast<i_difference_type>(n);
   }
   return f;
}

template
   <typename I,
    typename F>
inline __attribute__ ((__always_inline__)) I memmove_n_source_dest(I f, std::size_t n, F &r) noexcept
{
   typedef typename boost::container::iter_value<I>::type value_type;
   typedef typename boost::container::iterator_traits<F>::difference_type i_difference_type;
   typedef typename boost::container::iterator_traits<F>::difference_type f_difference_type;

   if(__builtin_expect(n != 0, 1)){
      void *dst = boost::movelib::iterator_to_raw_pointer(r);
      const void *src = boost::movelib::iterator_to_raw_pointer(f);
      if (dst && src)
         std::memmove(dst, src, sizeof(value_type)*n);
      f += i_difference_type(n);
      r += f_difference_type(n);
   }
   return f;
}

template <typename O>
struct is_memzero_initializable
{
   typedef typename ::boost::container::iterator_traits<O>::value_type value_type;
   static const bool value = are_elements_contiguous<O>::value &&
      ( dtl::is_integral<value_type>::value || dtl::is_enum<value_type>::value

      || dtl::is_pointer<value_type>::value


      || dtl::is_floating_point<value_type>::value

      );
};

template <typename O, typename R>
struct enable_if_memzero_initializable
   : enable_if_c<dtl::is_memzero_initializable<O>::value, R>
{};

template <typename O, typename R>
struct disable_if_memzero_initializable
   : enable_if_c<!dtl::is_memzero_initializable<O>::value, R>
{};

template <typename I, typename R>
struct enable_if_trivially_destructible
   : enable_if_c < dtl::is_trivially_destructible
                  <typename boost::container::iter_value<I>::type>::value
               , R>
{};

template <typename I, typename R>
struct disable_if_trivially_destructible
   : enable_if_c <!dtl::is_trivially_destructible
                  <typename boost::container::iter_value<I>::type>::value
               , R>
{};

}
# 342 "/usr/include/boost/container/detail/copy_move_algo.hpp" 3 4
template
   <typename Allocator,
    typename I,
    typename F>
inline typename dtl::disable_if_memtransfer_copy_constructible<I, F, F>::type
   uninitialized_move_alloc(Allocator &a, I f, I l, F r)
{
   F back = r;
   { try{
      while (f != l) {
         allocator_traits<Allocator>::construct(a, boost::movelib::iterator_to_raw_pointer(r), boost::move(*f));
         ++f; ++r;
      }
   }
   catch(...){
      for (; back != r; ++back){
         allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
      }
      throw;;
   }
   }
   return r;
}

template
   <typename Allocator,
    typename I,
    typename F>
inline __attribute__ ((__always_inline__)) typename dtl::enable_if_memtransfer_copy_constructible<I, F, F>::type
   uninitialized_move_alloc(Allocator &, I f, I l, F r) noexcept
{ return dtl::memmove(f, l, r); }
# 387 "/usr/include/boost/container/detail/copy_move_algo.hpp" 3 4
template
   <typename Allocator,
    typename I,
    typename F>
inline typename dtl::disable_if_memtransfer_copy_constructible<I, F, F>::type
   uninitialized_move_alloc_n(Allocator &a, I f, std::size_t n, F r)
{
   F back = r;
   { try{
      while (n) {
         --n;
         allocator_traits<Allocator>::construct(a, boost::movelib::iterator_to_raw_pointer(r), boost::move(*f));
         ++f; ++r;
      }
   }
   catch(...){
      for (; back != r; ++back){
         allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
      }
      throw;;
   }
   }
   return r;
}

template
   <typename Allocator,
    typename I,
    typename F>
inline __attribute__ ((__always_inline__)) typename dtl::enable_if_memtransfer_copy_constructible<I, F, F>::type
   uninitialized_move_alloc_n(Allocator &, I f, std::size_t n, F r) noexcept
{ return dtl::memmove_n(f, n, r); }
# 433 "/usr/include/boost/container/detail/copy_move_algo.hpp" 3 4
template
   <typename Allocator,
    typename I,
    typename F>
inline typename dtl::disable_if_memtransfer_copy_constructible<I, F, I>::type
   uninitialized_move_alloc_n_source(Allocator &a, I f, std::size_t n, F r)
{
   F back = r;
   { try{
      while (n) {
         --n;
         allocator_traits<Allocator>::construct(a, boost::movelib::iterator_to_raw_pointer(r), boost::move(*f));
         ++f; ++r;
      }
   }
   catch(...){
      for (; back != r; ++back){
         allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
      }
      throw;;
   }
   }
   return f;
}

template
   <typename Allocator,
    typename I,
    typename F>
inline __attribute__ ((__always_inline__)) typename dtl::enable_if_memtransfer_copy_constructible<I, F, I>::type
   uninitialized_move_alloc_n_source(Allocator &, I f, std::size_t n, F r) noexcept
{ return dtl::memmove_n_source(f, n, r); }
# 479 "/usr/include/boost/container/detail/copy_move_algo.hpp" 3 4
template
   <typename Allocator,
    typename I,
    typename F>
inline typename dtl::disable_if_memtransfer_copy_constructible<I, F, F>::type
   uninitialized_copy_alloc(Allocator &a, I f, I l, F r)
{
   F back = r;
   { try{
      while (f != l) {
         allocator_traits<Allocator>::construct(a, boost::movelib::iterator_to_raw_pointer(r), *f);
         ++f; ++r;
      }
   }
   catch(...){
      for (; back != r; ++back){
         allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
      }
      throw;;
   }
   }
   return r;
}

template
   <typename Allocator,
    typename I,
    typename F>
inline __attribute__ ((__always_inline__)) typename dtl::enable_if_memtransfer_copy_constructible<I, F, F>::type
   uninitialized_copy_alloc(Allocator &, I f, I l, F r) noexcept
{ return dtl::memmove(f, l, r); }
# 524 "/usr/include/boost/container/detail/copy_move_algo.hpp" 3 4
template
   <typename Allocator,
    typename I,
    typename F>
inline typename dtl::disable_if_memtransfer_copy_constructible<I, F, F>::type
   uninitialized_copy_alloc_n(Allocator &a, I f, std::size_t n, F r)
{
   F back = r;
   { try{
      while (n) {
         --n;
         allocator_traits<Allocator>::construct(a, boost::movelib::iterator_to_raw_pointer(r), *f);
         ++f; ++r;
      }
   }
   catch(...){
      for (; back != r; ++back){
         allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
      }
      throw;;
   }
   }
   return r;
}

template
   <typename Allocator,
    typename I,
    typename F>
inline __attribute__ ((__always_inline__)) typename dtl::enable_if_memtransfer_copy_constructible<I, F, F>::type
   uninitialized_copy_alloc_n(Allocator &, I f, std::size_t n, F r) noexcept
{ return dtl::memmove_n(f, n, r); }
# 570 "/usr/include/boost/container/detail/copy_move_algo.hpp" 3 4
template
   <typename Allocator,
    typename I,
    typename F>
inline typename dtl::disable_if_memtransfer_copy_constructible<I, F, I>::type
   uninitialized_copy_alloc_n_source(Allocator &a, I f, std::size_t n, F r)
{
   F back = r;
   { try{
      while (n) {
         boost::container::construct_in_place(a, boost::movelib::iterator_to_raw_pointer(r), f);
         ++f; ++r; --n;
      }
   }
   catch(...){
      for (; back != r; ++back){
         allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
      }
      throw;;
   }
   }
   return f;
}

template
   <typename Allocator,
    typename I,
    typename F>
inline __attribute__ ((__always_inline__)) typename dtl::enable_if_memtransfer_copy_constructible<I, F, I>::type
   uninitialized_copy_alloc_n_source(Allocator &, I f, std::size_t n, F r) noexcept
{ return dtl::memmove_n_source(f, n, r); }
# 615 "/usr/include/boost/container/detail/copy_move_algo.hpp" 3 4
template
   <typename Allocator,
    typename F>
inline typename dtl::disable_if_memzero_initializable<F, F>::type
   uninitialized_value_init_alloc_n(Allocator &a, std::size_t n, F r)
{
   F back = r;
   { try{
      while (n) {
         --n;
         allocator_traits<Allocator>::construct(a, boost::movelib::iterator_to_raw_pointer(r));
         ++r;
      }
   }
   catch(...){
      for (; back != r; ++back){
         allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
      }
      throw;;
   }
   }
   return r;
}

template
   <typename Allocator,
    typename F>
inline __attribute__ ((__always_inline__)) typename dtl::enable_if_memzero_initializable<F, F>::type
   uninitialized_value_init_alloc_n(Allocator &, std::size_t n, F r)
{
   typedef typename boost::container::iterator_traits<F>::value_type value_type;
   typedef typename boost::container::iterator_traits<F>::difference_type r_difference_type;

   if (__builtin_expect(n != 0, 1)){
      std::memset((void*)boost::movelib::iterator_to_raw_pointer(r), 0, sizeof(value_type)*n);
      r += static_cast<r_difference_type>(n);
   }
   return r;
}
# 668 "/usr/include/boost/container/detail/copy_move_algo.hpp" 3 4
template
   <typename Allocator,
    typename F>
inline F uninitialized_default_init_alloc_n(Allocator &a, std::size_t n, F r)
{
   F back = r;
   { try{
      while (n) {
         --n;
         allocator_traits<Allocator>::construct(a, boost::movelib::iterator_to_raw_pointer(r), default_init);
         ++r;
      }
   }
   catch(...){
      for (; back != r; ++back){
         allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
      }
      throw;;
   }
   }
   return r;
}
# 704 "/usr/include/boost/container/detail/copy_move_algo.hpp" 3 4
template
   <typename Allocator,
    typename F,
    typename T>
inline void uninitialized_fill_alloc(Allocator &a, F f, F l, const T &t)
{
   F back = f;
   { try{
      while (f != l) {
         allocator_traits<Allocator>::construct(a, boost::movelib::iterator_to_raw_pointer(f), t);
         ++f;
      }
   }
   catch(...){
      for (; back != l; ++back){
         allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
      }
      throw;;
   }
   }
}
# 740 "/usr/include/boost/container/detail/copy_move_algo.hpp" 3 4
template
   <typename Allocator,
    typename T,
    typename F>
inline F uninitialized_fill_alloc_n(Allocator &a, const T &v, std::size_t n, F r)
{
   F back = r;
   { try{
      while (n) {
         --n;
         allocator_traits<Allocator>::construct(a, boost::movelib::iterator_to_raw_pointer(r), v);
         ++r;
      }
   }
   catch(...){
      for (; back != r; ++back){
         allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
      }
      throw;;
   }
   }
   return r;
}







template
<typename I,
typename F>
inline typename dtl::disable_if_memtransfer_copy_assignable<I, F, F>::type
   copy(I f, I l, F r)
{
   while (f != l) {
      *r = *f;
      ++f; ++r;
   }
   return r;
}

template
<typename I,
typename F>
inline typename dtl::enable_if_memtransfer_copy_assignable<I, F, F>::type
   copy(I f, I l, F r) noexcept
{ return dtl::memmove(f, l, r); }







template
<typename I,
typename U,
typename F>
inline typename dtl::disable_if_memtransfer_copy_assignable<I, F, F>::type
   copy_n(I f, U n, F r)
{
   while (n) {
      --n;
      *r = *f;
      ++f; ++r;
   }
   return r;
}

template
<typename I,
typename U,
typename F>
inline __attribute__ ((__always_inline__)) typename dtl::enable_if_memtransfer_copy_assignable<I, F, F>::type
   copy_n(I f, U n, F r) noexcept
{ return dtl::memmove_n(f, n, r); }







template
<typename I,
typename U,
typename F>
inline typename dtl::disable_if_memtransfer_copy_assignable<I, F, I>::type
   copy_n_source(I f, U n, F r)
{
   while (n) {
      --n;
      boost::container::assign_in_place(r, f);
      ++f; ++r;
   }
   return f;
}

template
<typename I,
typename F>
inline __attribute__ ((__always_inline__)) typename dtl::enable_if_memtransfer_copy_assignable<I, F, I>::type
   copy_n_source(I f, std::size_t n, F r) noexcept
{ return dtl::memmove_n_source(f, n, r); }







template
<typename I,
typename F>
inline typename dtl::disable_if_memtransfer_copy_assignable<I, F, I>::type
   copy_n_source_dest(I f, std::size_t n, F &r)
{
   while (n) {
      --n;
      *r = *f;
      ++f; ++r;
   }
   return f;
}

template
<typename I,
typename F>
inline __attribute__ ((__always_inline__)) typename dtl::enable_if_memtransfer_copy_assignable<I, F, I>::type
   copy_n_source_dest(I f, std::size_t n, F &r) noexcept
{ return dtl::memmove_n_source_dest(f, n, r); }







template
<typename I,
typename F>
inline typename dtl::disable_if_memtransfer_copy_assignable<I, F, F>::type
   move(I f, I l, F r)
{
   while (f != l) {
      *r = ::boost::move(*f);
      ++f; ++r;
   }
   return r;
}

template
<typename I,
typename F>
inline typename dtl::enable_if_memtransfer_copy_assignable<I, F, F>::type
   move(I f, I l, F r) noexcept
{ return dtl::memmove(f, l, r); }







template
<typename I,
typename U,
typename F>
inline typename dtl::disable_if_memtransfer_copy_assignable<I, F, F>::type
   move_n(I f, U n, F r)
{
   while (n) {
      --n;
      *r = ::boost::move(*f);
      ++f; ++r;
   }
   return r;
}

template
<typename I,
typename U,
typename F>
inline __attribute__ ((__always_inline__)) typename dtl::enable_if_memtransfer_copy_assignable<I, F, F>::type
   move_n(I f, U n, F r) noexcept
{ return dtl::memmove_n(f, n, r); }
# 936 "/usr/include/boost/container/detail/copy_move_algo.hpp" 3 4
template
<typename I,
typename F>
inline typename dtl::disable_if_memtransfer_copy_assignable<I, F, F>::type
   move_backward(I f, I l, F r)
{
   while (f != l) {
      --l; --r;
      *r = ::boost::move(*l);
   }
   return r;
}

template
<typename I,
typename F>
inline __attribute__ ((__always_inline__)) typename dtl::enable_if_memtransfer_copy_assignable<I, F, F>::type
   move_backward(I f, I l, F r) noexcept
{
   typedef typename boost::container::iter_value<I>::type value_type;
   const std::size_t n = boost::container::iterator_udistance(f, l);
   if (__builtin_expect(n != 0, 1)){
      r -= n;
      std::memmove((boost::movelib::iterator_to_raw_pointer)(r), (boost::movelib::iterator_to_raw_pointer)(f), sizeof(value_type)*n);
   }
   return r;
}







template
<typename I
,typename U
,typename F>
inline typename dtl::disable_if_memtransfer_copy_assignable<I, F, I>::type
   move_n_source_dest(I f, U n, F &r)
{
   while (n) {
      --n;
      *r = ::boost::move(*f);
      ++f; ++r;
   }
   return f;
}

template
<typename I
,typename F>
inline __attribute__ ((__always_inline__)) typename dtl::enable_if_memtransfer_copy_assignable<I, F, I>::type
   move_n_source_dest(I f, std::size_t n, F &r) noexcept
{ return dtl::memmove_n_source_dest(f, n, r); }







template
<typename I
,typename U
,typename F>
inline typename dtl::disable_if_memtransfer_copy_assignable<I, F, I>::type
   move_n_source(I f, U n, F r)
{
   while (n) {
      --n;
      *r = ::boost::move(*f);
      ++f; ++r;
   }
   return f;
}

template
<typename I
,typename F>
inline __attribute__ ((__always_inline__)) typename dtl::enable_if_memtransfer_copy_assignable<I, F, I>::type
   move_n_source(I f, std::size_t n, F r) noexcept
{ return dtl::memmove_n_source(f, n, r); }

template<typename F>
inline __attribute__ ((__always_inline__)) F move_forward_overlapping(F f, F l, F r)
{
   return (f != r) ? (move)(f, l, r) : l;
}

template<typename B>
inline __attribute__ ((__always_inline__)) B move_backward_overlapping(B f, B l, B rl)
{
   return (l != rl) ? (move_backward)(f, l, rl) : f;
}
# 1039 "/usr/include/boost/container/detail/copy_move_algo.hpp" 3 4
template
   <typename Allocator
   ,typename I
   ,typename U>
inline typename dtl::disable_if_trivially_destructible<I, void>::type
   destroy_alloc_n(Allocator &a, I f, U n)
{
   while(n){
      --n;
      allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(f));
      ++f;
   }
}

template
   <typename Allocator
   ,typename I
   ,typename U>
inline __attribute__ ((__always_inline__)) typename dtl::enable_if_trivially_destructible<I, void>::type
   destroy_alloc_n(Allocator &, I, U)
{}







template
   <typename Allocator
   ,typename I>
inline typename dtl::disable_if_trivially_destructible<I, void>::type
   destroy_alloc(Allocator &a, I f, I l)
{
   while(f != l){
      allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(f));
      ++f;
   }
}

template
   <typename Allocator
   ,typename I >
inline __attribute__ ((__always_inline__)) typename dtl::enable_if_trivially_destructible<I, void>::type
   destroy_alloc(Allocator &, I, I)
{}







template
   <std::size_t MaxTmpBytes
   ,typename Allocator
   ,typename F
   ,typename G
   >
inline typename dtl::disable_if_memtransfer_copy_assignable<F, G, void>::type
   deep_swap_alloc_n( Allocator &a, F short_range_f, std::size_t n_i, G large_range_f, std::size_t n_j)
{
   std::size_t n = 0;
   for (; n != n_i ; ++short_range_f, ++large_range_f, ++n){
      boost::adl_move_swap(*short_range_f, *large_range_f);
   }
   boost::container::uninitialized_move_alloc_n(a, large_range_f, std::size_t(n_j - n_i), short_range_f);
   boost::container::destroy_alloc_n(a, large_range_f, std::size_t(n_j - n_i));
}

static const std::size_t DeepSwapAllocNMaxStorage = std::size_t(1) << std::size_t(11);

template
   <std::size_t MaxTmpBytes
   ,typename Allocator
   ,typename F
   ,typename G
   >
inline typename dtl::enable_if_c
   < dtl::is_memtransfer_copy_assignable<F, G>::value && (MaxTmpBytes <= DeepSwapAllocNMaxStorage) && false
   , void>::type
   deep_swap_alloc_n( Allocator &a, F short_range_f, std::size_t n_i, G large_range_f, std::size_t n_j)
{
   typedef typename allocator_traits<Allocator>::value_type value_type;
   typedef typename dtl::aligned_storage
      <MaxTmpBytes, dtl::alignment_of<value_type>::value>::type storage_type;
   storage_type storage;

   const std::size_t n_i_bytes = sizeof(value_type)*n_i;
   void *const large_ptr = static_cast<void*>(boost::movelib::iterator_to_raw_pointer(large_range_f));
   void *const short_ptr = static_cast<void*>(boost::movelib::iterator_to_raw_pointer(short_range_f));
   void *const stora_ptr = static_cast<void*>(boost::movelib::iterator_to_raw_pointer(storage.data));
   std::memcpy(stora_ptr, large_ptr, n_i_bytes);
   std::memcpy(large_ptr, short_ptr, n_i_bytes);
   std::memcpy(short_ptr, stora_ptr, n_i_bytes);
   boost::container::iterator_uadvance(large_range_f, n_i);
   boost::container::iterator_uadvance(short_range_f, n_i);
   boost::container::uninitialized_move_alloc_n(a, large_range_f, std::size_t(n_j - n_i), short_range_f);
   boost::container::destroy_alloc_n(a, large_range_f, std::size_t(n_j - n_i));
}

template
   <std::size_t MaxTmpBytes
   ,typename Allocator
   ,typename F
   ,typename G
   >
inline typename dtl::enable_if_c
   < dtl::is_memtransfer_copy_assignable<F, G>::value && true
   , void>::type
   deep_swap_alloc_n( Allocator &a, F short_range_f, std::size_t n_i, G large_range_f, std::size_t n_j)
{
   typedef typename allocator_traits<Allocator>::value_type value_type;
   typedef typename dtl::aligned_storage
      <DeepSwapAllocNMaxStorage, dtl::alignment_of<value_type>::value>::type storage_type;
   storage_type storage;
   const std::size_t sizeof_storage = sizeof(storage);

   std::size_t n_i_bytes = sizeof(value_type)*n_i;
   char *large_ptr = static_cast<char*>(static_cast<void*>(boost::movelib::iterator_to_raw_pointer(large_range_f)));
   char *short_ptr = static_cast<char*>(static_cast<void*>(boost::movelib::iterator_to_raw_pointer(short_range_f)));
   char *stora_ptr = static_cast<char*>(static_cast<void*>(storage.data));

   std::size_t szt_times = n_i_bytes/sizeof_storage;
   const std::size_t szt_rem = n_i_bytes%sizeof_storage;


   const std::size_t Unroll = 4;
   std::size_t n = (szt_times + (Unroll-1))/Unroll;
   const std::size_t branch_number = (szt_times == 0)*Unroll + (szt_times % Unroll);
   switch(branch_number){
      case 4:
         break;
      case 0: do{
         std::memcpy(stora_ptr, large_ptr, sizeof_storage);
         std::memcpy(large_ptr, short_ptr, sizeof_storage);
         std::memcpy(short_ptr, stora_ptr, sizeof_storage);
         large_ptr += sizeof_storage;
         short_ptr += sizeof_storage;
         [[clang::fallthrough]];
      case 3:
         std::memcpy(stora_ptr, large_ptr, sizeof_storage);
         std::memcpy(large_ptr, short_ptr, sizeof_storage);
         std::memcpy(short_ptr, stora_ptr, sizeof_storage);
         large_ptr += sizeof_storage;
         short_ptr += sizeof_storage;
         [[clang::fallthrough]];
      case 2:
         std::memcpy(stora_ptr, large_ptr, sizeof_storage);
         std::memcpy(large_ptr, short_ptr, sizeof_storage);
         std::memcpy(short_ptr, stora_ptr, sizeof_storage);
         large_ptr += sizeof_storage;
         short_ptr += sizeof_storage;
         [[clang::fallthrough]];
      case 1:
         std::memcpy(stora_ptr, large_ptr, sizeof_storage);
         std::memcpy(large_ptr, short_ptr, sizeof_storage);
         std::memcpy(short_ptr, stora_ptr, sizeof_storage);
         large_ptr += sizeof_storage;
         short_ptr += sizeof_storage;
         } while(--n);
   }
   std::memcpy(stora_ptr, large_ptr, szt_rem);
   std::memcpy(large_ptr, short_ptr, szt_rem);
   std::memcpy(short_ptr, stora_ptr, szt_rem);
   boost::container::iterator_uadvance(large_range_f, n_i);
   boost::container::iterator_uadvance(short_range_f, n_i);
   boost::container::uninitialized_move_alloc_n(a, large_range_f, std::size_t(n_j - n_i), short_range_f);
   boost::container::destroy_alloc_n(a, large_range_f, std::size_t(n_j - n_i));
}
# 1217 "/usr/include/boost/container/detail/copy_move_algo.hpp" 3 4
template
   <typename Allocator
   ,typename I
   ,typename O
   >
void copy_assign_range_alloc_n( Allocator &a, I inp_start, std::size_t n_i, O out_start, std::size_t n_o )
{
   if (n_o < n_i){
      inp_start = boost::container::copy_n_source_dest(inp_start, n_o, out_start);
      boost::container::uninitialized_copy_alloc_n(a, inp_start, std::size_t(n_i - n_o), out_start);
   }
   else{
      out_start = boost::container::copy_n(inp_start, n_i, out_start);
      boost::container::destroy_alloc_n(a, out_start, std::size_t(n_o - n_i));
   }
}







template
   <typename Allocator
   ,typename I
   ,typename O
   >
void move_assign_range_alloc_n( Allocator &a, I inp_start, std::size_t n_i, O out_start, std::size_t n_o )
{
   if (n_o < n_i){
      inp_start = boost::container::move_n_source_dest(inp_start, n_o, out_start);
      boost::container::uninitialized_move_alloc_n(a, inp_start, std::size_t(n_i - n_o), out_start);
   }
   else{
      out_start = boost::container::move_n(inp_start, n_i, out_start);
      boost::container::destroy_alloc_n(a, out_start, std::size_t(n_o - n_i));
   }
}

template<class Allocator>
struct array_destructor
{
   typedef typename ::boost::container::allocator_traits<Allocator>::value_type value_type;
   typedef typename dtl::if_c
      <dtl::is_trivially_destructible<value_type>::value
      ,dtl::null_scoped_destructor_range<Allocator>
      ,dtl::scoped_destructor_range<Allocator>
      >::type type;
};

template<class Allocator>
struct value_destructor
{
   typedef typename ::boost::container::allocator_traits<Allocator>::value_type value_type;
   typedef typename dtl::if_c
      <dtl::is_trivially_destructible<value_type>::value
      , dtl::null_scoped_destructor<Allocator>
      , dtl::scoped_destructor<Allocator>
      >::type type;
};

template
   <typename Allocator
   ,typename F
   ,typename O
   ,typename InsertionProxy
   >
void uninitialized_move_and_insert_alloc
   ( Allocator &a
   , F first
   , F pos
   , F last
   , O d_first
   , std::size_t n
   , InsertionProxy insertion_proxy)
{
   typedef typename array_destructor<Allocator>::type array_destructor_t;


   array_destructor_t new_values_destroyer(d_first, d_first, a);



   O d_last = ::boost::container::uninitialized_move_alloc(a, first, pos, d_first);
   new_values_destroyer.set_end(d_last);

   insertion_proxy.uninitialized_copy_n_and_update(a, d_last, n);
   d_last += n;
   new_values_destroyer.set_end(d_last);


   (void) ::boost::container::uninitialized_move_alloc(a, pos, last, d_last);

   new_values_destroyer.release();
}




template
   <typename Allocator
   ,typename F
   ,typename InsertionProxy
   >
typename dtl::enable_if_c<dtl::is_single_value_proxy<InsertionProxy>::value, void>::type
   expand_backward_and_insert_nonempty_middle_alloc
   ( Allocator &a
   , F const first
   , F const pos
   , std::size_t const
   , InsertionProxy insertion_proxy)
{
   (static_cast <bool> (first != pos) ? void (0) : __assert_fail ("first != pos", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));

   typedef typename value_destructor<Allocator>::type value_destructor_t;
   F aux = first; --aux;
   allocator_traits<Allocator>::construct(a, boost::movelib::iterator_to_raw_pointer(aux), boost::move(*first));
   value_destructor_t on_exception(a, boost::movelib::iterator_to_raw_pointer(aux));

   aux = first; ++aux;
   aux = boost::container::move(aux, pos, first);

   insertion_proxy.copy_n_and_update(a, aux, 1u);
   on_exception.release();
}

template
   <typename Allocator
   ,typename F
   ,typename InsertionProxy
   >
typename dtl::disable_if_c<dtl::is_single_value_proxy<InsertionProxy>::value, void>::type
   expand_backward_and_insert_nonempty_middle_alloc
   ( Allocator &a
   , F first
   , F pos
   , std::size_t const n
   , InsertionProxy insertion_proxy)
{
   (static_cast <bool> (first != pos) ? void (0) : __assert_fail ("first != pos", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
   (static_cast <bool> (n != 0) ? void (0) : __assert_fail ("n != 0", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));

   typedef typename array_destructor<Allocator>::type array_destructor_t;
   const std::size_t elems_before = iterator_udistance(first, pos);
   if(elems_before >= n){


      F const first_less_n = first - n;
      F nxt = ::boost::container::uninitialized_move_alloc_n_source(a, first, n, first_less_n);
      array_destructor_t on_exception(first_less_n, first, a);

      nxt = boost::container::move(nxt, pos, first);

      insertion_proxy.copy_n_and_update(a, nxt, n);
      on_exception.release();
   }
   else {


      F aux = ::boost::container::uninitialized_move_alloc(a, first, pos, first - n);
      array_destructor_t on_exception(first -n, aux, a);

      insertion_proxy.uninitialized_copy_n_and_update(a, aux, std::size_t(n - elems_before));
      insertion_proxy.copy_n_and_update(a, first, elems_before);
      on_exception.release();
   }
}


template
   <typename Allocator
   ,typename F
   ,typename InsertionProxy
   >
typename dtl::enable_if_c<dtl::is_single_value_proxy<InsertionProxy>::value, void>::type
   expand_forward_and_insert_nonempty_middle_alloc
   ( Allocator &a
   , F pos
   , F last
   , std::size_t const
   , InsertionProxy insertion_proxy)
{
   (static_cast <bool> (last != pos) ? void (0) : __assert_fail ("last != pos", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));

   typedef typename value_destructor<Allocator>::type value_destructor_t;
   F last_m_n = last; --last_m_n;
   allocator_traits<Allocator>::construct(a, boost::movelib::iterator_to_raw_pointer(last), boost::move(*last_m_n));
   value_destructor_t on_exception(a, boost::movelib::iterator_to_raw_pointer(last));

   boost::container::move_backward(pos, last_m_n, last);

   insertion_proxy.copy_n_and_update(a, pos, 1);
   on_exception.release();
}

template
   <typename Allocator
   ,typename F
   ,typename InsertionProxy
   >
typename dtl::disable_if_c<dtl::is_single_value_proxy<InsertionProxy>::value, void>::type
   expand_forward_and_insert_nonempty_middle_alloc
   ( Allocator &a
   , F pos
   , F last
   , std::size_t const n
   , InsertionProxy insertion_proxy)
{
   (static_cast <bool> (last != pos) ? void (0) : __assert_fail ("last != pos", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
   (static_cast <bool> (n != 0) ? void (0) : __assert_fail ("n != 0", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));

   typedef typename array_destructor<Allocator>::type array_destructor_t;
   const std::size_t elems_after = iterator_udistance(pos, last);
   if(elems_after >= n){


      F const last_m_n = last - n;
      F const nxt = ::boost::container::uninitialized_move_alloc_n(a, last_m_n, n, last);
      array_destructor_t on_exception(last, nxt, a);

      boost::container::move_backward(pos, last_m_n, last);

      insertion_proxy.copy_n_and_update(a, pos, n);
      on_exception.release();
   }
   else {


      F new_last = ::boost::container::uninitialized_move_alloc(a, pos, last, pos + n);
      array_destructor_t on_exception(pos + n, new_last, a);

      insertion_proxy.copy_n_and_update(a, pos, elems_after);

      insertion_proxy.uninitialized_copy_n_and_update(a, last, std::size_t(n - elems_after));
      on_exception.release();
   }
}

template
<typename Allocator
   , typename F
   , typename InsertionProxy
>
inline __attribute__ ((__always_inline__)) void expand_forward_and_insert_alloc
   ( Allocator& a
   , F pos
   , F last
   , std::size_t const n
   , InsertionProxy insertion_proxy)
{
   if (last == pos) {
      insertion_proxy.uninitialized_copy_n_and_update(a, last, n);
   }
   else{
      const bool single_value = dtl::is_single_value_proxy<InsertionProxy>::value;
      if constexpr(!single_value){
         if (__builtin_expect(!n, 0)) {
            return;
         }
      }
      expand_forward_and_insert_nonempty_middle_alloc(a, pos, last, n, insertion_proxy);
   }
}

template <class B, class InsertionProxy, class Allocator>
void expand_backward_forward_and_insert_alloc_move_backward
( B const old_start
, std::size_t const old_size
, B const new_start
, B const pos
, std::size_t const n
, InsertionProxy insertion_proxy
, Allocator& a)
{
   typedef std::size_t size_type;
   typedef typename allocator_traits<Allocator>::value_type value_type;
   static const bool trivial_dctr_after_move = has_trivial_destructor_after_move<value_type>::value;
   static const bool trivial_dctr = dtl::is_trivially_destructible<value_type>::value;

   typedef typename dtl::if_c
      <trivial_dctr
      , dtl::null_scoped_destructor_n<Allocator, B>
      , dtl::scoped_destructor_n<Allocator, B>
      >::type array_destructor_t;


   B old_finish = make_iterator_uadvance(old_start, old_size);


   const size_type elemsbefore = static_cast<size_type>(iterator_udistance(old_start, pos));
   const size_type raw_before = static_cast<size_type>(iterator_udistance(new_start, old_start));
   const size_type before_plus_new = size_type(elemsbefore + n);


   if (raw_before >= before_plus_new) {


      array_destructor_t old_values_destroyer(old_start, a, old_size);
# 1524 "/usr/include/boost/container/detail/copy_move_algo.hpp" 3 4
      B const new_elem_pos = ::boost::container::uninitialized_move_alloc(a, old_start, pos, new_start);
      array_destructor_t new_values_destroyer(new_start, a, elemsbefore);
      insertion_proxy.uninitialized_copy_n_and_update(a, new_elem_pos, n);
      new_values_destroyer.set_size(before_plus_new);
      const size_type new_size = size_type(old_size + n);


      if (raw_before >= new_size) {
# 1543 "/usr/include/boost/container/detail/copy_move_algo.hpp" 3 4
         if (before_plus_new != new_size) {
            B new_start_end(make_iterator_uadvance(new_start, before_plus_new));
            ::boost::container::uninitialized_move_alloc(a, pos, old_finish, new_start_end);
         }

         new_values_destroyer.release();



         if(trivial_dctr_after_move)
            old_values_destroyer.release();
      }

      else {
# 1569 "/usr/include/boost/container/detail/copy_move_algo.hpp" 3 4
         if constexpr(!trivial_dctr) {


            const size_type raw_gap = raw_before - before_plus_new;
            B new_start_plus(make_iterator_uadvance(new_start, before_plus_new));
            ::boost::container::uninitialized_move_alloc_n(a, pos, raw_gap, new_start_plus);
            new_values_destroyer.release();
            old_values_destroyer.increment_size_backwards(raw_before);

            B remaining_pos(make_iterator_uadvance(pos, raw_gap));
            remaining_pos = ::boost::container::move_forward_overlapping(remaining_pos, old_finish, old_start);
            (void)remaining_pos;

            if(!trivial_dctr_after_move) {
               boost::container::destroy_alloc(a, remaining_pos, old_finish);
            }
         }
         else {
            ::boost::container::uninitialized_move_alloc_n
               (a, pos, static_cast<size_type>(old_finish - pos), make_iterator_uadvance(new_start, before_plus_new));
         }
         old_values_destroyer.release();
      }
   }
   else {


      array_destructor_t old_values_destroyer(old_start, a, old_size);
# 1611 "/usr/include/boost/container/detail/copy_move_algo.hpp" 3 4
      const bool do_after = n > raw_before;



      if (raw_before <= elemsbefore) {
# 1633 "/usr/include/boost/container/detail/copy_move_algo.hpp" 3 4
         ::boost::container::uninitialized_move_alloc_n(a, old_start, raw_before, new_start);



         size_type new_1st_range;
         old_values_destroyer.increment_size_backwards(raw_before);
         new_1st_range = do_after ? raw_before : n;


         B const old_next(make_iterator_uadvance(old_start, raw_before));
         B const next = ::boost::container::move(old_next, pos, old_start);

         insertion_proxy.copy_n_and_update(a, next, new_1st_range);


         if (!do_after) {

            B const new_first(make_iterator_uadvance(next, new_1st_range));
            B const p = ::boost::container::move_forward_overlapping(pos, old_finish, new_first);
            (void)p;
            if(!trivial_dctr_after_move)
               boost::container::destroy_alloc(a, p, old_finish);
         }
      }
      else {
# 1679 "/usr/include/boost/container/detail/copy_move_algo.hpp" 3 4
         B const new_pos = ::boost::container::uninitialized_move_alloc(a, old_start, pos, new_start);
         array_destructor_t new_values_destroyer(new_start, a, elemsbefore);
         const size_type mid_n = size_type(raw_before - elemsbefore);
         insertion_proxy.uninitialized_copy_n_and_update(a, new_pos, mid_n);
         new_values_destroyer.release();

         old_values_destroyer.increment_size_backwards(raw_before);

         if (do_after) {

            insertion_proxy.copy_n_and_update(a, old_start, elemsbefore);
         }
         else {

            const size_type rest_new = size_type(n - mid_n);
            insertion_proxy.copy_n_and_update(a, old_start, rest_new);

            B move_start(make_iterator_uadvance(old_start, rest_new));


            B const move_end = ::boost::container::move_forward_overlapping(pos, old_finish, move_start);
            (void)move_end;



            if(!trivial_dctr_after_move) {
               boost::container::destroy_alloc(a, move_end, old_finish);
            }
         }
      }


      if (do_after) {
# 1722 "/usr/include/boost/container/detail/copy_move_algo.hpp" 3 4
         const size_type n_after = size_type(n - raw_before);
         const size_type elemsafter = size_type(old_size - elemsbefore);


         if (elemsafter >= n_after) {
# 1740 "/usr/include/boost/container/detail/copy_move_algo.hpp" 3 4
            B finish_n = make_iterator_advance(old_finish, -std::ptrdiff_t(n_after));
            ::boost::container::uninitialized_move_alloc(a, finish_n, old_finish, old_finish);
            old_values_destroyer.increment_size(n_after);

            boost::container::move_backward_overlapping(pos, finish_n, old_finish);


            insertion_proxy.copy_n_and_update(a, pos, n_after);
         }
         else {
# 1759 "/usr/include/boost/container/detail/copy_move_algo.hpp" 3 4
            const size_type mid_last_dist = size_type(n_after - elemsafter);


            B const mid_last(make_iterator_uadvance(old_finish, mid_last_dist));
            ::boost::container::uninitialized_move_alloc(a, pos, old_finish, mid_last);

            array_destructor_t old_end_destroyer(mid_last, a, iterator_udistance(pos, old_finish));


            insertion_proxy.copy_n_and_update(a, pos, elemsafter);

            insertion_proxy.uninitialized_copy_n_and_update(a, old_finish, mid_last_dist);
            old_end_destroyer.release();
         }
      }
      old_values_destroyer.release();
   }
}

template
<typename Allocator
   , typename B
   , typename InsertionProxy
>
inline __attribute__ ((__always_inline__)) void expand_backward_forward_and_insert_alloc_move_forward
   ( B const old_start
   , std::size_t const old_size
   , B const new_start
   , B const pos
   , std::size_t const n
   , InsertionProxy insertion_proxy
   , Allocator& a)
{
   typedef std::size_t size_type;
   typedef typename allocator_traits<Allocator>::value_type value_type;
   static const bool trivial_dctr_after_move = has_trivial_destructor_after_move<value_type>::value;
   static const bool trivial_dctr = dtl::is_trivially_destructible<value_type>::value;

   typedef typename dtl::if_c
      <trivial_dctr
      , dtl::null_scoped_destructor_n<Allocator, B>
      , dtl::scoped_destructor_n<Allocator, B>
      >::type array_destructor_t;



   B const old_finish = make_iterator_uadvance(old_start, old_size);
   const size_type new_size = size_type(old_size + n);
   B const new_finish = make_iterator_uadvance(new_start, new_size);



   const size_type elemsafter = static_cast<size_type>(iterator_udistance(pos, old_finish));
   const size_type raw_after = static_cast<size_type>(iterator_udistance(old_finish, new_finish));

   const size_type after_plus_new = size_type(elemsafter + n);


   if (raw_after >= after_plus_new) {


      array_destructor_t old_values_destroyer(old_start, a, old_size);
# 1829 "/usr/include/boost/container/detail/copy_move_algo.hpp" 3 4
      B new_elem_pos = new_finish - after_plus_new;
      insertion_proxy.uninitialized_copy_n_and_update(a, new_elem_pos, n);
      array_destructor_t new_values_destroyer(new_elem_pos, a, n);
      ::boost::container::uninitialized_move_alloc(a, pos, old_finish, new_elem_pos+n);
      new_values_destroyer.set_size(after_plus_new);



      if (raw_after >= new_size) {
# 1849 "/usr/include/boost/container/detail/copy_move_algo.hpp" 3 4
         ::boost::container::uninitialized_move_alloc(a, old_start, pos, new_start);

         new_values_destroyer.release();



         if(trivial_dctr_after_move)
            old_values_destroyer.release();
      }

      else {
# 1872 "/usr/include/boost/container/detail/copy_move_algo.hpp" 3 4
         const size_type raw_gap = raw_after - after_plus_new;
         B const pre_pos_raw = pos - raw_gap;
         ::boost::container::uninitialized_move_alloc_n(a, pre_pos_raw, raw_gap, old_finish);
         new_values_destroyer.release();
         old_values_destroyer.increment_size(raw_after);

         (static_cast <bool> (old_start != old_finish) ? void (0) : __assert_fail ("old_start != old_finish", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
         boost::container::move_backward_overlapping(old_start, pre_pos_raw, old_finish);
         old_values_destroyer.release();
         if (!trivial_dctr_after_move) {
            boost::container::destroy_alloc(a, old_start, new_start);
         }
      }
   }
   else{


      array_destructor_t old_values_destroyer(old_start, a, old_size);



      if (raw_after > elemsafter) {
# 1903 "/usr/include/boost/container/detail/copy_move_algo.hpp" 3 4
         B p = new_finish - elemsafter;
         ::boost::container::uninitialized_move_alloc(a, pos, old_finish, p);
         array_destructor_t new_values_destroyer(p, a, elemsafter);

         const size_type mid_n = size_type(raw_after - elemsafter);
         const size_type rest_new = size_type(n - mid_n);
         B new_rng_start = old_finish - rest_new;
         insertion_proxy.copy_n_and_update(a, new_rng_start, rest_new);
         insertion_proxy.uninitialized_copy_n_and_update(a, old_finish, mid_n);
         new_values_destroyer.release();
         old_values_destroyer.increment_size_backwards(raw_after);

         p = ::boost::container::move_backward_overlapping(old_start, pos, new_rng_start);



         old_values_destroyer.release();
         if (!trivial_dctr_after_move) {
            boost::container::destroy_alloc(a, old_start, p);
         }
      }
      else {
# 1934 "/usr/include/boost/container/detail/copy_move_algo.hpp" 3 4
         const B old_end_pivot = old_finish - raw_after;
         ::boost::container::uninitialized_move_alloc_n(a, old_end_pivot, raw_after, old_finish);

         old_values_destroyer.increment_size_backwards(raw_after);


         B const new_end_pos = ::boost::container::move_backward_overlapping(pos, old_end_pivot, old_finish);
         B const new_beg_pos = new_end_pos - n;


         insertion_proxy.copy_n_and_update(a, new_beg_pos, n);
         B const p = ::boost::container::move_backward_overlapping(old_start, pos, new_beg_pos);
         old_values_destroyer.release();

         if (!trivial_dctr_after_move) {
            (void)p;
            boost::container::destroy_alloc(a, old_start, p);
         }
      }
   }
}

template <class R, class InsertionProxy, class Allocator>
void expand_backward_forward_and_insert_alloc
   ( R const old_start
   , std::size_t const old_size
   , R const new_start
   , R const pos
   , std::size_t const n
   , InsertionProxy insertion_proxy
   , Allocator& a)
{
   if(new_start < old_start){
      expand_backward_forward_and_insert_alloc_move_backward(old_start, old_size, new_start, pos, n, insertion_proxy, a);
   }
   else{
      expand_backward_forward_and_insert_alloc_move_forward(old_start, old_size, new_start, pos, n, insertion_proxy, a);
   }
}

}
}
# 29 "/usr/include/boost/container/detail/advanced_insert_int.hpp" 2 3 4
# 43 "/usr/include/boost/container/detail/advanced_insert_int.hpp" 3 4
# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 58 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 59 "/usr/include/boost/assert.hpp" 2 3 4
# 44 "/usr/include/boost/container/detail/advanced_insert_int.hpp" 2 3 4

namespace boost { namespace container { namespace dtl {

template<class Allocator, class FwdIt>
struct move_insert_range_proxy
{
   typedef typename allocator_traits<Allocator>::value_type value_type;

   inline __attribute__ ((__always_inline__)) explicit move_insert_range_proxy(FwdIt first)
      : first_(first)
   {}

   template<class Iterator>
   inline __attribute__ ((__always_inline__)) void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n)
   {
      this->first_ = ::boost::container::uninitialized_move_alloc_n_source
         (a, this->first_, n, p);
   }

   template<class Iterator>
   inline __attribute__ ((__always_inline__)) void copy_n_and_update(Allocator &, Iterator p, std::size_t n)
   {
      this->first_ = ::boost::container::move_n_source(this->first_, n, p);
   }

   FwdIt first_;
};


template<class Allocator, class FwdIt>
struct insert_range_proxy
{
   typedef typename allocator_traits<Allocator>::value_type value_type;

   inline __attribute__ ((__always_inline__)) explicit insert_range_proxy(FwdIt first)
      : first_(first)
   {}

   template<class Iterator>
   inline __attribute__ ((__always_inline__)) void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n)
   {
      this->first_ = ::boost::container::uninitialized_copy_alloc_n_source(a, this->first_, n, p);
   }

   template<class Iterator>
   inline __attribute__ ((__always_inline__)) void copy_n_and_update(Allocator &, Iterator p, std::size_t n)
   {
      this->first_ = ::boost::container::copy_n_source(this->first_, n, p);
   }

   FwdIt first_;
};


template<class Allocator>
struct insert_n_copies_proxy
{
   typedef typename allocator_traits<Allocator>::value_type value_type;

   inline __attribute__ ((__always_inline__)) explicit insert_n_copies_proxy(const value_type &v)
      : v_(v)
   {}

   template<class Iterator>
   inline __attribute__ ((__always_inline__)) void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
   { boost::container::uninitialized_fill_alloc_n(a, v_, n, p); }

   template<class Iterator>
   inline __attribute__ ((__always_inline__)) void copy_n_and_update(Allocator &, Iterator p, std::size_t n) const
   {
      while (n){
         --n;
         *p = v_;
         ++p;
      }
   }

   const value_type &v_;
};

template<class Allocator>
struct insert_value_initialized_n_proxy
{
   typedef ::boost::container::allocator_traits<Allocator> alloc_traits;
   typedef typename allocator_traits<Allocator>::value_type value_type;
   typedef typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type storage_t;

   template<class Iterator>
   inline __attribute__ ((__always_inline__)) void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
   { boost::container::uninitialized_value_init_alloc_n(a, n, p); }

   template<class Iterator>
   void copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
   {
      while (n){
         --n;
         storage_t v;
         alloc_traits::construct(a, move_detail::force_ptr<value_type *>(&v));
         value_type *vp = move_detail::force_ptr<value_type *>(&v);
         value_destructor<Allocator> on_exit(a, *vp); (void)on_exit;
         *p = ::boost::move(*vp);
         ++p;
      }
   }
};

template<class Allocator>
struct insert_default_initialized_n_proxy
{
   typedef ::boost::container::allocator_traits<Allocator> alloc_traits;
   typedef typename allocator_traits<Allocator>::value_type value_type;
   typedef typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type storage_t;

   template<class Iterator>
   inline __attribute__ ((__always_inline__)) void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
   { boost::container::uninitialized_default_init_alloc_n(a, n, p); }

   template<class Iterator>
   void copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
   {
      if(!is_pod<value_type>::value){
         while (n){
            --n;
            typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type v;
            alloc_traits::construct(a, move_detail::force_ptr<value_type *>(&v), default_init);
            value_type *vp = move_detail::force_ptr<value_type *>(&v);
            value_destructor<Allocator> on_exit(a, *vp); (void)on_exit;
            *p = ::boost::move(*vp);
            ++p;
         }
      }
   }
};

template<class Allocator>
struct insert_copy_proxy
{
   typedef boost::container::allocator_traits<Allocator> alloc_traits;
   typedef typename alloc_traits::value_type value_type;

   static const bool single_value = true;

   inline __attribute__ ((__always_inline__)) explicit insert_copy_proxy(const value_type &v)
      : v_(v)
   {}

   template<class Iterator>
   inline __attribute__ ((__always_inline__)) void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
   {
      (static_cast <bool> (n == 1) ? void (0) : __assert_fail ("n == 1", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); (void)n;
      alloc_traits::construct( a, boost::movelib::iterator_to_raw_pointer(p), v_);
   }

   template<class Iterator>
   inline __attribute__ ((__always_inline__)) void copy_n_and_update(Allocator &, Iterator p, std::size_t n) const
   {
      (static_cast <bool> (n == 1) ? void (0) : __assert_fail ("n == 1", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); (void)n;
      *p = v_;
   }

   const value_type &v_;
};


template<class Allocator>
struct insert_move_proxy
{
   typedef boost::container::allocator_traits<Allocator> alloc_traits;
   typedef typename alloc_traits::value_type value_type;

   static const bool single_value = true;

   inline __attribute__ ((__always_inline__)) explicit insert_move_proxy(value_type &v)
      : v_(v)
   {}

   template<class Iterator>
   inline __attribute__ ((__always_inline__)) void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
   {
      (static_cast <bool> (n == 1) ? void (0) : __assert_fail ("n == 1", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); (void)n;
      alloc_traits::construct( a, boost::movelib::iterator_to_raw_pointer(p), ::boost::move(v_) );
   }

   template<class Iterator>
   inline __attribute__ ((__always_inline__)) void copy_n_and_update(Allocator &, Iterator p, std::size_t n) const
   {
      (static_cast <bool> (n == 1) ? void (0) : __assert_fail ("n == 1", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); (void)n;
      *p = ::boost::move(v_);
   }

   value_type &v_;
};

template<class It, class Allocator>
inline __attribute__ ((__always_inline__)) insert_move_proxy<Allocator> get_insert_value_proxy(typename boost::container::iterator_traits<It>::value_type && v)
{
   return insert_move_proxy<Allocator>(v);
}

template<class It, class Allocator>
inline __attribute__ ((__always_inline__)) insert_copy_proxy<Allocator> get_insert_value_proxy(const typename boost::container::iterator_traits<It>::value_type &v)
{
   return insert_copy_proxy<Allocator>(v);
}

}}}






namespace boost {
namespace container {
namespace dtl {

template<class Allocator, class ...Args>
struct insert_nonmovable_emplace_proxy
{
   typedef boost::container::allocator_traits<Allocator> alloc_traits;
   typedef typename alloc_traits::value_type value_type;
   typedef typename build_number_seq<sizeof...(Args)>::type index_tuple_t;

   static const bool single_value = true;

   inline __attribute__ ((__always_inline__)) explicit insert_nonmovable_emplace_proxy(Args &&... args)
      : args_(args...)
   {}

   template<class Iterator>
   inline __attribute__ ((__always_inline__)) void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n)
   { this->priv_uninitialized_copy_some_and_update(a, index_tuple_t(), p, n); }

   private:
   template<std::size_t ...IdxPack, class Iterator>
   inline __attribute__ ((__always_inline__)) void priv_uninitialized_copy_some_and_update(Allocator &a, const index_tuple<IdxPack...>&, Iterator p, std::size_t n)
   {
      (static_cast <bool> (n == 1) ? void (0) : __assert_fail ("n == 1", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); (void)n;
      alloc_traits::construct( a, boost::movelib::iterator_to_raw_pointer(p), ::boost::forward<Args>(get<IdxPack>(this->args_))... );
   }

   protected:
   tuple<Args&...> args_;
};

template<class Allocator, class ...Args>
struct insert_emplace_proxy
   : public insert_nonmovable_emplace_proxy<Allocator, Args...>
{
   typedef insert_nonmovable_emplace_proxy<Allocator, Args...> base_t;
   typedef boost::container::allocator_traits<Allocator> alloc_traits;
   typedef typename base_t::value_type value_type;
   typedef typename base_t::index_tuple_t index_tuple_t;

   static const bool single_value = true;

   inline __attribute__ ((__always_inline__)) explicit insert_emplace_proxy(Args &&... args)
      : base_t(::boost::forward<Args>(args)...)
   {}

   template<class Iterator>
   inline __attribute__ ((__always_inline__)) void copy_n_and_update(Allocator &a, Iterator p, std::size_t n)
   { this->priv_copy_some_and_update(a, index_tuple_t(), p, n); }

   private:

   template<std::size_t ...IdxPack, class Iterator>
   inline __attribute__ ((__always_inline__)) void priv_copy_some_and_update(Allocator &a, const index_tuple<IdxPack...>&, Iterator p, std::size_t n)
   {
      (static_cast <bool> (n ==1) ? void (0) : __assert_fail ("n ==1", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); (void)n;
      typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type v;
      alloc_traits::construct(a, move_detail::force_ptr<value_type *>(&v), ::boost::forward<Args>(get<IdxPack>(this->args_))...);
      value_type *vp = move_detail::force_ptr<value_type *>(&v);
      { try{
         *p = ::boost::move(*vp);
      }
      catch(...){
         alloc_traits::destroy(a, vp);
         throw;
      }
      }
      alloc_traits::destroy(a, vp);
   }
};


template<class Allocator>
struct insert_emplace_proxy<Allocator, typename boost::container::allocator_traits<Allocator>::value_type>
   : public insert_move_proxy<Allocator>
{
   static const bool single_value = true;

   inline __attribute__ ((__always_inline__)) explicit insert_emplace_proxy(typename boost::container::allocator_traits<Allocator>::value_type &&v)
   : insert_move_proxy<Allocator>(v)
   {}
};




template<class Allocator>
struct insert_emplace_proxy<Allocator
   , typename boost::container::dtl::add_const<typename boost::container::allocator_traits<Allocator>::value_type>::type
   >
   : public insert_copy_proxy<Allocator>
{

   static const bool single_value = true;

   inline __attribute__ ((__always_inline__)) explicit insert_emplace_proxy(const typename boost::container::allocator_traits<Allocator>::value_type &v)
   : insert_copy_proxy<Allocator>(v)
   {}
};

template<class Allocator>
struct insert_emplace_proxy<Allocator, typename boost::container::allocator_traits<Allocator>::value_type &>
   : public insert_copy_proxy<Allocator>
{
   static const bool single_value = true;

   inline __attribute__ ((__always_inline__)) explicit insert_emplace_proxy(const typename boost::container::allocator_traits<Allocator>::value_type &v)
   : insert_copy_proxy<Allocator>(v)
   {}
};

template<class Allocator>
struct insert_emplace_proxy<Allocator
   , typename boost::container::dtl::add_const<typename boost::container::allocator_traits<Allocator>::value_type>::type &
   >
   : public insert_copy_proxy<Allocator>
{
   static const bool single_value = true;

   inline __attribute__ ((__always_inline__)) explicit insert_emplace_proxy(const typename boost::container::allocator_traits<Allocator>::value_type &v)
   : insert_copy_proxy<Allocator>(v)
   {}
};

}}}
# 540 "/usr/include/boost/container/detail/advanced_insert_int.hpp" 3 4
# 1 "/usr/include/boost/container/detail/config_end.hpp" 1 3 4
# 541 "/usr/include/boost/container/detail/advanced_insert_int.hpp" 2 3 4
# 33 "/usr/include/boost/container/vector.hpp" 2 3 4
# 1 "/usr/include/boost/container/detail/algorithm.hpp" 1 3 4
# 26 "/usr/include/boost/container/detail/algorithm.hpp" 3 4
namespace boost {
namespace container {

using boost::intrusive::algo_equal;
using boost::intrusive::algo_lexicographical_compare;

template<class Func>
class binder1st
{
   public:
 typedef typename Func::second_argument_type argument_type;
 typedef typename Func::result_type result_type;

 binder1st(const Func& func, const typename Func::first_argument_type& arg)
    : op(func), value(arg)
 {}

 result_type operator()(const argument_type& arg) const
   { return op(value, arg); }

 result_type operator()(argument_type& arg) const
   { return op(value, arg); }

   private:
 Func op;
 typename Func::first_argument_type value;
};

template<class Func, class T>
inline binder1st<Func> bind1st(const Func& func, const T& arg)
{ return boost::container::binder1st<Func>(func, arg); }

template<class Func>
class binder2nd
{
   public:
 typedef typename Func::first_argument_type argument_type;
 typedef typename Func::result_type result_type;

 binder2nd(const Func& func, const typename Func::second_argument_type& arg)
    : op(func), value(arg)
   {}

 result_type operator()(const argument_type& arg) const
   { return op(arg, value); }

 result_type operator()(argument_type& arg) const
 { return op(arg, value); }

   private:
 Func op;
 typename Func::second_argument_type value;
};

template<class Func, class T>
inline binder2nd<Func> bind2nd(const Func& func, const T& arg)
{
   return (boost::container::binder2nd<Func>(func, arg));
}

template<class Func>
class unary_negate
{
   public:
   typedef typename Func::argument_type argument_type;
   typedef typename Func::result_type result_type;

 explicit unary_negate(const Func& func)
  : m_func(func)
   {}

 bool operator()(const typename Func::argument_type& arg) const
 { return !m_func(arg); }

   private:
 Func m_func;
};

template<class Func> inline
unary_negate<Func> not1(const Func& func)
{
   return boost::container::unary_negate<Func>(func);
}

template<class InputIt, class UnaryPredicate>
InputIt find_if(InputIt first, InputIt last, UnaryPredicate p)
{
   for (; first != last; ++first) {
      if (p(*first)) {
         return first;
      }
   }
   return last;
}

template<class ForwardIt1, class ForwardIt2, class BinaryPredicate>
  ForwardIt1 find_end (ForwardIt1 first1, ForwardIt1 last1
                      ,ForwardIt2 first2, ForwardIt2 last2
                      ,BinaryPredicate p)
{
   if (first2==last2)
      return last1;

   ForwardIt1 ret = last1;

   while (first1!=last1)
   {
      ForwardIt1 it1 = first1;
      ForwardIt2 it2 = first2;
      while ( p(*it1, *it2) ) {
         ++it1; ++it2;
         if (it2==last2) {
            ret=first1;
            break;
         }
         if (it1==last1)
         return ret;
      }
      ++first1;
   }
   return ret;
}

template<class InputIt, class ForwardIt, class BinaryPredicate>
InputIt find_first_of(InputIt first1, InputIt last1, ForwardIt first2, ForwardIt last2, BinaryPredicate p)
{
   for (; first1 != last1; ++first1) {
      for (ForwardIt it = first2; it != last2; ++it) {
         if (p(*first1, *it)) {
            return first1;
         }
      }
   }
   return last1;
}

template<class ForwardIt1, class ForwardIt2, class BinaryPredicate>
ForwardIt1 search(ForwardIt1 first1, ForwardIt1 last1,
                        ForwardIt2 first2, ForwardIt2 last2, BinaryPredicate p)
{
   for (; ; ++first1) {
      ForwardIt1 it = first1;
      for (ForwardIt2 it2 = first2; ; ++it, ++it2) {
         if (it2 == last2) {
            return first1;
         }
         if (it == last1) {
            return last1;
         }
         if (!p(*it, *it2)) {
            break;
         }
      }
   }
}

}
}
# 34 "/usr/include/boost/container/vector.hpp" 2 3 4
# 1 "/usr/include/boost/container/detail/alloc_helpers.hpp" 1 3 4
# 25 "/usr/include/boost/container/detail/alloc_helpers.hpp" 3 4
namespace boost {
namespace container {
namespace dtl {

template<class AllocatorType>
inline __attribute__ ((__always_inline__)) void swap_alloc(AllocatorType &, AllocatorType &, dtl::false_type)
   noexcept
{}

template<class AllocatorType>
inline __attribute__ ((__always_inline__)) void swap_alloc(AllocatorType &l, AllocatorType &r, dtl::true_type)
{ boost::adl_move_swap(l, r); }

template<class AllocatorType>
inline __attribute__ ((__always_inline__)) void assign_alloc(AllocatorType &, const AllocatorType &, dtl::false_type)
   noexcept
{}

template<class AllocatorType>
inline __attribute__ ((__always_inline__)) void assign_alloc(AllocatorType &l, const AllocatorType &r, dtl::true_type)
{ l = r; }

template<class AllocatorType>
inline __attribute__ ((__always_inline__)) void move_alloc(AllocatorType &, AllocatorType &, dtl::false_type)
   noexcept
{}

template<class AllocatorType>
inline __attribute__ ((__always_inline__)) void move_alloc(AllocatorType &l, AllocatorType &r, dtl::true_type)
{ l = ::boost::move(r); }

}
}
}
# 35 "/usr/include/boost/container/vector.hpp" 2 3 4
# 1 "/usr/include/boost/container/detail/allocation_type.hpp" 1 3 4
# 22 "/usr/include/boost/container/detail/allocation_type.hpp" 3 4
# 1 "/usr/include/boost/container/detail/config_begin.hpp" 1 3 4
# 23 "/usr/include/boost/container/detail/allocation_type.hpp" 2 3 4


namespace boost {
namespace container {


enum allocation_type_v
{

   allocate_new_v = 0x01,
   expand_fwd_v = 0x02,
   expand_bwd_v = 0x04,


   shrink_in_place_v = 0x08,
   nothrow_allocation_v = 0x10,
   zero_memory_v = 0x20,
   try_shrink_in_place_v = 0x40
};

typedef unsigned int allocation_type;

static const allocation_type allocate_new = (allocation_type)allocate_new_v;
static const allocation_type expand_fwd = (allocation_type)expand_fwd_v;
static const allocation_type expand_bwd = (allocation_type)expand_bwd_v;
static const allocation_type shrink_in_place = (allocation_type)shrink_in_place_v;
static const allocation_type try_shrink_in_place= (allocation_type)try_shrink_in_place_v;
static const allocation_type nothrow_allocation = (allocation_type)nothrow_allocation_v;
static const allocation_type zero_memory = (allocation_type)zero_memory_v;

}
}

# 1 "/usr/include/boost/container/detail/config_end.hpp" 1 3 4
# 57 "/usr/include/boost/container/detail/allocation_type.hpp" 2 3 4
# 36 "/usr/include/boost/container/vector.hpp" 2 3 4






# 1 "/usr/include/boost/container/detail/next_capacity.hpp" 1 3 4
# 21 "/usr/include/boost/container/detail/next_capacity.hpp" 3 4
# 1 "/usr/include/boost/container/detail/config_begin.hpp" 1 3 4
# 22 "/usr/include/boost/container/detail/next_capacity.hpp" 2 3 4





# 1 "/usr/include/boost/container/detail/min_max.hpp" 1 3 4
# 21 "/usr/include/boost/container/detail/min_max.hpp" 3 4
namespace boost {
namespace container {
namespace dtl {

template<class T>
const T &max_value(const T &a, const T &b)
{ return a > b ? a : b; }

template<class T>
const T &min_value(const T &a, const T &b)
{ return a < b ? a : b; }

}
}
}
# 28 "/usr/include/boost/container/detail/next_capacity.hpp" 2 3 4



namespace boost {
namespace container {
namespace dtl {

template<unsigned Minimum, unsigned Numerator, unsigned Denominator>
struct grow_factor_ratio
{
   static_assert(Numerator > Denominator, "Numerator > Denominator");
   static_assert(Numerator < 100, "Numerator < 100");
   static_assert(Denominator < 100, "Denominator < 100");
   static_assert(Denominator == 1 || (0 != Numerator % Denominator), "Denominator == 1 || (0 != Numerator % Denominator)");

   template<class SizeType>
   SizeType operator()(const SizeType cur_cap, const SizeType add_min_cap, const SizeType max_cap) const
   {
      const SizeType overflow_limit = ((SizeType)-1) / Numerator;

      SizeType new_cap = 0;

      if(cur_cap <= overflow_limit){
         new_cap = SizeType(cur_cap * Numerator / Denominator);
      }
      else if(Denominator == 1 || (SizeType(new_cap = cur_cap) / Denominator) > overflow_limit){
         new_cap = (SizeType)-1;
      }
      else{
         new_cap = SizeType(new_cap*Numerator);
      }
      return max_value<SizeType>
               ( SizeType(Minimum)
               , max_value<SizeType>
                  ( SizeType(cur_cap+add_min_cap)
                  , min_value<SizeType>(max_cap, new_cap))
               );
   }
};

}

struct growth_factor_50
   : dtl::grow_factor_ratio<0, 3, 2>
{};

struct growth_factor_60
   : dtl::grow_factor_ratio<0, 8, 5>
{};

struct growth_factor_100
   : dtl::grow_factor_ratio<0, 2, 1>
{};

template<class SizeType>
inline __attribute__ ((__always_inline__)) void clamp_by_stored_size_type(SizeType &, SizeType)
{}

template<class SizeType, class SomeStoredSizeType>
inline __attribute__ ((__always_inline__)) void clamp_by_stored_size_type(SizeType &s, SomeStoredSizeType)
{
   if (s >= SomeStoredSizeType(-1) )
      s = SomeStoredSizeType(-1);
}

}
}

# 1 "/usr/include/boost/container/detail/config_end.hpp" 1 3 4
# 97 "/usr/include/boost/container/detail/next_capacity.hpp" 2 3 4
# 43 "/usr/include/boost/container/vector.hpp" 2 3 4
# 1 "/usr/include/boost/container/detail/value_functors.hpp" 1 3 4
# 23 "/usr/include/boost/container/detail/value_functors.hpp" 3 4
namespace boost {
namespace container {

using ::boost::intrusive::value_less;
using ::boost::intrusive::value_equal;

}
}
# 44 "/usr/include/boost/container/vector.hpp" 2 3 4
# 58 "/usr/include/boost/container/vector.hpp" 3 4
# 1 "/usr/include/boost/move/detail/move_helpers.hpp" 1 3 4
# 59 "/usr/include/boost/container/vector.hpp" 2 3 4

# 1 "/usr/include/boost/move/algo/adaptive_merge.hpp" 1 3 4
# 15 "/usr/include/boost/move/algo/adaptive_merge.hpp" 3 4
# 1 "/usr/include/boost/move/detail/config_begin.hpp" 1 3 4
# 16 "/usr/include/boost/move/algo/adaptive_merge.hpp" 2 3 4
# 1 "/usr/include/boost/move/algo/detail/adaptive_sort_merge.hpp" 1 3 4
# 45 "/usr/include/boost/move/algo/detail/adaptive_sort_merge.hpp" 3 4
# 1 "/usr/include/boost/move/detail/config_begin.hpp" 1 3 4
# 46 "/usr/include/boost/move/algo/detail/adaptive_sort_merge.hpp" 2 3 4


# 1 "/usr/include/boost/move/algo/move.hpp" 1 3 4
# 25 "/usr/include/boost/move/algo/move.hpp" 3 4
# 1 "/usr/include/boost/move/detail/config_begin.hpp" 1 3 4
# 26 "/usr/include/boost/move/algo/move.hpp" 2 3 4
# 35 "/usr/include/boost/move/algo/move.hpp" 3 4
namespace boost {
# 54 "/usr/include/boost/move/algo/move.hpp" 3 4
   template <typename I,
            typename O>
   O move(I f, I l, O result)
   {
      while (f != l) {
         *result = ::boost::move(*f);
         ++f; ++result;
      }
      return result;
   }
# 81 "/usr/include/boost/move/algo/move.hpp" 3 4
   template <typename I,
   typename O>
   O move_backward(I f, I l, O result)
   {
      while (f != l) {
         --l; --result;
         *result = ::boost::move(*l);
      }
      return result;
   }
# 112 "/usr/include/boost/move/algo/move.hpp" 3 4
template
   <typename I,
    typename F>
F uninitialized_move(I f, I l, F r



   )
{
   typedef typename boost::movelib::iterator_traits<I>::value_type input_value_type;

   F back = r;
   { try{
      while (f != l) {
         void * const addr = static_cast<void*>(::boost::move_detail::addressof(*r));
         ::new(addr) input_value_type(::boost::move(*f));
         ++f; ++r;
      }
   }
   catch(...){
      for (; back != r; ++back){
         boost::movelib::iterator_to_raw_pointer(back)->~input_value_type();
      }
      throw;;
   }
   }
   return r;
}
# 155 "/usr/include/boost/move/algo/move.hpp" 3 4
}

# 1 "/usr/include/boost/move/detail/config_end.hpp" 1 3 4
# 158 "/usr/include/boost/move/algo/move.hpp" 2 3 4
# 49 "/usr/include/boost/move/algo/detail/adaptive_sort_merge.hpp" 2 3 4
# 1 "/usr/include/boost/move/algo/detail/merge.hpp" 1 3 4
# 15 "/usr/include/boost/move/algo/detail/merge.hpp" 3 4
# 1 "/usr/include/boost/move/algo/detail/basic_op.hpp" 1 3 4
# 27 "/usr/include/boost/move/algo/detail/basic_op.hpp" 3 4
namespace boost {
namespace movelib {

struct forward_t{};
struct backward_t{};
struct three_way_t{};
struct three_way_forward_t{};
struct four_way_t{};

struct move_op
{
   template <class SourceIt, class DestinationIt>
   inline __attribute__ ((__always_inline__)) void operator()(SourceIt source, DestinationIt dest)
   { *dest = ::boost::move(*source); }

   template <class SourceIt, class DestinationIt>
   inline __attribute__ ((__always_inline__)) DestinationIt operator()(forward_t, SourceIt first, SourceIt last, DestinationIt dest_begin)
   { return ::boost::move(first, last, dest_begin); }

   template <class SourceIt, class DestinationIt>
   inline __attribute__ ((__always_inline__)) DestinationIt operator()(backward_t, SourceIt first, SourceIt last, DestinationIt dest_last)
   { return ::boost::move_backward(first, last, dest_last); }

   template <class SourceIt, class DestinationIt1, class DestinationIt2>
   inline __attribute__ ((__always_inline__)) void operator()(three_way_t, SourceIt srcit, DestinationIt1 dest1it, DestinationIt2 dest2it)
   {
      *dest2it = boost::move(*dest1it);
      *dest1it = boost::move(*srcit);
   }

   template <class SourceIt, class DestinationIt1, class DestinationIt2>
   DestinationIt2 operator()(three_way_forward_t, SourceIt srcit, SourceIt srcitend, DestinationIt1 dest1it, DestinationIt2 dest2it)
   {

      while(srcit != srcitend){
         this->operator()(three_way_t(), srcit++, dest1it++, dest2it++);
      }
      return dest2it;
   }

   template <class SourceIt, class DestinationIt1, class DestinationIt2, class DestinationIt3>
   inline __attribute__ ((__always_inline__)) void operator()(four_way_t, SourceIt srcit, DestinationIt1 dest1it, DestinationIt2 dest2it, DestinationIt3 dest3it)
   {
      *dest3it = boost::move(*dest2it);
      *dest2it = boost::move(*dest1it);
      *dest1it = boost::move(*srcit);
   }
};

struct swap_op
{
   template <class SourceIt, class DestinationIt>
   inline __attribute__ ((__always_inline__)) void operator()(SourceIt source, DestinationIt dest)
   { boost::adl_move_swap(*dest, *source); }

   template <class SourceIt, class DestinationIt>
   inline __attribute__ ((__always_inline__)) DestinationIt operator()(forward_t, SourceIt first, SourceIt last, DestinationIt dest_begin)
   { return boost::adl_move_swap_ranges(first, last, dest_begin); }

   template <class SourceIt, class DestinationIt>
   inline __attribute__ ((__always_inline__)) DestinationIt operator()(backward_t, SourceIt first, SourceIt last, DestinationIt dest_begin)
   { return boost::adl_move_swap_ranges_backward(first, last, dest_begin); }

   template <class SourceIt, class DestinationIt1, class DestinationIt2>
   inline __attribute__ ((__always_inline__)) void operator()(three_way_t, SourceIt srcit, DestinationIt1 dest1it, DestinationIt2 dest2it)
   {
      typename ::boost::movelib::iterator_traits<SourceIt>::value_type tmp(boost::move(*dest2it));
      *dest2it = boost::move(*dest1it);
      *dest1it = boost::move(*srcit);
      *srcit = boost::move(tmp);
   }

   template <class SourceIt, class DestinationIt1, class DestinationIt2>
   DestinationIt2 operator()(three_way_forward_t, SourceIt srcit, SourceIt srcitend, DestinationIt1 dest1it, DestinationIt2 dest2it)
   {
      while(srcit != srcitend){
         this->operator()(three_way_t(), srcit++, dest1it++, dest2it++);
      }
      return dest2it;
   }

   template <class SourceIt, class DestinationIt1, class DestinationIt2, class DestinationIt3>
   inline __attribute__ ((__always_inline__)) void operator()(four_way_t, SourceIt srcit, DestinationIt1 dest1it, DestinationIt2 dest2it, DestinationIt3 dest3it)
   {
      typename ::boost::movelib::iterator_traits<SourceIt>::value_type tmp(boost::move(*dest3it));
      *dest3it = boost::move(*dest2it);
      *dest2it = boost::move(*dest1it);
      *dest1it = boost::move(*srcit);
      *srcit = boost::move(tmp);
   }
};


}}
# 16 "/usr/include/boost/move/algo/detail/merge.hpp" 2 3 4

# 1 "/usr/include/boost/move/detail/destruct_n.hpp" 1 3 4
# 27 "/usr/include/boost/move/detail/destruct_n.hpp" 3 4
namespace boost {
namespace movelib{

template<class T, class RandItUninit>
class destruct_n
{
   public:
   explicit destruct_n(RandItUninit raw)
      : m_ptr(raw), m_size()
   {}

   void incr()
   {
      ++m_size;
   }

   void incr(std::size_t n)
   {
      m_size += n;
   }

   void release()
   {
      m_size = 0u;
   }

   ~destruct_n()
   {
      while(m_size--){
         m_ptr[m_size].~T();
      }
   }
   private:
   RandItUninit m_ptr;
   std::size_t m_size;
};

}}
# 18 "/usr/include/boost/move/algo/detail/merge.hpp" 2 3 4
# 1 "/usr/include/boost/move/algo/predicate.hpp" 1 3 4
# 19 "/usr/include/boost/move/algo/predicate.hpp" 3 4
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 1 3 4
# 42 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 3


# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 45 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 2 3
# 20 "/usr/include/boost/move/algo/predicate.hpp" 2 3 4

namespace boost {
namespace movelib {

template<class Comp>
struct antistable
{
   inline __attribute__ ((__always_inline__)) explicit antistable(Comp &comp)
      : m_comp(comp)
   {}

   inline __attribute__ ((__always_inline__)) antistable(const antistable & other)
      : m_comp(other.m_comp)
   {}

   template<class U, class V>
   inline __attribute__ ((__always_inline__)) bool operator()(const U &u, const V & v)
   { return !m_comp(v, u); }

   inline __attribute__ ((__always_inline__)) const Comp &get() const
   { return m_comp; }

   private:
   antistable & operator=(const antistable &);
   Comp &m_comp;
};

template<class Comp>
Comp unantistable(Comp comp)
{ return comp; }

template<class Comp>
Comp unantistable(antistable<Comp> comp)
{ return comp.get(); }

template <class Comp>
class negate
{
   public:
   inline __attribute__ ((__always_inline__)) negate()
   {}

   inline __attribute__ ((__always_inline__)) explicit negate(Comp comp)
      : m_comp(comp)
   {}

   template <class T1, class T2>
   inline __attribute__ ((__always_inline__)) bool operator()(const T1& l, const T2& r)
   {
      return !m_comp(l, r);
   }

   private:
   Comp m_comp;
};


template <class Comp>
class inverse
{
   public:
   inline __attribute__ ((__always_inline__)) inverse()
   {}

   inline __attribute__ ((__always_inline__)) explicit inverse(Comp comp)
      : m_comp(comp)
   {}

   template <class T1, class T2>
   inline __attribute__ ((__always_inline__)) bool operator()(const T1& l, const T2& r)
   {
      return m_comp(r, l);
   }

   private:
   Comp m_comp;
};

}
}
# 19 "/usr/include/boost/move/algo/detail/merge.hpp" 2 3 4
# 1 "/usr/include/boost/move/algo/detail/search.hpp" 1 3 4
# 17 "/usr/include/boost/move/algo/detail/search.hpp" 3 4
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wsign-conversion"


namespace boost {
namespace movelib {

template <class RandIt, class T, class Compare>
RandIt lower_bound
   (RandIt first, const RandIt last, const T& key, Compare comp)
{
   typedef typename iter_size<RandIt>::type size_type;
   size_type len = size_type(last - first);
   RandIt middle;

   while (len) {
      size_type step = size_type(len >> 1);
      middle = first;
      middle += step;

      if (comp(*middle, key)) {
         first = ++middle;
         len = size_type(len - (step + 1));
      }
      else{
         len = step;
      }
   }
   return first;
}

template <class RandIt, class T, class Compare>
RandIt upper_bound
   (RandIt first, const RandIt last, const T& key, Compare comp)
{
   typedef typename iter_size<RandIt>::type size_type;
   size_type len = size_type(last - first);
   RandIt middle;

   while (len) {
      size_type step = size_type(len >> 1);
      middle = first;
      middle += step;

      if (!comp(key, *middle)) {
         first = ++middle;
         len = size_type(len - (step + 1));
      }
      else{
         len = step;
      }
   }
   return first;
}

}
}


#pragma GCC diagnostic pop
# 20 "/usr/include/boost/move/algo/detail/merge.hpp" 2 3 4

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 1 3 4
# 42 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 3


# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 45 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 2 3
# 22 "/usr/include/boost/move/algo/detail/merge.hpp" 2 3 4



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wsign-conversion"


namespace boost {
namespace movelib {

template<class T, class RandRawIt = T*, class SizeType = typename iter_size<RandRawIt>::type>
class adaptive_xbuf
{
   adaptive_xbuf(const adaptive_xbuf &);
   adaptive_xbuf & operator=(const adaptive_xbuf &);





   public:
   typedef RandRawIt iterator;
   typedef SizeType size_type;

   inline __attribute__ ((__always_inline__)) adaptive_xbuf()
      : m_ptr(), m_size(0), m_capacity(0)
   {}

   inline __attribute__ ((__always_inline__)) adaptive_xbuf(RandRawIt raw_memory, size_type cap)
      : m_ptr(raw_memory), m_size(0), m_capacity(cap)
   {}

   template<class RandIt>
   void move_assign(RandIt first, size_type n)
   {
      typedef typename iterator_traits<RandIt>::difference_type rand_diff_t;
      if(n <= m_size){
         boost::move(first, first+rand_diff_t(n), m_ptr);
         size_type sz = m_size;
         while(sz-- != n){
            m_ptr[sz].~T();
         }
         m_size = n;
      }
      else{
         RandRawIt result = boost::move(first, first+rand_diff_t(m_size), m_ptr);
         boost::uninitialized_move(first+rand_diff_t(m_size), first+rand_diff_t(n), result);
         m_size = n;
      }
   }

   template<class RandIt>
   void push_back(RandIt first, size_type n)
   {
      (static_cast <bool> (m_capacity - m_size >= n) ? void (0) : __assert_fail ("m_capacity - m_size >= n", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      boost::uninitialized_move(first, first+n, m_ptr+m_size);
      m_size += n;
   }

   template<class RandIt>
   iterator add(RandIt it)
   {
      (static_cast <bool> (m_size < m_capacity) ? void (0) : __assert_fail ("m_size < m_capacity", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      RandRawIt p_ret = m_ptr + m_size;
      ::new(&*p_ret) T(::boost::move(*it));
      ++m_size;
      return p_ret;
   }

   template<class RandIt>
   void insert(iterator pos, RandIt it)
   {
      if(pos == (m_ptr + m_size)){
         this->add(it);
      }
      else{
         this->add(m_ptr+m_size-1);

         boost::move_backward(pos, m_ptr+m_size-2, m_ptr+m_size-1);
         *pos = boost::move(*it);
      }
   }

   inline __attribute__ ((__always_inline__)) void set_size(size_type sz)
   {
      m_size = sz;
   }

   void shrink_to_fit(size_type const sz)
   {
      if(m_size > sz){
         for(size_type szt_i = sz; szt_i != m_size; ++szt_i){
            m_ptr[szt_i].~T();
         }
         m_size = sz;
      }
   }

   void initialize_until(size_type const sz, T &t)
   {
      (static_cast <bool> (m_size < m_capacity) ? void (0) : __assert_fail ("m_size < m_capacity", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      if(m_size < sz){
         { try
         {
            ::new((void*)&m_ptr[m_size]) T(::boost::move(t));
            ++m_size;
            for(; m_size != sz; ++m_size){
               ::new((void*)&m_ptr[m_size]) T(::boost::move(m_ptr[m_size-1]));
            }
            t = ::boost::move(m_ptr[m_size-1]);
         }
         catch(...)
         {
            while(m_size)
            {
               --m_size;
               m_ptr[m_size].~T();
            }
         }
         }
      }
   }

   private:
   template<class RIt>
   inline __attribute__ ((__always_inline__)) static bool is_raw_ptr(RIt)
   {
      return false;
   }

   inline __attribute__ ((__always_inline__)) static bool is_raw_ptr(T*)
   {
      return true;
   }

   public:
   template<class U>
   bool supports_aligned_trailing(size_type sz, size_type trail_count) const
   {
      if(this->is_raw_ptr(this->data()) && m_capacity){
         uintptr_t u_addr_sz = uintptr_t(&*(this->data()+sz));
         uintptr_t u_addr_cp = uintptr_t(&*(this->data()+this->capacity()));
         u_addr_sz = ((u_addr_sz + sizeof(U)-1)/sizeof(U))*sizeof(U);
         return (u_addr_cp >= u_addr_sz) && ((u_addr_cp - u_addr_sz)/sizeof(U) >= trail_count);
      }
      return false;
   }

   template<class U>
   inline __attribute__ ((__always_inline__)) U *aligned_trailing() const
   {
      return this->aligned_trailing<U>(this->size());
   }

   template<class U>
   inline __attribute__ ((__always_inline__)) U *aligned_trailing(size_type pos) const
   {
      uintptr_t u_addr = uintptr_t(&*(this->data()+pos));
      u_addr = ((u_addr + sizeof(U)-1)/sizeof(U))*sizeof(U);
      return (U*)u_addr;
   }

   inline __attribute__ ((__always_inline__)) ~adaptive_xbuf()
   {
      this->clear();
   }

   inline __attribute__ ((__always_inline__)) size_type capacity() const
   { return m_capacity; }

   inline __attribute__ ((__always_inline__)) iterator data() const
   { return m_ptr; }

   inline __attribute__ ((__always_inline__)) iterator begin() const
   { return m_ptr; }

   inline __attribute__ ((__always_inline__)) iterator end() const
   { return m_ptr+m_size; }

   inline __attribute__ ((__always_inline__)) size_type size() const
   { return m_size; }

   inline __attribute__ ((__always_inline__)) bool empty() const
   { return !m_size; }

   inline __attribute__ ((__always_inline__)) void clear()
   {
      this->shrink_to_fit(0u);
   }

   private:
   RandRawIt m_ptr;
   size_type m_size;
   size_type m_capacity;
};

template<class Iterator, class SizeType, class Op>
class range_xbuf
{
   range_xbuf(const range_xbuf &);
   range_xbuf & operator=(const range_xbuf &);

   public:
   typedef SizeType size_type;
   typedef Iterator iterator;

   range_xbuf(Iterator first, Iterator last)
      : m_first(first), m_last(first), m_cap(last)
   {}

   template<class RandIt>
   void move_assign(RandIt first, size_type n)
   {
      (static_cast <bool> (size_type(n) <= size_type(m_cap-m_first)) ? void (0) : __assert_fail ("size_type(n) <= size_type(m_cap-m_first)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      typedef typename iter_difference<RandIt>::type d_type;
      m_last = Op()(forward_t(), first, first+d_type(n), m_first);
   }

   ~range_xbuf()
   {}

   size_type capacity() const
   { return m_cap-m_first; }

   Iterator data() const
   { return m_first; }

   Iterator end() const
   { return m_last; }

   size_type size() const
   { return m_last-m_first; }

   bool empty() const
   { return m_first == m_last; }

   void clear()
   {
      m_last = m_first;
   }

   template<class RandIt>
   iterator add(RandIt it)
   {
      Iterator pos(m_last);
      *pos = boost::move(*it);
      ++m_last;
      return pos;
   }

   void set_size(size_type sz)
   {
      m_last = m_first;
      m_last += sz;
   }

   private:
   Iterator const m_first;
   Iterator m_last;
   Iterator const m_cap;
};
# 308 "/usr/include/boost/move/algo/detail/merge.hpp" 3 4
template<typename Unsigned>
Unsigned gcd(Unsigned x, Unsigned y)
{
   if(0 == ((x &(x-1)) | (y & (y-1)))){
      return x < y ? x : y;
   }
   else{
      Unsigned z = 1;
      while((!(x&1)) & (!(y&1))){
         z = Unsigned(z << 1);
         x = Unsigned(x >> 1);
         y = Unsigned(y >> 1);
      }
      while(x && y){
         if(!(x&1))
            x = Unsigned(x >> 1);
         else if(!(y&1))
            y = Unsigned (y >> 1);
         else if(x >=y)
            x = Unsigned((x-y) >> 1u);
         else
            y = Unsigned((y-x) >> 1);
      }
      return Unsigned(z*(x+y));
   }
}

template<typename RandIt>
RandIt rotate_gcd(RandIt first, RandIt middle, RandIt last)
{
   typedef typename iter_size<RandIt>::type size_type;
   typedef typename iterator_traits<RandIt>::value_type value_type;

   if(first == middle)
      return last;
   if(middle == last)
      return first;
   const size_type middle_pos = size_type(middle - first);
   RandIt ret = last - middle_pos;
   if (middle == ret){
      boost::adl_move_swap_ranges(first, middle, middle);
   }
   else{
      const size_type length = size_type(last - first);
      for( RandIt it_i(first), it_gcd(it_i + gcd(length, middle_pos))
         ; it_i != it_gcd
         ; ++it_i){
         value_type temp(boost::move(*it_i));
         RandIt it_j = it_i;
         RandIt it_k = it_j+middle_pos;
         do{
            *it_j = boost::move(*it_k);
            it_j = it_k;
            size_type const left = size_type(last - it_j);
            it_k = left > middle_pos ? it_j + middle_pos : first + middle_pos - left;
         } while(it_k != it_i);
         *it_j = boost::move(temp);
      }
   }
   return ret;
}

template<class RandIt, class Compare, class Op>
void op_merge_left( RandIt buf_first
                    , RandIt first1
                    , RandIt const last1
                    , RandIt const last2
                    , Compare comp
                    , Op op)
{
   for(RandIt first2=last1; first2 != last2; ++buf_first){
      if(first1 == last1){
         op(forward_t(), first2, last2, buf_first);
         return;
      }
      else if(comp(*first2, *first1)){
         op(first2, buf_first);
         ++first2;
      }
      else{
         op(first1, buf_first);
         ++first1;
      }
   }
   if(buf_first != first1){


      op(forward_t(), first1, last1, buf_first);
   }
}





template<class RandIt, class Compare>
void merge_left
   (RandIt buf_first, RandIt first1, RandIt const last1, RandIt const last2, Compare comp)
{
   op_merge_left(buf_first, first1, last1, last2, comp, move_op());
}





template<class RandIt, class Compare>
void swap_merge_left
   (RandIt buf_first, RandIt first1, RandIt const last1, RandIt const last2, Compare comp)
{
   op_merge_left(buf_first, first1, last1, last2, comp, swap_op());
}

template<class RandIt, class Compare, class Op>
void op_merge_right
   (RandIt const first1, RandIt last1, RandIt last2, RandIt buf_last, Compare comp, Op op)
{
   RandIt const first2 = last1;
   while(first1 != last1){
      if(last2 == first2){
         op(backward_t(), first1, last1, buf_last);
         return;
      }
      --last2;
      --last1;
      --buf_last;
      if(comp(*last2, *last1)){
         op(last1, buf_last);
         ++last2;
      }
      else{
         op(last2, buf_last);
         ++last1;
      }
   }
   if(last2 != buf_last){


      op(backward_t(), first2, last2, buf_last);
   }
}




template<class RandIt, class Compare>
void merge_right
   (RandIt first1, RandIt last1, RandIt last2, RandIt buf_last, Compare comp)
{
   op_merge_right(first1, last1, last2, buf_last, comp, move_op());
}




template<class RandIt, class Compare>
void swap_merge_right
   (RandIt first1, RandIt last1, RandIt last2, RandIt buf_last, Compare comp)
{
   op_merge_right(first1, last1, last2, buf_last, comp, swap_op());
}






template<class RandIt, class Compare, class Op, class Buf>
void op_buffered_merge
      ( RandIt first, RandIt const middle, RandIt last
      , Compare comp, Op op
      , Buf &xbuf)
{
   if(first != middle && middle != last && comp(*middle, middle[-1])){
      typedef typename iter_size<RandIt>::type size_type;
      size_type const len1 = size_type(middle-first);
      size_type const len2 = size_type(last-middle);
      if(len1 <= len2){
         first = boost::movelib::upper_bound(first, middle, *middle, comp);
         xbuf.move_assign(first, size_type(middle-first));
         op_merge_with_right_placed
            (xbuf.data(), xbuf.end(), first, middle, last, comp, op);
      }
      else{
         last = boost::movelib::lower_bound(middle, last, middle[-1], comp);
         xbuf.move_assign(middle, size_type(last-middle));
         op_merge_with_left_placed
            (first, middle, last, xbuf.data(), xbuf.end(), comp, op);
      }
   }
}

template<class RandIt, class Compare, class XBuf>
void buffered_merge
      ( RandIt first, RandIt const middle, RandIt last
      , Compare comp
      , XBuf &xbuf)
{
   op_buffered_merge(first, middle, last, comp, move_op(), xbuf);
}


template<class RandIt, class Compare>
void merge_bufferless_ON2(RandIt first, RandIt middle, RandIt last, Compare comp)
{
   if((middle - first) < (last - middle)){
      while(first != middle){
         RandIt const old_last1 = middle;
         middle = boost::movelib::lower_bound(middle, last, *first, comp);
         first = rotate_gcd(first, old_last1, middle);
         if(middle == last){
            break;
         }
         do{
            ++first;
         } while(first != middle && !comp(*middle, *first));
      }
   }
   else{
      while(middle != last){
         RandIt p = boost::movelib::upper_bound(first, middle, last[-1], comp);
         last = rotate_gcd(p, middle, last);
         middle = p;
         if(middle == first){
            break;
         }
         --p;
         do{
            --last;
         } while(middle != last && !comp(last[-1], *p));
      }
   }
}

static const std::size_t MergeBufferlessONLogNRotationThreshold = 16u;

template <class RandIt, class Compare>
void merge_bufferless_ONlogN_recursive
   ( RandIt first, RandIt middle, RandIt last
   , typename iter_size<RandIt>::type len1
   , typename iter_size<RandIt>::type len2
   , Compare comp)
{
   typedef typename iter_size<RandIt>::type size_type;

   while(1) {

      if (!len2) {
         return;
      }
      else if (!len1) {
         return;
      }
      else if (size_type(len1 | len2) == 1u) {
         if (comp(*middle, *first))
            adl_move_swap(*first, *middle);
         return;
      }
      else if(size_type(len1+len2) < MergeBufferlessONLogNRotationThreshold){
         merge_bufferless_ON2(first, middle, last, comp);
         return;
      }

      RandIt first_cut = first;
      RandIt second_cut = middle;
      size_type len11 = 0;
      size_type len22 = 0;
      if (len1 > len2) {
         len11 = len1 / 2;
         first_cut += len11;
         second_cut = boost::movelib::lower_bound(middle, last, *first_cut, comp);
         len22 = size_type(second_cut - middle);
      }
      else {
         len22 = len2 / 2;
         second_cut += len22;
         first_cut = boost::movelib::upper_bound(first, middle, *second_cut, comp);
         len11 = size_type(first_cut - first);
      }
      RandIt new_middle = rotate_gcd(first_cut, middle, second_cut);


      const size_type len_internal = size_type(len11+len22);
      if( len_internal < (len1 + len2 - len_internal) ) {
         merge_bufferless_ONlogN_recursive(first, first_cut, new_middle, len11, len22, comp);
         first = new_middle;
         middle = second_cut;
         len1 = size_type(len1-len11);
         len2 = size_type(len2-len22);
      }
      else {
         merge_bufferless_ONlogN_recursive
            (new_middle, second_cut, last, size_type(len1 - len11), size_type(len2 - len22), comp);
         middle = first_cut;
         last = new_middle;
         len1 = len11;
         len2 = len22;
      }
   }
}



template<class RandIt, class Compare>
void merge_bufferless_ONlogN(RandIt first, RandIt middle, RandIt last, Compare comp)
{
   typedef typename iter_size<RandIt>::type size_type;
   merge_bufferless_ONlogN_recursive
      (first, middle, last, size_type(middle - first), size_type(last - middle), comp);
}

template<class RandIt, class Compare>
void merge_bufferless(RandIt first, RandIt middle, RandIt last, Compare comp)
{


   merge_bufferless_ONlogN(first, middle, last, comp);



}


template <class Compare, class InputIterator, class InputOutIterator, class Op>
void op_merge_with_right_placed
   ( InputIterator first, InputIterator last
   , InputOutIterator dest_first, InputOutIterator r_first, InputOutIterator r_last
   , Compare comp, Op op)
{
   (static_cast <bool> ((last - first) == (r_first - dest_first)) ? void (0) : __assert_fail ("(last - first) == (r_first - dest_first)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
   while ( first != last ) {
      if (r_first == r_last) {
         InputOutIterator end = op(forward_t(), first, last, dest_first);
         (static_cast <bool> (end == r_last) ? void (0) : __assert_fail ("end == r_last", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
         boost::movelib::ignore(end);
         return;
      }
      else if (comp(*r_first, *first)) {
         op(r_first, dest_first);
         ++r_first;
      }
      else {
         op(first, dest_first);
         ++first;
      }
      ++dest_first;
   }

}

template <class Compare, class InputIterator, class InputOutIterator>
void swap_merge_with_right_placed
   ( InputIterator first, InputIterator last
   , InputOutIterator dest_first, InputOutIterator r_first, InputOutIterator r_last
   , Compare comp)
{
   op_merge_with_right_placed(first, last, dest_first, r_first, r_last, comp, swap_op());
}


template <class Compare, class Op, class BidirIterator, class BidirOutIterator>
void op_merge_with_left_placed
   ( BidirOutIterator const first, BidirOutIterator last, BidirOutIterator dest_last
   , BidirIterator const r_first, BidirIterator r_last
   , Compare comp, Op op)
{
   (static_cast <bool> ((dest_last - last) == (r_last - r_first)) ? void (0) : __assert_fail ("(dest_last - last) == (r_last - r_first)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
   while( r_first != r_last ) {
      if(first == last) {
         BidirOutIterator res = op(backward_t(), r_first, r_last, dest_last);
         (static_cast <bool> (last == res) ? void (0) : __assert_fail ("last == res", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
         boost::movelib::ignore(res);
         return;
      }
      --r_last;
      --last;
      if(comp(*r_last, *last)){
         ++r_last;
         --dest_last;
         op(last, dest_last);
      }
      else{
         ++last;
         --dest_last;
         op(r_last, dest_last);
      }
   }

}




template <class Compare, class BidirIterator, class BidirOutIterator>
void merge_with_left_placed
   ( BidirOutIterator const first, BidirOutIterator last, BidirOutIterator dest_last
   , BidirIterator const r_first, BidirIterator r_last
   , Compare comp)
{
   op_merge_with_left_placed(first, last, dest_last, r_first, r_last, comp, move_op());
}


template <class Compare, class InputIterator, class InputOutIterator>
void merge_with_right_placed
   ( InputIterator first, InputIterator last
   , InputOutIterator dest_first, InputOutIterator r_first, InputOutIterator r_last
   , Compare comp)
{
   op_merge_with_right_placed(first, last, dest_first, r_first, r_last, comp, move_op());
}



template <class Compare, class InputIterator, class InputOutIterator>
void uninitialized_merge_with_right_placed
   ( InputIterator first, InputIterator last
   , InputOutIterator dest_first, InputOutIterator r_first, InputOutIterator r_last
   , Compare comp)
{
   (static_cast <bool> ((last - first) == (r_first - dest_first)) ? void (0) : __assert_fail ("(last - first) == (r_first - dest_first)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
   typedef typename iterator_traits<InputOutIterator>::value_type value_type;
   InputOutIterator const original_r_first = r_first;

   destruct_n<value_type, InputOutIterator> d(dest_first);

   while ( first != last && dest_first != original_r_first ) {
      if (r_first == r_last) {
         for(; dest_first != original_r_first; ++dest_first, ++first){
            ::new((iterator_to_raw_pointer)(dest_first)) value_type(::boost::move(*first));
            d.incr();
         }
         d.release();
         InputOutIterator end = ::boost::move(first, last, original_r_first);
         (static_cast <bool> (end == r_last) ? void (0) : __assert_fail ("end == r_last", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
         boost::movelib::ignore(end);
         return;
      }
      else if (comp(*r_first, *first)) {
         ::new((iterator_to_raw_pointer)(dest_first)) value_type(::boost::move(*r_first));
         d.incr();
         ++r_first;
      }
      else {
         ::new((iterator_to_raw_pointer)(dest_first)) value_type(::boost::move(*first));
         d.incr();
         ++first;
      }
      ++dest_first;
   }
   d.release();
   merge_with_right_placed(first, last, original_r_first, r_first, r_last, comp);
}


template<typename BidirectionalIterator1, typename BidirectionalIterator2>
   BidirectionalIterator1
   rotate_adaptive(BidirectionalIterator1 first,
      BidirectionalIterator1 middle,
      BidirectionalIterator1 last,
      typename iter_size<BidirectionalIterator1>::type len1,
      typename iter_size<BidirectionalIterator1>::type len2,
      BidirectionalIterator2 buffer,
      typename iter_size<BidirectionalIterator1>::type buffer_size)
{
   if (len1 > len2 && len2 <= buffer_size)
   {
      if(len2)
      {
         BidirectionalIterator2 buffer_end = boost::move(middle, last, buffer);
         boost::move_backward(first, middle, last);
         return boost::move(buffer, buffer_end, first);
      }
      else
         return first;
   }
   else if (len1 <= buffer_size)
   {
      if(len1)
      {
         BidirectionalIterator2 buffer_end = boost::move(first, middle, buffer);
         BidirectionalIterator1 ret = boost::move(middle, last, first);
         boost::move(buffer, buffer_end, ret);
         return ret;
      }
      else
         return last;
   }
   else
      return rotate_gcd(first, middle, last);
}

template<typename BidirectionalIterator,
   typename Pointer, typename Compare>
   void merge_adaptive_ONlogN_recursive
   (BidirectionalIterator first,
      BidirectionalIterator middle,
      BidirectionalIterator last,
      typename iter_size<BidirectionalIterator>::type len1,
      typename iter_size<BidirectionalIterator>::type len2,
      Pointer buffer,
      typename iter_size<BidirectionalIterator>::type buffer_size,
      Compare comp)
{
   typedef typename iter_size<BidirectionalIterator>::type size_type;

   if (!len2 || !len1) {

   }
   else if (len1 <= buffer_size || len2 <= buffer_size) {
      range_xbuf<Pointer, size_type, move_op> rxbuf(buffer, buffer + buffer_size);
      buffered_merge(first, middle, last, comp, rxbuf);
   }
   else if (size_type(len1 + len2) == 2u) {
      if (comp(*middle, *first))
         adl_move_swap(*first, *middle);
   }
   else if (size_type(len1 + len2) < MergeBufferlessONLogNRotationThreshold) {
      merge_bufferless_ON2(first, middle, last, comp);
   }
   else {
      BidirectionalIterator first_cut = first;
      BidirectionalIterator second_cut = middle;
      size_type len11 = 0;
      size_type len22 = 0;
      if (len1 > len2)
      {
         len11 = len1 / 2;
         first_cut += len11;
         second_cut = boost::movelib::lower_bound(middle, last, *first_cut, comp);
         len22 = size_type(second_cut - middle);
      }
      else
      {
         len22 = len2 / 2;
         second_cut += len22;
         first_cut = boost::movelib::upper_bound(first, middle, *second_cut, comp);
         len11 = size_type(first_cut - first);
      }

      BidirectionalIterator new_middle
         = rotate_adaptive(first_cut, middle, second_cut,
            size_type(len1 - len11), len22, buffer,
            buffer_size);
      merge_adaptive_ONlogN_recursive(first, first_cut, new_middle, len11,
         len22, buffer, buffer_size, comp);
      merge_adaptive_ONlogN_recursive(new_middle, second_cut, last,
         size_type(len1 - len11), size_type(len2 - len22), buffer, buffer_size, comp);
   }
}


template<typename BidirectionalIterator, typename Compare, typename RandRawIt>
void merge_adaptive_ONlogN(BidirectionalIterator first,
                       BidirectionalIterator middle,
                       BidirectionalIterator last,
                       Compare comp,
                           RandRawIt uninitialized,
                           typename iter_size<BidirectionalIterator>::type uninitialized_len)
{
   typedef typename iterator_traits<BidirectionalIterator>::value_type value_type;
   typedef typename iter_size<BidirectionalIterator>::type size_type;

   if (first == middle || middle == last)
      return;

   if(uninitialized_len)
   {
      const size_type len1 = size_type(middle - first);
      const size_type len2 = size_type(last - middle);

      ::boost::movelib::adaptive_xbuf<value_type, RandRawIt> xbuf(uninitialized, uninitialized_len);
      xbuf.initialize_until(uninitialized_len, *first);
    merge_adaptive_ONlogN_recursive(first, middle, last, len1, len2, xbuf.begin(), uninitialized_len, comp);
   }
   else
   {
      merge_bufferless(first, middle, last, comp);
   }
}

}
}


#pragma GCC diagnostic pop
# 50 "/usr/include/boost/move/algo/detail/adaptive_sort_merge.hpp" 2 3 4

# 1 "/usr/include/boost/move/algo/detail/insertion_sort.hpp" 1 3 4
# 37 "/usr/include/boost/move/algo/detail/insertion_sort.hpp" 3 4
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wsign-conversion"


namespace boost { namespace movelib{



template <class Compare, class ForwardIterator, class BirdirectionalIterator, class Op>
void insertion_sort_op(ForwardIterator first1, ForwardIterator last1, BirdirectionalIterator first2, Compare comp, Op op)
{
   if (first1 != last1){
      BirdirectionalIterator last2 = first2;
      op(first1, last2);
      for (++last2; ++first1 != last1; ++last2){
         BirdirectionalIterator j2 = last2;
         BirdirectionalIterator i2 = j2;
         if (comp(*first1, *--i2)){
            op(i2, j2);
            for (--j2; i2 != first2 && comp(*first1, *--i2); --j2) {
               op(i2, j2);
            }
         }
         op(first1, j2);
      }
   }
}

template <class Compare, class ForwardIterator, class BirdirectionalIterator>
void insertion_sort_swap(ForwardIterator first1, ForwardIterator last1, BirdirectionalIterator first2, Compare comp)
{
   insertion_sort_op(first1, last1, first2, comp, swap_op());
}


template <class Compare, class ForwardIterator, class BirdirectionalIterator>
void insertion_sort_copy(ForwardIterator first1, ForwardIterator last1, BirdirectionalIterator first2, Compare comp)
{
   insertion_sort_op(first1, last1, first2, comp, move_op());
}



template <class Compare, class BirdirectionalIterator>
void insertion_sort(BirdirectionalIterator first, BirdirectionalIterator last, Compare comp)
{
   typedef typename boost::movelib::iterator_traits<BirdirectionalIterator>::value_type value_type;
   if (first != last){
      BirdirectionalIterator i = first;
      for (++i; i != last; ++i){
         BirdirectionalIterator j = i;
         if (comp(*i, *--j)) {
            value_type tmp(::boost::move(*i));
            *i = ::boost::move(*j);
            for (BirdirectionalIterator k = j; k != first && comp(tmp, *--k); --j) {
               *j = ::boost::move(*k);
            }
            *j = ::boost::move(tmp);
         }
      }
   }
}

template <class Compare, class BirdirectionalIterator, class BirdirectionalRawIterator>
void insertion_sort_uninitialized_copy
   (BirdirectionalIterator first1, BirdirectionalIterator const last1
   , BirdirectionalRawIterator const first2
   , Compare comp)
{
   typedef typename iterator_traits<BirdirectionalIterator>::value_type value_type;
   if (first1 != last1){
      BirdirectionalRawIterator last2 = first2;
      ::new((iterator_to_raw_pointer)(last2), boost_move_new_t()) value_type(::boost::move(*first1));
      destruct_n<value_type, BirdirectionalRawIterator> d(first2);
      d.incr();
      for (++last2; ++first1 != last1; ++last2){
         BirdirectionalRawIterator j2 = last2;
         BirdirectionalRawIterator k2 = j2;
         if (comp(*first1, *--k2)){
            ::new((iterator_to_raw_pointer)(j2), boost_move_new_t()) value_type(::boost::move(*k2));
            d.incr();
            for (--j2; k2 != first2 && comp(*first1, *--k2); --j2)
               *j2 = ::boost::move(*k2);
            *j2 = ::boost::move(*first1);
         }
         else{
            ::new((iterator_to_raw_pointer)(j2), boost_move_new_t()) value_type(::boost::move(*first1));
            d.incr();
         }
      }
      d.release();
   }
}

}}


#pragma GCC diagnostic pop
# 52 "/usr/include/boost/move/algo/detail/adaptive_sort_merge.hpp" 2 3 4
# 1 "/usr/include/boost/move/algo/detail/merge_sort.hpp" 1 3 4
# 25 "/usr/include/boost/move/algo/detail/merge_sort.hpp" 3 4
# 1 "/usr/include/boost/move/detail/config_begin.hpp" 1 3 4
# 26 "/usr/include/boost/move/algo/detail/merge_sort.hpp" 2 3 4
# 35 "/usr/include/boost/move/algo/detail/merge_sort.hpp" 3 4
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 1 3 4
# 42 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 3


# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 45 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 2 3
# 36 "/usr/include/boost/move/algo/detail/merge_sort.hpp" 2 3 4


#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wsign-conversion"


namespace boost {
namespace movelib {



static const unsigned MergeSortInsertionSortThreshold = 16;

template <class RandIt, class Compare>
void inplace_stable_sort(RandIt first, RandIt last, Compare comp)
{
   typedef typename iter_size<RandIt>::type size_type;
   if (size_type(last - first) <= size_type(MergeSortInsertionSortThreshold)) {
      insertion_sort(first, last, comp);
      return;
   }
   RandIt middle = first + (last - first) / 2;
   inplace_stable_sort(first, middle, comp);
   inplace_stable_sort(middle, last, comp);
   merge_bufferless_ONlogN_recursive
      (first, middle, last, size_type(middle - first), size_type(last - middle), comp);
}



template<class RandIt, class RandIt2, class Compare>
void merge_sort_copy( RandIt first, RandIt last
                   , RandIt2 dest, Compare comp)
{
   typedef typename iter_size<RandIt>::type size_type;

   size_type const count = size_type(last - first);
   if(count <= MergeSortInsertionSortThreshold){
      insertion_sort_copy(first, last, dest, comp);
   }
   else{
      size_type const half = size_type(count/2u);
      merge_sort_copy(first + half, last , dest+half , comp);
      merge_sort_copy(first , first + half, first + half, comp);
      merge_with_right_placed
         ( first + half, first + half + half
         , dest, dest+half, dest + count
         , comp);
   }
}

template<class RandIt, class RandItRaw, class Compare>
void merge_sort_uninitialized_copy( RandIt first, RandIt last
                                 , RandItRaw uninitialized
                                 , Compare comp)
{
   typedef typename iter_size<RandIt>::type size_type;
   typedef typename iterator_traits<RandIt>::value_type value_type;

   size_type const count = size_type(last - first);
   if(count <= MergeSortInsertionSortThreshold){
      insertion_sort_uninitialized_copy(first, last, uninitialized, comp);
   }
   else{
      size_type const half = count/2;
      merge_sort_uninitialized_copy(first + half, last, uninitialized + half, comp);
      destruct_n<value_type, RandItRaw> d(uninitialized+half);
      d.incr(size_type(count-half));
      merge_sort_copy(first, first + half, first + half, comp);
      uninitialized_merge_with_right_placed
         ( first + half, first + half + half
         , uninitialized, uninitialized+half, uninitialized+count
         , comp);
      d.release();
   }
}

template<class RandIt, class RandItRaw, class Compare>
void merge_sort( RandIt first, RandIt last, Compare comp
               , RandItRaw uninitialized)
{
   typedef typename iter_size<RandIt>::type size_type;
   typedef typename iterator_traits<RandIt>::value_type value_type;

   size_type const count = size_type(last - first);
   if(count <= MergeSortInsertionSortThreshold){
      insertion_sort(first, last, comp);
   }
   else{
      size_type const half = size_type(count/2u);
      size_type const rest = size_type(count - half);
      RandIt const half_it = first + half;
      RandIt const rest_it = first + rest;

      merge_sort_uninitialized_copy(half_it, last, uninitialized, comp);
      destruct_n<value_type, RandItRaw> d(uninitialized);
      d.incr(rest);
      merge_sort_copy(first, half_it, rest_it, comp);
      merge_with_right_placed
         ( uninitialized, uninitialized + rest
         , first, rest_it, last, antistable<Compare>(comp));
   }
}



template<class RandIt, class RandItRaw, class Compare>
void merge_sort_with_constructed_buffer( RandIt first, RandIt last, Compare comp, RandItRaw buffer)
{
   typedef typename iter_size<RandIt>::type size_type;

   size_type const count = size_type(last - first);
   if(count <= MergeSortInsertionSortThreshold){
      insertion_sort(first, last, comp);
   }
   else{
      size_type const half = size_type(count/2);
      size_type const rest = size_type(count - half);
      RandIt const half_it = first + half;
      RandIt const rest_it = first + rest;

      merge_sort_copy(half_it, last, buffer, comp);
      merge_sort_copy(first, half_it, rest_it, comp);
      merge_with_right_placed
         (buffer, buffer + rest
         , first, rest_it, last, antistable<Compare>(comp));
   }
}

template<typename RandIt, typename Pointer,
         typename Distance, typename Compare>
void stable_sort_ONlogN_recursive(RandIt first, RandIt last, Pointer buffer, Distance buffer_size, Compare comp)
{
   typedef typename iter_size<RandIt>::type size_type;
   if (size_type(last - first) <= size_type(MergeSortInsertionSortThreshold)) {
      insertion_sort(first, last, comp);
   }
   else {
      const size_type len = size_type(last - first) / 2u;
      const RandIt middle = first + len;
      if (len > ((buffer_size+1)/2)){
         stable_sort_ONlogN_recursive(first, middle, buffer, buffer_size, comp);
         stable_sort_ONlogN_recursive(middle, last, buffer, buffer_size, comp);
      }
      else{
         merge_sort_with_constructed_buffer(first, middle, comp, buffer);
         merge_sort_with_constructed_buffer(middle, last, comp, buffer);
      }
      merge_adaptive_ONlogN_recursive(first, middle, last,
         size_type(middle - first),
         size_type(last - middle),
         buffer, buffer_size,
         comp);
   }
}

template<typename BidirectionalIterator, typename Compare, typename RandRawIt>
void stable_sort_adaptive_ONlogN2(BidirectionalIterator first,
                             BidirectionalIterator last,
                             Compare comp,
                                 RandRawIt uninitialized,
                                 std::size_t uninitialized_len)
{
   typedef typename iterator_traits<BidirectionalIterator>::value_type value_type;

   ::boost::movelib::adaptive_xbuf<value_type, RandRawIt> xbuf(uninitialized, uninitialized_len);
   xbuf.initialize_until(uninitialized_len, *first);
   stable_sort_ONlogN_recursive(first, last, uninitialized, uninitialized_len, comp);
}



}}


#pragma GCC diagnostic pop


# 1 "/usr/include/boost/move/detail/config_end.hpp" 1 3 4
# 215 "/usr/include/boost/move/algo/detail/merge_sort.hpp" 2 3 4
# 53 "/usr/include/boost/move/algo/detail/adaptive_sort_merge.hpp" 2 3 4
# 1 "/usr/include/boost/move/algo/detail/heap_sort.hpp" 1 3 4
# 25 "/usr/include/boost/move/algo/detail/heap_sort.hpp" 3 4
# 1 "/usr/include/boost/move/detail/config_begin.hpp" 1 3 4
# 26 "/usr/include/boost/move/algo/detail/heap_sort.hpp" 2 3 4



# 1 "/usr/include/boost/move/algo/detail/is_sorted.hpp" 1 3 4
# 21 "/usr/include/boost/move/algo/detail/is_sorted.hpp" 3 4
namespace boost {
namespace movelib {

template<class ForwardIt, class Pred>
bool is_sorted(ForwardIt const first, ForwardIt last, Pred pred)
{
   if (first != last) {
      ForwardIt next = first, cur(first);
      while (++next != last) {
         if (pred(*next, *cur))
            return false;
         cur = next;
      }
   }
   return true;
}

template<class ForwardIt, class Pred>
bool is_sorted_and_unique(ForwardIt first, ForwardIt last, Pred pred)
{
   if (first != last) {
      ForwardIt next = first;
      while (++next != last) {
         if (!pred(*first, *next))
            return false;
         first = next;
      }
   }
   return true;
}

}
}
# 30 "/usr/include/boost/move/algo/detail/heap_sort.hpp" 2 3 4

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 1 3 4
# 42 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 3


# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 45 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 2 3
# 32 "/usr/include/boost/move/algo/detail/heap_sort.hpp" 2 3 4


#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wsign-conversion"


namespace boost { namespace movelib{

template <class RandomAccessIterator, class Compare>
class heap_sort_helper
{
   typedef typename boost::movelib::iter_size<RandomAccessIterator>::type size_type;
   typedef typename boost::movelib::iterator_traits<RandomAccessIterator>::value_type value_type;

   static void adjust_heap(RandomAccessIterator first, size_type hole_index, size_type const len, value_type &value, Compare comp)
   {
      size_type const top_index = hole_index;
      size_type second_child = size_type(2u*(hole_index + 1u));

      while (second_child < len) {
         if (comp(*(first + second_child), *(first + size_type(second_child - 1u))))
            second_child--;
         *(first + hole_index) = boost::move(*(first + second_child));
         hole_index = second_child;
         second_child = size_type(2u * (second_child + 1u));
      }
      if (second_child == len) {
         *(first + hole_index) = boost::move(*(first + size_type(second_child - 1u)));
         hole_index = size_type(second_child - 1);
      }

      {
         size_type parent = size_type((hole_index - 1u) / 2u);
         while (hole_index > top_index && comp(*(first + parent), value)) {
            *(first + hole_index) = boost::move(*(first + parent));
            hole_index = parent;
            parent = size_type((hole_index - 1u) / 2u);
         }
         *(first + hole_index) = boost::move(value);
      }
   }

   static void make_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp)
   {
      size_type const len = size_type(last - first);
      if (len > 1) {
         size_type parent = size_type(len/2u - 1u);

         do {
            value_type v(boost::move(*(first + parent)));
            adjust_heap(first, parent, len, v, comp);
         }while (parent--);
      }
   }

   static void sort_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp)
   {
      size_type len = size_type(last - first);
      while (len > 1) {

         --last;
         value_type v(boost::move(*last));
         *last = boost::move(*first);
         adjust_heap(first, size_type(0), --len, v, comp);
      }
   }

   public:
   static void sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp)
   {
      make_heap(first, last, comp);
      sort_heap(first, last, comp);
      (static_cast <bool> (boost::movelib::is_sorted(first, last, comp)) ? void (0) : __assert_fail ("boost::movelib::is_sorted(first, last, comp)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
   }
};

template <class RandomAccessIterator, class Compare>
inline __attribute__ ((__always_inline__)) void heap_sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp)
{
   heap_sort_helper<RandomAccessIterator, Compare>::sort(first, last, comp);
}

}}


#pragma GCC diagnostic pop


# 1 "/usr/include/boost/move/detail/config_end.hpp" 1 3 4
# 121 "/usr/include/boost/move/algo/detail/heap_sort.hpp" 2 3 4
# 54 "/usr/include/boost/move/algo/detail/adaptive_sort_merge.hpp" 2 3 4


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 1 3 4
# 42 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 3


# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 45 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 2 3
# 57 "/usr/include/boost/move/algo/detail/adaptive_sort_merge.hpp" 2 3 4
# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 58 "/usr/include/boost/move/algo/detail/adaptive_sort_merge.hpp" 2 3 4



#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wsign-conversion"
# 96 "/usr/include/boost/move/algo/detail/adaptive_sort_merge.hpp" 3 4
namespace boost {
namespace movelib {
# 116 "/usr/include/boost/move/algo/detail/adaptive_sort_merge.hpp" 3 4
namespace detail_adaptive {

static const std::size_t AdaptiveSortInsertionSortThreshold = 16;

static_assert((AdaptiveSortInsertionSortThreshold&(AdaptiveSortInsertionSortThreshold-1)) == 0, "(AdaptiveSortInsertionSortThreshold&(AdaptiveSortInsertionSortThreshold-1)) == 0");


   typedef ::boost::uintptr_t uintptr_t;




template<class T>
const T &min_value(const T &a, const T &b)
{
   return a < b ? a : b;
}

template<class T>
const T &max_value(const T &a, const T &b)
{
   return a > b ? a : b;
}

template<class ForwardIt, class Pred, class V>
typename iter_size<ForwardIt>::type
   count_if_with(ForwardIt first, ForwardIt last, Pred pred, const V &v)
{
   typedef typename iter_size<ForwardIt>::type size_type;
   size_type count = 0;
   while(first != last) {
      count = size_type(count + static_cast<size_type>(0 != pred(*first, v)));
      ++first;
   }
   return count;
}


template<class RandIt, class Compare>
RandIt skip_until_merge
   ( RandIt first1, RandIt const last1
   , const typename iterator_traits<RandIt>::value_type &next_key, Compare comp)
{
   while(first1 != last1 && !comp(next_key, *first1)){
      ++first1;
   }
   return first1;
}


template<class RandItKeys, class RandIt>
void swap_and_update_key
   ( RandItKeys const key_next
   , RandItKeys const key_range2
   , RandItKeys &key_mid
   , RandIt const begin
   , RandIt const end
   , RandIt const with)
{
   if(begin != with){
      ::boost::adl_move_swap_ranges(begin, end, with);
      if(key_next != key_range2)
         ::boost::adl_move_swap(*key_next, *key_range2);
      if(key_next == key_mid){
         key_mid = key_range2;
      }
      else if(key_mid == key_range2){
         key_mid = key_next;
      }
   }
}

template<class RandItKeys>
void update_key
(RandItKeys const key_next
   , RandItKeys const key_range2
   , RandItKeys &key_mid)
{
   if (key_next != key_range2) {
      ::boost::adl_move_swap(*key_next, *key_range2);
      if (key_next == key_mid) {
         key_mid = key_range2;
      }
      else if (key_mid == key_range2) {
         key_mid = key_next;
      }
   }
}

template<class RandItKeys, class RandIt, class RandIt2, class Op>
RandIt2 buffer_and_update_key
(RandItKeys const key_next
   , RandItKeys const key_range2
   , RandItKeys &key_mid
   , RandIt begin
   , RandIt end
   , RandIt with
   , RandIt2 buffer
   , Op op)
{
   if (begin != with) {
      while(begin != end) {
         op(three_way_t(), begin++, with++, buffer++);
      }
      if (key_next != key_range2)
         ::boost::adl_move_swap(*key_next, *key_range2);
      if (key_next == key_mid) {
         key_mid = key_range2;
      }
      else if (key_mid == key_range2) {
         key_mid = key_next;
      }
   }
   return buffer;
}
# 239 "/usr/include/boost/move/algo/detail/adaptive_sort_merge.hpp" 3 4
template<class RandIt, class Compare>
RandIt partial_merge_bufferless_impl
   (RandIt first1, RandIt last1, RandIt const last2, bool *const pis_range1_A, Compare comp)
{
   if(last1 == last2){
      return first1;
   }
   bool const is_range1_A = *pis_range1_A;
   if(first1 != last1 && comp(*last1, last1[-1])){
      do{
         RandIt const old_last1 = last1;
         last1 = boost::movelib::lower_bound(last1, last2, *first1, comp);
         first1 = rotate_gcd(first1, old_last1, last1);
         if(last1 == last2){
            return first1;
         }
         do{
            ++first1;
         } while(last1 != first1 && !comp(*last1, *first1) );
      } while(first1 != last1);
   }
   *pis_range1_A = !is_range1_A;
   return last1;
}


template<class RandIt, class Compare>
RandIt partial_merge_bufferless
   (RandIt first1, RandIt last1, RandIt const last2, bool *const pis_range1_A, Compare comp)
{
   return *pis_range1_A ? partial_merge_bufferless_impl(first1, last1, last2, pis_range1_A, comp)
                        : partial_merge_bufferless_impl(first1, last1, last2, pis_range1_A, antistable<Compare>(comp));
}

template<class SizeType>
static SizeType needed_keys_count(SizeType n_block_a, SizeType n_block_b)
{
   return SizeType(n_block_a + n_block_b);
}

template<class RandItKeys, class KeyCompare, class RandIt, class Compare>
typename iter_size<RandIt>::type
   find_next_block
      ( RandItKeys const key_first
      , KeyCompare key_comp
      , RandIt const first
      , typename iter_size<RandIt>::type const l_block
      , typename iter_size<RandIt>::type const ix_first_block
      , typename iter_size<RandIt>::type const ix_last_block
      , Compare comp)
{
   typedef typename iter_size<RandIt>::type size_type;
   typedef typename iterator_traits<RandIt>::value_type value_type;
   typedef typename iterator_traits<RandItKeys>::value_type key_type;
   (static_cast <bool> (ix_first_block <= ix_last_block) ? void (0) : __assert_fail ("ix_first_block <= ix_last_block", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
   size_type ix_min_block = 0u;
   for (size_type szt_i = ix_first_block; szt_i < ix_last_block; ++szt_i) {
      const value_type &min_val = first[size_type(ix_min_block*l_block)];
      const value_type &cur_val = first[size_type(szt_i*l_block)];
      const key_type &min_key = key_first[ix_min_block];
      const key_type &cur_key = key_first[szt_i];

      bool const less_than_minimum = comp(cur_val, min_val) ||
         (!comp(min_val, cur_val) && key_comp(cur_key, min_key));

      if (less_than_minimum) {
         ix_min_block = szt_i;
      }
   }
   return ix_min_block;
}

template<class RandItKeys, class KeyCompare, class RandIt, class Compare>
void merge_blocks_bufferless
   ( RandItKeys const key_first
   , KeyCompare key_comp
   , RandIt const first
   , typename iter_size<RandIt>::type const l_block
   , typename iter_size<RandIt>::type const l_irreg1
   , typename iter_size<RandIt>::type const n_block_a
   , typename iter_size<RandIt>::type const n_block_b
   , typename iter_size<RandIt>::type const l_irreg2
   , Compare comp)
{
   typedef typename iter_size<RandIt>::type size_type;
   size_type const key_count = needed_keys_count(n_block_a, n_block_b);
   ::boost::movelib::ignore(key_count);

                                                                                                                       ;
                                                                                                                                                 ;

   size_type n_bef_irreg2 = 0;
   bool l_irreg_pos_count = true;
   RandItKeys key_mid(key_first + n_block_a);
   RandIt const first_irr2 = first + size_type(l_irreg1 + (n_block_a+n_block_b)*l_block);
   RandIt const last_irr2 = first_irr2 + l_irreg2;

   {
      size_type n_block_left = size_type(n_block_b + n_block_a);
      RandItKeys key_range2(key_first);

      size_type min_check = n_block_a == n_block_left ? 0u : n_block_a;
      size_type max_check = min_value<size_type>(size_type(min_check+1), n_block_left);
      for ( RandIt f = first+l_irreg1; n_block_left; --n_block_left) {
         size_type const next_key_idx = find_next_block(key_range2, key_comp, f, l_block, min_check, max_check, comp);
         RandItKeys const key_next(key_range2 + next_key_idx);
         max_check = min_value<size_type>(max_value<size_type>(max_check, size_type(next_key_idx+2)), n_block_left);

         RandIt const first_min = f + size_type(next_key_idx*l_block);



         if (l_irreg_pos_count && l_irreg2 && comp(*first_irr2, *first_min)){
            l_irreg_pos_count = false;
         }
         n_bef_irreg2 = size_type(n_bef_irreg2+l_irreg_pos_count);

         swap_and_update_key(key_next, key_range2, key_mid, f, f + l_block, first_min);
                                                                                          ;
                                                                                                            ;
                                                                                               ;

         ++key_range2;
         f += l_block;
         min_check = size_type(min_check - (min_check != 0));
         max_check = size_type(max_check - (max_check != 0));
      }
   }
                                                                                                                       ;

   RandIt first1 = first;
   RandIt last1 = first+l_irreg1;
   RandItKeys const key_end (key_first+n_bef_irreg2);
   bool is_range1_A = true;

   for(RandItKeys key_next = key_first; key_next != key_end; ++key_next){
      bool is_range2_A = key_mid == (key_first+key_count) || key_comp(*key_next, *key_mid);
      first1 = is_range1_A == is_range2_A
         ? last1 : partial_merge_bufferless(first1, last1, last1 + l_block, &is_range1_A, comp);
      last1 += l_block;
                                                                                        ;
   }

   merge_bufferless(is_range1_A ? first1 : last1, first_irr2, last_irr2, comp);
                                                                                        ;
}







template<class RandIt, class Compare, class XBuf>
typename iter_size<RandIt>::type
   collect_unique
      ( RandIt const first, RandIt const last
      , typename iter_size<RandIt>::type const max_collected, Compare comp
      , XBuf & xbuf)
{
   typedef typename iter_size<RandIt>::type size_type;
   size_type h = 0;

   if(max_collected){
      ++h;
      RandIt h0 = first;
      RandIt u = first; ++u;
      RandIt search_end = u;

      if(xbuf.capacity() >= max_collected){
         typename XBuf::iterator const ph0 = xbuf.add(first);
         while(u != last && h < max_collected){
            typename XBuf::iterator const r = boost::movelib::lower_bound(ph0, xbuf.end(), *u, comp);

            if(r == xbuf.end() || comp(*u, *r) ){
               RandIt const new_h0 = boost::move(search_end, u, h0);
               search_end = u;
               ++search_end;
               ++h;
               xbuf.insert(r, u);
               h0 = new_h0;
            }
            ++u;
         }
         boost::move_backward(first, h0, h0+h);
         boost::move(xbuf.data(), xbuf.end(), first);
      }
      else{
         while(u != last && h < max_collected){
            RandIt const r = boost::movelib::lower_bound(h0, search_end, *u, comp);

            if(r == search_end || comp(*u, *r) ){
               RandIt const new_h0 = rotate_gcd(h0, search_end, u);
               search_end = u;
               ++search_end;
               ++h;
               rotate_gcd(r+(new_h0-h0), u, search_end);
               h0 = new_h0;
            }
            ++u;
         }
         rotate_gcd(first, h0, h0+h);
      }
   }
   return h;
}

template<class Unsigned>
Unsigned floor_sqrt(Unsigned n)
{
   Unsigned rem = 0, root = 0;
   const unsigned bits = sizeof(Unsigned)*8;

   for (unsigned i = bits / 2; i > 0; i--) {
      root = Unsigned(root << 1u);
      rem = Unsigned(Unsigned(rem << 2u) | Unsigned(n >> (bits - 2u)));
      n = Unsigned(n << 2u);
      if (root < rem) {
         rem = Unsigned(rem - Unsigned(root | 1u));
         root = Unsigned(root + 2u);
      }
   }
   return Unsigned(root >> 1u);
}

template<class Unsigned>
Unsigned ceil_sqrt(Unsigned const n)
{
   Unsigned r = floor_sqrt(n);
   return Unsigned(r + Unsigned((n%r) != 0));
}

template<class Unsigned>
Unsigned floor_merge_multiple(Unsigned const n, Unsigned &base, Unsigned &pow)
{
   Unsigned s = n;
   Unsigned p = 0;
   while(s > AdaptiveSortInsertionSortThreshold){
      s /= 2;
      ++p;
   }
   base = s;
   pow = p;
   return Unsigned(s << p);
}

template<class Unsigned>
Unsigned ceil_merge_multiple(Unsigned const n, Unsigned &base, Unsigned &pow)
{
   Unsigned fm = floor_merge_multiple(n, base, pow);

   if(fm != n){
      if(base < AdaptiveSortInsertionSortThreshold){
         ++base;
      }
      else{
         base = AdaptiveSortInsertionSortThreshold/2 + 1;
         ++pow;
      }
   }
   return Unsigned(base << pow);
}

template<class Unsigned>
Unsigned ceil_sqrt_multiple(Unsigned const n, Unsigned *pbase = 0)
{
   Unsigned const r = ceil_sqrt(n);
   Unsigned pow = 0;
   Unsigned base = 0;
   Unsigned const res = ceil_merge_multiple(r, base, pow);
   if(pbase) *pbase = base;
   return res;
}

struct less
{
   template<class T>
   bool operator()(const T &l, const T &r)
   { return l < r; }
};
# 538 "/usr/include/boost/move/algo/detail/adaptive_sort_merge.hpp" 3 4
template<class RandIt, class Compare>
void slow_stable_sort
   ( RandIt const first, RandIt const last, Compare comp)
{
   typedef typename iter_size<RandIt>::type size_type;

   size_type L = size_type(last - first);
   {
      size_type m = 0;
      while((L - m) > size_type(AdaptiveSortInsertionSortThreshold)){
         insertion_sort(first+m, first+m+size_type(AdaptiveSortInsertionSortThreshold), comp);
         m = size_type(m + AdaptiveSortInsertionSortThreshold);
      }
      insertion_sort(first+m, last, comp);
   }

   size_type h = AdaptiveSortInsertionSortThreshold;
   for(bool do_merge = L > h; do_merge; h = size_type(h*2)){
      do_merge = (L - h) > h;
      size_type p0 = 0;
      if(do_merge){
         size_type const h_2 = size_type(2*h);
         while((L-p0) > h_2){
            merge_bufferless(first+p0, first+p0+h, first+p0+h_2, comp);
            p0 = size_type(p0 + h_2);
         }
      }
      if((L-p0) > h){
         merge_bufferless(first+p0, first+p0+h, last, comp);
      }
   }
}




template<class Unsigned>
Unsigned lblock_for_combine
   (Unsigned const l_block, Unsigned const n_keys, Unsigned const l_data, bool &use_buf)
{
   (static_cast <bool> (l_data > 1) ? void (0) : __assert_fail ("l_data > 1", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));







   if(!l_block){


      (static_cast <bool> (n_keys >= 4) ? void (0) : __assert_fail ("n_keys >= 4", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));



      Unsigned const new_buf = n_keys/2;
      Unsigned const new_keys = Unsigned(n_keys-new_buf);
      use_buf = new_keys >= 4 && new_keys >= l_data/new_buf;
      if(use_buf){
         return new_buf;
      }
      else{
         return l_data/n_keys;
      }
   }
   else{
      use_buf = true;
      return l_block;
   }
}

template<class RandIt, class Compare, class XBuf>
void stable_sort( RandIt first, RandIt last, Compare comp, XBuf & xbuf)
{
   typedef typename iter_size<RandIt>::type size_type;
   size_type const len = size_type(last - first);
   size_type const half_len = size_type(len/2u + (len&1u));
   if(std::size_t(xbuf.capacity() - xbuf.size()) >= half_len) {
      merge_sort(first, last, comp, xbuf.data()+xbuf.size());
   }
   else{
      slow_stable_sort(first, last, comp);
   }
}

template<class RandIt, class Comp, class XBuf>
void unstable_sort( RandIt first, RandIt last
                    , Comp comp
                    , XBuf & xbuf)
{
   heap_sort(first, last, comp);
   ::boost::movelib::ignore(xbuf);
}

template<class RandIt, class Compare, class XBuf>
void stable_merge
      ( RandIt first, RandIt const middle, RandIt last
      , Compare comp
      , XBuf &xbuf)
{
   (static_cast <bool> (xbuf.empty()) ? void (0) : __assert_fail ("xbuf.empty()", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
   typedef typename iter_size<RandIt>::type size_type;
   size_type const len1 = size_type(middle-first);
   size_type const len2 = size_type(last-middle);
   size_type const l_min = min_value<size_type>(len1, len2);
   if(xbuf.capacity() >= l_min){
      buffered_merge(first, middle, last, comp, xbuf);
      xbuf.clear();
   }
   else{

      merge_adaptive_ONlogN(first, middle, last, comp, xbuf.begin(), xbuf.capacity());
   }
                                                                                                                 ;
}

template<class RandIt, class Comp, class XBuf>
void initialize_keys( RandIt first, RandIt last
                    , Comp comp
                    , XBuf & xbuf)
{
   unstable_sort(first, last, comp, xbuf);
   (static_cast <bool> (boost::movelib::is_sorted_and_unique(first, last, comp)) ? void (0) : __assert_fail ("boost::movelib::is_sorted_and_unique(first, last, comp)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
}

template<class RandIt, class U>
void initialize_keys( RandIt first, RandIt last
                    , less
                    , U &)
{
   typedef typename iterator_traits<RandIt>::value_type value_type;
   std::size_t count = std::size_t(last - first);
   for(std::size_t i = 0; i != count; ++i){
      *first = static_cast<value_type>(i);
      ++first;
   }
}

template <class Unsigned>
Unsigned calculate_total_combined(Unsigned const len, Unsigned const l_prev_merged, Unsigned *pl_irreg_combined = 0)
{
   typedef Unsigned size_type;

   size_type const l_combined = size_type(2*l_prev_merged);
   size_type l_irreg_combined = size_type(len%l_combined);
   size_type l_total_combined = len;
   if(l_irreg_combined <= l_prev_merged){
      l_total_combined = size_type(l_total_combined - l_irreg_combined);
      l_irreg_combined = 0;
   }
   if(pl_irreg_combined)
      *pl_irreg_combined = l_irreg_combined;
   return l_total_combined;
}

template<class RandItKeys, class KeyCompare, class SizeType, class XBuf>
void combine_params
   ( RandItKeys const keys
   , KeyCompare key_comp
   , SizeType l_combined
   , SizeType const l_prev_merged
   , SizeType const l_block
   , XBuf & xbuf

   , SizeType &n_block_a
   , SizeType &n_block_b
   , SizeType &l_irreg1
   , SizeType &l_irreg2

   , bool do_initialize_keys = true)
{
   typedef SizeType size_type;


   l_irreg1 = size_type(l_prev_merged%l_block);
   l_irreg2 = size_type((l_combined-l_irreg1)%l_block);
   (static_cast <bool> (((l_combined-l_irreg1-l_irreg2)%l_block) == 0) ? void (0) : __assert_fail ("((l_combined-l_irreg1-l_irreg2)%l_block) == 0", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
   size_type const n_reg_block = size_type((l_combined-l_irreg1-l_irreg2)/l_block);
   n_block_a = l_prev_merged/l_block;
   n_block_b = size_type(n_reg_block - n_block_a);
   (static_cast <bool> (n_reg_block>=n_block_a) ? void (0) : __assert_fail ("n_reg_block>=n_block_a", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));


   if (do_initialize_keys) {
      initialize_keys(keys, keys + needed_keys_count(n_block_a, n_block_b), key_comp, xbuf);
   }
}
# 733 "/usr/include/boost/move/algo/detail/adaptive_sort_merge.hpp" 3 4
template<class InputIt1, class InputIt2, class OutputIt, class Compare, class Op>
OutputIt op_partial_merge_impl
   (InputIt1 &r_first1, InputIt1 const last1, InputIt2 &r_first2, InputIt2 const last2, OutputIt d_first, Compare comp, Op op)
{
   InputIt1 first1(r_first1);
   InputIt2 first2(r_first2);
   if(first2 != last2 && last1 != first1)
   while(1){
      if(comp(*first2, *first1)) {
         op(first2++, d_first++);
         if(first2 == last2){
            break;
         }
      }
      else{
         op(first1++, d_first++);
         if(first1 == last1){
            break;
         }
      }
   }
   r_first1 = first1;
   r_first2 = first2;
   return d_first;
}

template<class InputIt1, class InputIt2, class OutputIt, class Compare, class Op>
OutputIt op_partial_merge
   (InputIt1 &r_first1, InputIt1 const last1, InputIt2 &r_first2, InputIt2 const last2, OutputIt d_first, Compare comp, Op op, bool is_stable)
{
   return is_stable ? op_partial_merge_impl(r_first1, last1, r_first2, last2, d_first, comp, op)
                    : op_partial_merge_impl(r_first1, last1, r_first2, last2, d_first, antistable<Compare>(comp), op);
}
# 776 "/usr/include/boost/move/algo/detail/adaptive_sort_merge.hpp" 3 4
template<class InputIt1, class InputIt2, class OutputIt, class Compare, class Op>
OutputIt op_partial_merge_and_swap_impl
   (InputIt1 &r_first1, InputIt1 const last1, InputIt2 &r_first2, InputIt2 const last2, InputIt2 &r_first_min, OutputIt d_first, Compare comp, Op op)
{
   InputIt1 first1(r_first1);
   InputIt2 first2(r_first2);

   if(first2 != last2 && last1 != first1) {
      InputIt2 first_min(r_first_min);
      bool non_empty_ranges = true;
      do{
         if(comp(*first_min, *first1)) {
            op(three_way_t(), first2++, first_min++, d_first++);
            non_empty_ranges = first2 != last2;
         }
         else{
            op(first1++, d_first++);
            non_empty_ranges = first1 != last1;
         }
      } while(non_empty_ranges);
      r_first_min = first_min;
      r_first1 = first1;
      r_first2 = first2;
   }
   return d_first;
}

template<class RandIt, class InputIt2, class OutputIt, class Compare, class Op>
OutputIt op_partial_merge_and_swap
   (RandIt &r_first1, RandIt const last1, InputIt2 &r_first2, InputIt2 const last2, InputIt2 &r_first_min, OutputIt d_first, Compare comp, Op op, bool is_stable)
{
   return is_stable ? op_partial_merge_and_swap_impl(r_first1, last1, r_first2, last2, r_first_min, d_first, comp, op)
                    : op_partial_merge_and_swap_impl(r_first1, last1, r_first2, last2, r_first_min, d_first, antistable<Compare>(comp), op);
}

template<class RandIt1, class RandIt2, class RandItB, class Compare, class Op>
RandItB op_buffered_partial_merge_and_swap_to_range1_and_buffer
   ( RandIt1 first1, RandIt1 const last1
   , RandIt2 &rfirst2, RandIt2 const last2, RandIt2 &rfirst_min
   , RandItB &rfirstb, Compare comp, Op op )
{
   RandItB firstb = rfirstb;
   RandItB lastb = firstb;
   RandIt2 first2 = rfirst2;




   if(first1 != last1 && first2 != last2){
      RandIt2 first_min = rfirst_min;
      op(four_way_t(), first2++, first_min++, first1++, lastb++);

      while(first1 != last1){
         if(first2 == last2){
            lastb = op(forward_t(), first1, last1, firstb);
            break;
         }

         if(comp(*first_min, *firstb)){
            op( four_way_t(), first2++, first_min++, first1++, lastb++);
         }
         else{
            op(three_way_t(), firstb++, first1++, lastb++);
         }
      }
      rfirst2 = first2;
      rfirstb = firstb;
      rfirst_min = first_min;
   }

   return lastb;
}

template<class RandIt1, class RandIt2, class RandItB, class Compare, class Op>
RandItB op_buffered_partial_merge_to_range1_and_buffer
   ( RandIt1 first1, RandIt1 const last1
   , RandIt2 &rfirst2, RandIt2 const last2
   , RandItB &rfirstb, Compare comp, Op op )
{
   RandItB firstb = rfirstb;
   RandItB lastb = firstb;
   RandIt2 first2 = rfirst2;




   if(first1 != last1 && first2 != last2){
      op(three_way_t(), first2++, first1++, lastb++);

      while(true){
         if(first1 == last1){
            break;
         }
         if(first2 == last2){
            lastb = op(forward_t(), first1, last1, firstb);
            break;
         }
         if (comp(*first2, *firstb)) {
            op(three_way_t(), first2++, first1++, lastb++);
         }
         else {
            op(three_way_t(), firstb++, first1++, lastb++);
         }
      }
      rfirst2 = first2;
      rfirstb = firstb;
   }

   return lastb;
}

template<class RandIt, class RandItBuf, class Compare, class Op>
RandIt op_partial_merge_and_save_impl
   ( RandIt first1, RandIt const last1, RandIt &rfirst2, RandIt last2, RandIt first_min
   , RandItBuf &buf_first1_in_out, RandItBuf &buf_last1_in_out
   , Compare comp, Op op
   )
{
   RandItBuf buf_first1 = buf_first1_in_out;
   RandItBuf buf_last1 = buf_last1_in_out;
   RandIt first2(rfirst2);

   bool const do_swap = first2 != first_min;
   if(buf_first1 == buf_last1){

      RandIt new_first1 = skip_until_merge(first1, last1, *first_min, comp);
      buf_first1 += (new_first1-first1);
      first1 = new_first1;
      buf_last1 = do_swap ? op_buffered_partial_merge_and_swap_to_range1_and_buffer(first1, last1, first2, last2, first_min, buf_first1, comp, op)
                           : op_buffered_partial_merge_to_range1_and_buffer (first1, last1, first2, last2, buf_first1, comp, op);
      first1 = last1;
   }
   else{
      (static_cast <bool> ((last1-first1) == (buf_last1 - buf_first1)) ? void (0) : __assert_fail ("(last1-first1) == (buf_last1 - buf_first1)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
   }


   first1 = do_swap ? op_partial_merge_and_swap_impl(buf_first1, buf_last1, first2, last2, first_min, first1, comp, op)
                    : op_partial_merge_impl (buf_first1, buf_last1, first2, last2, first1, comp, op);
   buf_first1_in_out = buf_first1;
   buf_last1_in_out = buf_last1;
   rfirst2 = first2;
   return first1;
}

template<class RandIt, class RandItBuf, class Compare, class Op>
RandIt op_partial_merge_and_save
   ( RandIt first1, RandIt const last1, RandIt &rfirst2, RandIt last2, RandIt first_min
   , RandItBuf &buf_first1_in_out
   , RandItBuf &buf_last1_in_out
   , Compare comp
   , Op op
   , bool is_stable)
{
   return is_stable
      ? op_partial_merge_and_save_impl
         (first1, last1, rfirst2, last2, first_min, buf_first1_in_out, buf_last1_in_out, comp, op)
      : op_partial_merge_and_save_impl
         (first1, last1, rfirst2, last2, first_min, buf_first1_in_out, buf_last1_in_out, antistable<Compare>(comp), op)
      ;
}
# 948 "/usr/include/boost/move/algo/detail/adaptive_sort_merge.hpp" 3 4
template<class RandItKeys, class KeyCompare, class RandIt, class RandIt2, class OutputIt, class Compare, class Op>
OutputIt op_merge_blocks_with_irreg
   ( RandItKeys key_first
   , RandItKeys key_mid
   , KeyCompare key_comp
   , RandIt first_reg
   , RandIt2 &first_irr
   , RandIt2 const last_irr
   , OutputIt dest
   , typename iter_size<RandIt>::type const l_block
   , typename iter_size<RandIt>::type n_block_left
   , typename iter_size<RandIt>::type min_check
   , typename iter_size<RandIt>::type max_check
   , Compare comp, bool const is_stable, Op op)
{
   typedef typename iter_size<RandIt>::type size_type;

   for(; n_block_left; --n_block_left){
      size_type next_key_idx = find_next_block(key_first, key_comp, first_reg, l_block, min_check, max_check, comp);
      max_check = min_value(max_value(max_check, size_type(next_key_idx+2u)), n_block_left);
      RandIt const last_reg = first_reg + l_block;
      RandIt first_min = first_reg + size_type(next_key_idx*l_block);
      RandIt const last_min = first_min + l_block;
      boost::movelib::ignore(last_min);

                                                                                              ;
                                                                                                               ;
                                                                                           ;

      OutputIt orig_dest = dest;
      boost::movelib::ignore(orig_dest);
      dest = next_key_idx ? op_partial_merge_and_swap(first_irr, last_irr, first_reg, last_reg, first_min, dest, comp, op, is_stable)
                          : op_partial_merge (first_irr, last_irr, first_reg, last_reg, dest, comp, op, is_stable);
                                                                                          ;

      if(first_reg == dest){
         dest = next_key_idx ? ::boost::adl_move_swap_ranges(first_min, last_min, first_reg)
                             : last_reg;
      }
      else{
         dest = next_key_idx ? op(three_way_forward_t(), first_reg, last_reg, first_min, dest)
                             : op(forward_t(), first_reg, last_reg, dest);
      }

      RandItKeys const key_next(key_first + next_key_idx);
      swap_and_update_key(key_next, key_first, key_mid, last_reg, last_reg, first_min);

                                                                                          ;
      first_reg = last_reg;
      ++key_first;
      min_check = size_type(min_check - (min_check != 0));
      max_check = size_type(max_check - (max_check != 0));
   }
   return dest;
}
# 1014 "/usr/include/boost/move/algo/detail/adaptive_sort_merge.hpp" 3 4
template<class RandItKeys, class KeyCompare, class RandIt, class Compare, class Op>
void op_merge_blocks_left
   ( RandItKeys const key_first
   , KeyCompare key_comp
   , RandIt const first
   , typename iter_size<RandIt>::type const l_block
   , typename iter_size<RandIt>::type const l_irreg1
   , typename iter_size<RandIt>::type const n_block_a
   , typename iter_size<RandIt>::type const n_block_b
   , typename iter_size<RandIt>::type const l_irreg2
   , Compare comp, Op op)
{
   typedef typename iter_size<RandIt>::type size_type;

   size_type const key_count = needed_keys_count(n_block_a, n_block_b);
   boost::movelib::ignore(key_count);


                                                                                                                       ;
                                                                                                                                                 ;

   size_type n_block_b_left = n_block_b;
   size_type n_block_a_left = n_block_a;
   size_type n_block_left = size_type(n_block_b + n_block_a);
   RandItKeys key_mid(key_first + n_block_a);

   RandIt buffer = first - l_block;
   RandIt first1 = first;
   RandIt last1 = first1 + l_irreg1;
   RandIt first2 = last1;
   RandIt const irreg2 = first2 + size_type(n_block_left*l_block);
   bool is_range1_A = true;

   RandItKeys key_range2(key_first);




   size_type min_check = n_block_a == n_block_left ? 0u : n_block_a;
   size_type max_check = min_value<size_type>(size_type(min_check+1u), n_block_left);
   for (; n_block_left; --n_block_left) {
      size_type const next_key_idx = find_next_block(key_range2, key_comp, first2, l_block, min_check, max_check, comp);
      max_check = min_value<size_type>(max_value<size_type>(max_check, size_type(next_key_idx+2u)), n_block_left);
      RandIt const first_min = first2 + size_type(next_key_idx*l_block);
      RandIt const last_min = first_min + l_block;

      boost::movelib::ignore(last_min);
      RandIt const last2 = first2 + l_block;

                                                                                        ;
                                                                                        ;
                                                                                                               ;



      if (!n_block_b_left &&
            ( (l_irreg2 && comp(*irreg2, *first_min)) || (!l_irreg2 && is_range1_A)) ){
         break;
      }

      RandItKeys const key_next(key_range2 + next_key_idx);
      bool const is_range2_A = key_mid == (key_first+key_count) || key_comp(*key_next, *key_mid);

      bool const is_buffer_middle = last1 == buffer;

                                                                                                                        ;

      if(is_range1_A == is_range2_A){
         (static_cast <bool> ((first1 == last1) || !comp(*first_min, last1[typename iterator_traits<RandIt>::difference_type(-1)])) ? void (0) : __assert_fail ("(first1 == last1) || !comp(*first_min, last1[typename iterator_traits<RandIt>::difference_type(-1)])", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
         if(!is_buffer_middle){
            buffer = op(forward_t(), first1, last1, buffer);
         }
         swap_and_update_key(key_next, key_range2, key_mid, first2, last2, first_min);
         first1 = first2;
         last1 = last2;
      }
      else {
         RandIt unmerged;
         RandIt buf_beg;
         RandIt buf_end;
         if(is_buffer_middle){
            buf_end = buf_beg = first2 - (last1-first1);
            unmerged = op_partial_merge_and_save( first1, last1, first2, last2, first_min
                                                , buf_beg, buf_end, comp, op, is_range1_A);
         }
         else{
            buf_beg = first1;
            buf_end = last1;
            unmerged = op_partial_merge_and_save
               (buffer, buffer+(last1-first1), first2, last2, first_min, buf_beg, buf_end, comp, op, is_range1_A);
         }

         boost::movelib::ignore(unmerged);
                                                                                                     ;

         swap_and_update_key( key_next, key_range2, key_mid, first2, last2
                            , last_min - size_type(last2 - first2));

         if(buf_beg != buf_end){
            first1 = buf_beg;
            last1 = buf_end;
                                                                          ;
            buffer = last1;
         }
         else{
            first1 = first2;
            last1 = last2;
            buffer = first2 - l_block;
            is_range1_A = is_range2_A;
         }
      }
                                                                                                              ;
      is_range2_A ? --n_block_a_left : --n_block_b_left;
      first2 = last2;

      ++key_range2;
      min_check = size_type(min_check - (min_check != 0));
      max_check = size_type(max_check - (max_check != 0));
   }

                                                                                                                                         ;
   (static_cast <bool> (!n_block_b_left) ? void (0) : __assert_fail ("!n_block_b_left", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));




   bool const is_buffer_middle = last1 == buffer;
   RandIt first_irr2 = irreg2;
   RandIt const last_irr2 = first_irr2 + l_irreg2;
   if(l_irreg2 && is_range1_A){
      if(is_buffer_middle){
         first1 = skip_until_merge(first1, last1, *first_irr2, comp);


         RandIt const new_first1 = first2 - (last1 - first1);
         op(forward_t(), first1, last1, new_first1);
         first1 = new_first1;
         last1 = first2;
         buffer = first1 - l_block;
      }
      buffer = op_partial_merge_impl(first1, last1, first_irr2, last_irr2, buffer, comp, op);
      buffer = op(forward_t(), first1, last1, buffer);
   }
   else if(!is_buffer_middle){
      buffer = op(forward_t(), first1, last1, buffer);
   }
                                                                                             ;




   buffer = op_merge_blocks_with_irreg
      ( key_range2, key_mid, key_comp, first2, first_irr2, last_irr2
      , buffer, l_block, n_block_left, min_check, max_check, comp, false, op);
   buffer = op(forward_t(), first_irr2, last_irr2, buffer);
   boost::movelib::ignore(buffer);
                                                                                             ;
}
# 1180 "/usr/include/boost/move/algo/detail/adaptive_sort_merge.hpp" 3 4
template<class RandItKeys, class KeyCompare, class RandIt, class Compare>
void merge_blocks_left
   ( RandItKeys const key_first
   , KeyCompare key_comp
   , RandIt const first
   , typename iter_size<RandIt>::type const l_block
   , typename iter_size<RandIt>::type const l_irreg1
   , typename iter_size<RandIt>::type const n_block_a
   , typename iter_size<RandIt>::type const n_block_b
   , typename iter_size<RandIt>::type const l_irreg2
   , Compare comp
   , bool const xbuf_used)
{
                                                                                                                                                                               ;
   if(xbuf_used){
      op_merge_blocks_left
         (key_first, key_comp, first, l_block, l_irreg1, n_block_a, n_block_b, l_irreg2, comp, move_op());
   }
   else{
      op_merge_blocks_left
         (key_first, key_comp, first, l_block, l_irreg1, n_block_a, n_block_b, l_irreg2, comp, swap_op());
   }
}
# 1211 "/usr/include/boost/move/algo/detail/adaptive_sort_merge.hpp" 3 4
template<class RandItKeys, class KeyCompare, class RandIt, class Compare>
void merge_blocks_right
   ( RandItKeys const key_first
   , KeyCompare key_comp
   , RandIt const first
   , typename iter_size<RandIt>::type const l_block
   , typename iter_size<RandIt>::type const n_block_a
   , typename iter_size<RandIt>::type const n_block_b
   , typename iter_size<RandIt>::type const l_irreg2
   , Compare comp
   , bool const xbuf_used)
{
   typedef typename iter_size<RandIt>::type size_type;
   merge_blocks_left
      ( (make_reverse_iterator)(key_first + needed_keys_count(n_block_a, n_block_b))
      , inverse<KeyCompare>(key_comp)
      , (make_reverse_iterator)(first + size_type((n_block_a+n_block_b)*l_block+l_irreg2))
      , l_block
      , l_irreg2
      , n_block_b
      , n_block_a
      , 0
      , inverse<Compare>(comp), xbuf_used);
}
# 1245 "/usr/include/boost/move/algo/detail/adaptive_sort_merge.hpp" 3 4
template<class RandItKeys, class KeyCompare, class RandIt, class Compare, class Op, class RandItBuf>
void op_merge_blocks_with_buf
   ( RandItKeys key_first
   , KeyCompare key_comp
   , RandIt const first
   , typename iter_size<RandIt>::type const l_block
   , typename iter_size<RandIt>::type const l_irreg1
   , typename iter_size<RandIt>::type const n_block_a
   , typename iter_size<RandIt>::type const n_block_b
   , typename iter_size<RandIt>::type const l_irreg2
   , Compare comp
   , Op op
   , RandItBuf const buf_first)
{
   typedef typename iter_size<RandIt>::type size_type;
   size_type const key_count = needed_keys_count(n_block_a, n_block_b);
   boost::movelib::ignore(key_count);

                                                                                                                       ;
                                                                                                                                                 ;

   size_type n_block_b_left = n_block_b;
   size_type n_block_a_left = n_block_a;
   size_type n_block_left = size_type(n_block_b + n_block_a);
   RandItKeys key_mid(key_first + n_block_a);

   RandItBuf buffer = buf_first;
   RandItBuf buffer_end = buffer;
   RandIt first1 = first;
   RandIt last1 = first1 + l_irreg1;
   RandIt first2 = last1;
   RandIt const first_irr2 = first2 + size_type(n_block_left*l_block);
   bool is_range1_A = true;
   const size_type len = size_type(l_block * n_block_a + l_block * n_block_b + l_irreg1 + l_irreg2);
   boost::movelib::ignore(len);

   RandItKeys key_range2(key_first);




   size_type min_check = n_block_a == n_block_left ? 0u : n_block_a;
   size_type max_check = min_value(size_type(min_check+1), n_block_left);
   for (; n_block_left; --n_block_left) {
      size_type const next_key_idx = find_next_block(key_range2, key_comp, first2, l_block, min_check, max_check, comp);
      max_check = min_value(max_value(max_check, size_type(next_key_idx+2)), n_block_left);
      RandIt first_min = first2 + size_type(next_key_idx*l_block);
      RandIt const last_min = first_min + l_block;
      boost::movelib::ignore(last_min);
      RandIt const last2 = first2 + l_block;

      bool const buffer_empty = buffer == buffer_end;
      boost::movelib::ignore(buffer_empty);
                                                                                                                                                             ;
                                                                                        ;
                                                                                                               ;



      if (!n_block_b_left &&
            ( (l_irreg2 && comp(*first_irr2, *first_min)) || (!l_irreg2 && is_range1_A)) ){
         break;
      }

      RandItKeys const key_next(key_range2 + next_key_idx);
      bool const is_range2_A = key_mid == (key_first+key_count) || key_comp(*key_next, *key_mid);

      if(is_range1_A == is_range2_A){
                                                                                                                                                   ;

         RandIt res = op(forward_t(), buffer, buffer_end, first1);
                                                                          ;
         buffer = buffer_end = buf_first;
         (static_cast <bool> (buffer_empty || res == last1) ? void (0) : __assert_fail ("buffer_empty || res == last1", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
         boost::movelib::ignore(res);

         buffer_end = buffer_and_update_key(key_next, key_range2, key_mid, first2, last2, first_min, buffer = buf_first, op);
                                                                          ;
                                                                                           ;
                                                                                                 ;
         first1 = first2;
                                                                                           ;
      }
      else {
         RandIt const unmerged = op_partial_merge_and_save(first1, last1, first2, last2, first_min, buffer, buffer_end, comp, op, is_range1_A);
                                                                          ;
         bool const is_range_1_empty = buffer == buffer_end;
         (static_cast <bool> (is_range_1_empty || (buffer_end-buffer) == (last1+l_block-unmerged)) ? void (0) : __assert_fail ("is_range_1_empty || (buffer_end-buffer) == (last1+l_block-unmerged)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
         if(is_range_1_empty){
            buffer = buffer_end = buf_first;
            first_min = last_min - (last2 - first2);

            buffer_end = buffer_and_update_key(key_next, key_range2, key_mid, first2, last2, first_min, buf_first, op);
         }
         else{
            first_min = last_min;

            update_key(key_next, key_range2, key_mid);
         }
                                                                                                          ;
                                                                          ;
                                                                                                 ;
         is_range1_A ^= is_range_1_empty;
         first1 = unmerged;
                                                                                             ;
      }
      (static_cast <bool> ((is_range2_A && n_block_a_left) || (!is_range2_A && n_block_b_left)) ? void (0) : __assert_fail ("(is_range2_A && n_block_a_left) || (!is_range2_A && n_block_b_left)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      is_range2_A ? --n_block_a_left : --n_block_b_left;
      last1 += l_block;
      first2 = last2;

      ++key_range2;
      min_check = size_type(min_check - (min_check != 0));
      max_check = size_type(max_check - (max_check != 0));
   }
   RandIt res = op(forward_t(), buffer, buffer_end, first1);
   boost::movelib::ignore(res);
                                                                                  ;
                                                                    ;




   RandIt const last_irr2 = first_irr2 + l_irreg2;
   op(forward_t(), first_irr2, first_irr2+l_irreg2, buf_first);
                                                                    ;
   buffer = buf_first;
   buffer_end = buffer+l_irreg2;

   reverse_iterator<RandItBuf> rbuf_beg(buffer_end);
   RandIt dest = op_merge_blocks_with_irreg
      ((make_reverse_iterator)(key_first + n_block_b + n_block_a), (make_reverse_iterator)(key_mid), inverse<KeyCompare>(key_comp)
      , (make_reverse_iterator)(first_irr2), rbuf_beg, (make_reverse_iterator)(buffer), (make_reverse_iterator)(last_irr2)
      , l_block, n_block_left, 0, n_block_left
      , inverse<Compare>(comp), true, op).base();
                                                                                       ;
                                                                    ;

   buffer_end = rbuf_beg.base();
   (static_cast <bool> ((dest-last1) == (buffer_end-buffer)) ? void (0) : __assert_fail ("(dest-last1) == (buffer_end-buffer)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
   op_merge_with_left_placed(is_range1_A ? first1 : last1, last1, dest, buffer, buffer_end, comp, op);
                                                                    ;
                                                                                        ;
}
# 1400 "/usr/include/boost/move/algo/detail/adaptive_sort_merge.hpp" 3 4
template<class RandIt, class Compare, class Op>
typename iter_size<RandIt>::type
   op_insertion_sort_step_left
      ( RandIt const first
      , typename iter_size<RandIt>::type const length
      , typename iter_size<RandIt>::type const step
      , Compare comp, Op op)
{
   typedef typename iter_size<RandIt>::type size_type;

   size_type const s = min_value<size_type>(step, AdaptiveSortInsertionSortThreshold);
   size_type m = 0;

   while(size_type(length - m) > s){
      insertion_sort_op(first+m, first+m+s, first+m-s, comp, op);
      m = size_type(m + s);
   }
   insertion_sort_op(first+m, first+length, first+m-s, comp, op);
   return s;
}

template<class RandIt, class Compare, class Op>
void op_merge_right_step_once
      ( RandIt first_block
      , typename iter_size<RandIt>::type const elements_in_blocks
      , typename iter_size<RandIt>::type const l_build_buf
      , Compare comp
      , Op op)
{
   typedef typename iter_size<RandIt>::type size_type;
   size_type restk = size_type(elements_in_blocks%(2*l_build_buf));
   size_type p = size_type(elements_in_blocks - restk);
   (static_cast <bool> (0 == (p%(2*l_build_buf))) ? void (0) : __assert_fail ("0 == (p%(2*l_build_buf))", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));

   if(restk <= l_build_buf){
      op(backward_t(),first_block+p, first_block+p+restk, first_block+p+restk+l_build_buf);
   }
   else{
      op_merge_right(first_block+p, first_block+p+l_build_buf, first_block+p+restk, first_block+p+restk+l_build_buf, comp, op);
   }
   while(p>0){
      p = size_type(p - 2u*l_build_buf);
      op_merge_right( first_block+p, first_block+size_type(p+l_build_buf)
                    , first_block+size_type(p+2*l_build_buf)
                    , first_block+size_type(p+3*l_build_buf), comp, op);
   }
}
# 1458 "/usr/include/boost/move/algo/detail/adaptive_sort_merge.hpp" 3 4
template<class RandIt, class Compare>
typename iter_size<RandIt>::type
   insertion_sort_step
      ( RandIt const first
      , typename iter_size<RandIt>::type const length
      , typename iter_size<RandIt>::type const step
      , Compare comp)
{
   typedef typename iter_size<RandIt>::type size_type;
   size_type const s = min_value<size_type>(step, AdaptiveSortInsertionSortThreshold);
   size_type m = 0;

   while((length - m) > s){
      insertion_sort(first+m, first+m+s, comp);
      m = size_type(m + s);
   }
   insertion_sort(first+m, first+length, comp);
   return s;
}
# 1487 "/usr/include/boost/move/algo/detail/adaptive_sort_merge.hpp" 3 4
template<class RandIt, class Compare, class Op>
typename iter_size<RandIt>::type
   op_merge_left_step_multiple
      ( RandIt first_block
      , typename iter_size<RandIt>::type const elements_in_blocks
      , typename iter_size<RandIt>::type l_merged
      , typename iter_size<RandIt>::type const l_build_buf
      , typename iter_size<RandIt>::type l_left_space
      , Compare comp
      , Op op)
{
   typedef typename iter_size<RandIt>::type size_type;
   for(; l_merged < l_build_buf && l_left_space >= l_merged; l_merged = size_type(l_merged*2u)){
      size_type p0=0;
      RandIt pos = first_block;
      while((elements_in_blocks - p0) > 2*l_merged) {
         op_merge_left(pos-l_merged, pos, pos+l_merged, pos+size_type(2*l_merged), comp, op);
                                                                                                        ;
         p0 = size_type(p0 + 2u*l_merged);
         pos = first_block+p0;
      }
      if((elements_in_blocks-p0) > l_merged) {
         op_merge_left(pos-l_merged, pos, pos+l_merged, first_block+elements_in_blocks, comp, op);


                                                                                                  ;
      }
      else {
         op(forward_t(), pos, first_block+elements_in_blocks, pos-l_merged);


                                                                                        ;
      }
      first_block -= l_merged;
      l_left_space = size_type(l_left_space - l_merged);
   }
   return l_merged;
}


}
}
}


#pragma GCC diagnostic pop


# 1 "/usr/include/boost/move/detail/config_end.hpp" 1 3 4
# 1536 "/usr/include/boost/move/algo/detail/adaptive_sort_merge.hpp" 2 3 4
# 17 "/usr/include/boost/move/algo/adaptive_merge.hpp" 2 3 4
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 1 3 4
# 42 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 3


# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 45 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 2 3
# 18 "/usr/include/boost/move/algo/adaptive_merge.hpp" 2 3 4


#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wsign-conversion"


namespace boost {
namespace movelib {


namespace detail_adaptive {

template<class RandIt, class Compare, class XBuf>
inline void adaptive_merge_combine_blocks( RandIt first
                                      , typename iter_size<RandIt>::type len1
                                      , typename iter_size<RandIt>::type len2
                                      , typename iter_size<RandIt>::type collected
                                      , typename iter_size<RandIt>::type n_keys
                                      , typename iter_size<RandIt>::type l_block
                                      , bool use_internal_buf
                                      , bool xbuf_used
                                      , Compare comp
                                      , XBuf & xbuf
                                      )
{
   typedef typename iter_size<RandIt>::type size_type;

   size_type const len = size_type(len1+len2);
   size_type const l_combine = size_type(len-collected);
   size_type const l_combine1 = size_type(len1-collected);

    if(n_keys){
      RandIt const first_data = first+collected;
      RandIt const keys = first;
                                                              ;
      if(xbuf_used){
         if(xbuf.size() < l_block){
            xbuf.initialize_until(l_block, *first);
         }
         (static_cast <bool> (xbuf.size() >= l_block) ? void (0) : __assert_fail ("xbuf.size() >= l_block", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
         size_type n_block_a, n_block_b, l_irreg1, l_irreg2;
         combine_params( keys, comp, l_combine
                           , l_combine1, l_block, xbuf
                           , n_block_a, n_block_b, l_irreg1, l_irreg2);
         op_merge_blocks_with_buf
            (keys, comp, first_data, l_block, l_irreg1, n_block_a, n_block_b, l_irreg2, comp, move_op(), xbuf.data());
                                                                 ;
      }
      else{
         size_type n_block_a, n_block_b, l_irreg1, l_irreg2;
         combine_params( keys, comp, l_combine
                           , l_combine1, l_block, xbuf
                           , n_block_a, n_block_b, l_irreg1, l_irreg2);
         if(use_internal_buf){
            op_merge_blocks_with_buf
               ( keys, comp, first_data, l_block, l_irreg1, n_block_a, n_block_b
               , l_irreg2, comp, swap_op(), first_data-l_block);
                                                                    ;
         }
         else{
            merge_blocks_bufferless
               (keys, comp, first_data, l_block, l_irreg1, n_block_a, n_block_b, l_irreg2, comp);
                                                                    ;
         }
      }
   }
   else{
      xbuf.shrink_to_fit(l_block);
      if(xbuf.size() < l_block){
         xbuf.initialize_until(l_block, *first);
      }
      size_type *const uint_keys = xbuf.template aligned_trailing<size_type>(l_block);
      size_type n_block_a, n_block_b, l_irreg1, l_irreg2;
      combine_params( uint_keys, less(), l_combine
                     , l_combine1, l_block, xbuf
                     , n_block_a, n_block_b, l_irreg1, l_irreg2, true);
                                                              ;
      (static_cast <bool> (xbuf.size() >= l_block) ? void (0) : __assert_fail ("xbuf.size() >= l_block", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      op_merge_blocks_with_buf
         (uint_keys, less(), first, l_block, l_irreg1, n_block_a, n_block_b, l_irreg2, comp, move_op(), xbuf.data());
      xbuf.clear();
                                                              ;
   }
}

template<class RandIt, class Compare, class XBuf>
inline void adaptive_merge_final_merge( RandIt first
                                      , typename iter_size<RandIt>::type len1
                                      , typename iter_size<RandIt>::type len2
                                      , typename iter_size<RandIt>::type collected
                                      , typename iter_size<RandIt>::type l_intbuf
                                      , typename iter_size<RandIt>::type
                                      , bool
                                      , bool xbuf_used
                                      , Compare comp
                                      , XBuf & xbuf
                                      )
{
   typedef typename iter_size<RandIt>::type size_type;

   size_type n_keys = size_type(collected-l_intbuf);
   size_type len = size_type(len1+len2);
   if (!xbuf_used || n_keys) {
      xbuf.clear();
      const size_type middle = xbuf_used && n_keys ? n_keys: collected;
      unstable_sort(first, first + middle, comp, xbuf);
                                                              ;
      stable_merge(first, first + middle, first + len, comp, xbuf);
   }
                                                           ;
}

template<class SizeType>
inline static SizeType adaptive_merge_n_keys_without_external_keys(SizeType l_block, SizeType len1, SizeType len2, SizeType l_intbuf)
{
   typedef SizeType size_type;

   size_type n_keys = size_type(len1/l_block + len2/l_block);
   const size_type second_half_blocks = size_type(len2/l_block);
   const size_type first_half_aux = size_type(len1 - l_intbuf);
   while(n_keys >= ((first_half_aux-n_keys)/l_block + second_half_blocks)){
      --n_keys;
   }
   ++n_keys;
   return n_keys;
}

template<class SizeType>
inline static SizeType adaptive_merge_n_keys_with_external_keys(SizeType l_block, SizeType len1, SizeType len2, SizeType l_intbuf)
{
   typedef SizeType size_type;

   size_type n_keys = size_type((len1-l_intbuf)/l_block + len2/l_block);
   return n_keys;
}

template<class SizeType, class Xbuf>
inline SizeType adaptive_merge_n_keys_intbuf(SizeType &rl_block, SizeType len1, SizeType len2, Xbuf & xbuf, SizeType &l_intbuf_inout)
{
   typedef SizeType size_type;
   size_type l_block = rl_block;
   size_type l_intbuf = xbuf.capacity() >= l_block ? 0u : l_block;

   if (xbuf.capacity() > l_block){
      l_block = xbuf.capacity();
   }


   size_type n_keys = adaptive_merge_n_keys_without_external_keys(l_block, len1, len2, l_intbuf);
   (static_cast <bool> (n_keys >= ((len1-l_intbuf-n_keys)/l_block + len2/l_block)) ? void (0) : __assert_fail ("n_keys >= ((len1-l_intbuf-n_keys)/l_block + len2/l_block)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));

   if(xbuf.template supports_aligned_trailing<size_type>
      ( l_block
      , adaptive_merge_n_keys_with_external_keys(l_block, len1, len2, l_intbuf)))
   {
      n_keys = 0u;
   }
   l_intbuf_inout = l_intbuf;
   rl_block = l_block;
   return n_keys;
}
# 223 "/usr/include/boost/move/algo/adaptive_merge.hpp" 3 4
template<class RandIt, class Compare, class XBuf>
void adaptive_merge_impl
   ( RandIt first
   , typename iter_size<RandIt>::type len1
   , typename iter_size<RandIt>::type len2
   , Compare comp
   , XBuf & xbuf
   )
{
   typedef typename iter_size<RandIt>::type size_type;

   if(xbuf.capacity() >= min_value<size_type>(len1, len2)){
      buffered_merge( first, first+len1
                    , first + len1+len2, comp, xbuf);
   }
   else{
      const size_type len = size_type(len1+len2);

      size_type l_block = size_type(ceil_sqrt(len));



      if(len1 <= l_block*2 || len2 <= l_block*2){
         merge_bufferless(first, first+len1, first+len1+len2, comp);
         return;
      }



      size_type l_intbuf = 0;
      size_type n_keys = adaptive_merge_n_keys_intbuf(l_block, len1, len2, xbuf, l_intbuf);
      size_type const to_collect = size_type(l_intbuf+n_keys);

      size_type const collected = collect_unique(first, first+len1, to_collect, comp, xbuf);
                                                                ;


      if(collected != to_collect && collected < 4){
         merge_bufferless(first, first+collected, first+len1, comp);
         merge_bufferless(first, first + len1, first + len1 + len2, comp);
         return;
      }


      bool use_internal_buf = collected == to_collect;
      if (!use_internal_buf){
         l_intbuf = 0u;
         n_keys = collected;
         l_block = lblock_for_combine(l_intbuf, n_keys, len, use_internal_buf);

         l_intbuf = use_internal_buf ? l_block : 0u;
      }

      bool const xbuf_used = collected == to_collect && xbuf.capacity() >= l_block;

      adaptive_merge_combine_blocks(first, len1, len2, collected, n_keys, l_block, use_internal_buf, xbuf_used, comp, xbuf);

      adaptive_merge_final_merge (first, len1, len2, collected, l_intbuf, l_block, use_internal_buf, xbuf_used, comp, xbuf);
   }
}

}
# 317 "/usr/include/boost/move/algo/adaptive_merge.hpp" 3 4
template<class RandIt, class Compare>
void adaptive_merge( RandIt first, RandIt middle, RandIt last, Compare comp
                , typename iterator_traits<RandIt>::value_type* uninitialized = 0
                , typename iter_size<RandIt>::type uninitialized_len = 0)
{
   typedef typename iter_size<RandIt>::type size_type;
   typedef typename iterator_traits<RandIt>::value_type value_type;

   if (first == middle || middle == last){
      return;
   }


   do {
      if (comp(*middle, *first)){
         break;
      }
      ++first;
      if (first == middle)
         return;
   } while(1);

   RandIt first_high(middle);
   --first_high;
   do {
      --last;
      if (comp(*last, *first_high)){
         ++last;
         break;
      }
      if (last == middle)
         return;
   } while(1);

   ::boost::movelib::adaptive_xbuf<value_type, value_type*, size_type> xbuf(uninitialized, size_type(uninitialized_len));
   ::boost::movelib::detail_adaptive::adaptive_merge_impl(first, size_type(middle - first), size_type(last - middle), comp, xbuf);
}

}
}


#pragma GCC diagnostic pop


# 1 "/usr/include/boost/move/detail/config_end.hpp" 1 3 4
# 363 "/usr/include/boost/move/algo/adaptive_merge.hpp" 2 3 4
# 61 "/usr/include/boost/container/vector.hpp" 2 3 4
# 1 "/usr/include/boost/move/algo/unique.hpp" 1 3 4
# 15 "/usr/include/boost/move/algo/unique.hpp" 3 4
# 1 "/usr/include/boost/move/detail/config_begin.hpp" 1 3 4
# 16 "/usr/include/boost/move/algo/unique.hpp" 2 3 4


namespace boost {
namespace movelib {
# 31 "/usr/include/boost/move/algo/unique.hpp" 3 4
template<class ForwardIterator, class BinaryPredicate>
ForwardIterator unique(ForwardIterator first, ForwardIterator last, BinaryPredicate pred)
{
    if (first != last) {
      ForwardIterator next(first);
      ++next;
      for (; next != last; ++next, ++first) {
         if (pred(*first, *next)) {
            while (++next != last)
               if (!pred(*first, *next))
                  *++first = ::boost::move(*next);
            break;
         }
      }
      ++first;
   }
   return first;
}

}
}

# 1 "/usr/include/boost/move/detail/config_end.hpp" 1 3 4
# 54 "/usr/include/boost/move/algo/unique.hpp" 2 3 4
# 62 "/usr/include/boost/container/vector.hpp" 2 3 4

# 1 "/usr/include/boost/move/algo/detail/set_difference.hpp" 1 3 4
# 19 "/usr/include/boost/move/algo/detail/set_difference.hpp" 3 4
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wsign-conversion"


namespace boost {
namespace move_detail{

template<class InputIt, class OutputIt>
OutputIt copy(InputIt first, InputIt last, OutputIt result)
{
   while (first != last) {
      *result++ = *first;
      ++result;
      ++first;
   }
   return result;
}

}

namespace movelib {







template<class InputIt1, class InputIt2,
         class OutputIt, class Compare>
OutputIt set_difference
   (InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, OutputIt result, Compare comp)
{
   while (first1 != last1) {
      if (first2 == last2)
         return boost::move_detail::copy(first1, last1, result);

      if (comp(*first1, *first2)) {
         *result = *first1;
         ++result;
         ++first1;
      }
      else {
         if (!comp(*first2, *first1)) {
            ++first1;
         }
         ++first2;
      }
   }
   return result;
}






template<class InputOutputIt1, class InputIt2, class Compare>
InputOutputIt1 inplace_set_difference
   (InputOutputIt1 first1, InputOutputIt1 last1, InputIt2 first2, InputIt2 last2, Compare comp )
{
   while (first1 != last1) {

      if (first2 == last2){
         return last1;
      }
      else if (comp(*first1, *first2)){
         ++first1;
      }
      else{
         if (!comp(*first2, *first1)) {
            InputOutputIt1 result = first1;

            return boost::movelib::set_difference
               ( boost::make_move_iterator(++first1)
               , boost::make_move_iterator(last1)
               , ++first2, last2, result, comp);
         }
         ++first2;
      }
   }
   return first1;
}
# 110 "/usr/include/boost/move/algo/detail/set_difference.hpp" 3 4
template<class ForwardIt1, class InputIt2,
         class OutputIt, class Compare>
OutputIt set_unique_difference
   (ForwardIt1 first1, ForwardIt1 last1, InputIt2 first2, InputIt2 last2, OutputIt result, Compare comp)
{
   while (first1 != last1) {
      if (first2 == last2){


         ForwardIt1 i = first1;
         while (++first1 != last1) {
            if (comp(*i, *first1)) {
               *result = *i;
               ++result;
               i = first1;
            }
         }
         *result = *i;
         ++result;
         break;
      }

      if (comp(*first1, *first2)) {


         ForwardIt1 i = first1;
         while (++first1 != last1) {
            if (comp(*i, *first1)) {
               break;
            }
         }
         *result = *i;
         ++result;
      }
      else {
         if (comp(*first2, *first1)) {
            ++first2;
         }
         else{
            ++first1;
         }
      }
   }
   return result;
}






template<class ForwardOutputIt1, class ForwardIt2, class Compare>
ForwardOutputIt1 inplace_set_unique_difference
   (ForwardOutputIt1 first1, ForwardOutputIt1 last1, ForwardIt2 first2, ForwardIt2 last2, Compare comp )
{
   while (first1 != last1) {

      if (first2 == last2){

         ForwardOutputIt1 result = first1;
         while (++first1 != last1) {
            if (comp(*result, *first1) && ++result != first1) {
               *result = boost::move(*first1);
            }
         }
         return ++result;
      }
      else if (comp(*first2, *first1)) {
         ++first2;
      }
      else if (comp(*first1, *first2)){

         ForwardOutputIt1 result = first1;
         if (++first1 != last1 && !comp(*result, *first1)) {

            while (++first1 != last1 && !comp(*result, *first1)){}
            return boost::movelib::set_unique_difference
               ( boost::make_move_iterator(first1)
               , boost::make_move_iterator(last1)
               , first2, last2, ++result, comp);
         }
      }
      else{
         ForwardOutputIt1 result = first1;

         while (++first1 != last1 && !comp(*result, *first1)){}

         return boost::movelib::set_unique_difference
            ( boost::make_move_iterator(first1)
            , boost::make_move_iterator(last1)
            , first2, last2, result, comp);
      }
   }
   return first1;
}


#pragma GCC diagnostic pop


}
}
# 64 "/usr/include/boost/container/vector.hpp" 2 3 4

# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 58 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 59 "/usr/include/boost/assert.hpp" 2 3 4
# 66 "/usr/include/boost/container/vector.hpp" 2 3 4
# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 67 "/usr/include/boost/container/vector.hpp" 2 3 4






namespace boost {
namespace container {




template <class Pointer, bool IsConst>
class vec_iterator
{
   public:
   typedef std::random_access_iterator_tag iterator_category;

   typedef std::contiguous_iterator_tag iterator_concept;

   typedef typename boost::intrusive::pointer_traits<Pointer>::element_type value_type;
# 97 "/usr/include/boost/container/vector.hpp" 3 4
   typedef typename boost::intrusive::pointer_traits<Pointer>::difference_type difference_type;
   typedef typename boost::intrusive::pointer_traits<Pointer>::size_type size_type;
   typedef typename dtl::if_c
      < IsConst
      , typename boost::intrusive::pointer_traits<Pointer>::template
                                 rebind_pointer<const value_type>::type
      , Pointer
      >::type pointer;
   typedef typename boost::intrusive::pointer_traits<pointer> ptr_traits;
   typedef typename ptr_traits::reference reference;


   private:
   Pointer m_ptr;

   class nat
   {
      public:
      Pointer get_ptr() const
      { return Pointer(); }
   };
   typedef typename dtl::if_c< IsConst
                             , vec_iterator<Pointer, false>
                             , nat>::type nonconst_iterator;

   public:
   inline __attribute__ ((__always_inline__))
      const Pointer &get_ptr() const noexcept
   { return m_ptr; }

   inline __attribute__ ((__always_inline__))
      Pointer &get_ptr() noexcept
   { return m_ptr; }

   inline __attribute__ ((__always_inline__)) explicit vec_iterator(Pointer ptr) noexcept
      : m_ptr(ptr)
   {}


   public:


   inline __attribute__ ((__always_inline__)) vec_iterator() noexcept
      : m_ptr()
   {}

   inline __attribute__ ((__always_inline__)) vec_iterator(const vec_iterator& other) noexcept
      : m_ptr(other.get_ptr())
   {}

   inline __attribute__ ((__always_inline__)) vec_iterator(const nonconst_iterator &other) noexcept
      : m_ptr(other.get_ptr())
   {}

   inline __attribute__ ((__always_inline__)) vec_iterator & operator=(const vec_iterator& other) noexcept
   { m_ptr = other.get_ptr(); return *this; }


   [[nodiscard]] inline __attribute__ ((__always_inline__))
      reference operator*() const noexcept
   { (static_cast <bool> (!!m_ptr) ? void (0) : __assert_fail ("!!m_ptr", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); return *m_ptr; }

   [[nodiscard]] inline __attribute__ ((__always_inline__))
      pointer operator->() const noexcept
   { return m_ptr; }

   [[nodiscard]] inline __attribute__ ((__always_inline__))
      reference operator[](difference_type off) const noexcept
   { (static_cast <bool> (!!m_ptr) ? void (0) : __assert_fail ("!!m_ptr", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); return m_ptr[off]; }


   inline __attribute__ ((__always_inline__)) vec_iterator& operator++() noexcept
   { (static_cast <bool> (!!m_ptr) ? void (0) : __assert_fail ("!!m_ptr", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); ++m_ptr; return *this; }

   inline __attribute__ ((__always_inline__)) vec_iterator operator++(int) noexcept
   { (static_cast <bool> (!!m_ptr) ? void (0) : __assert_fail ("!!m_ptr", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); return vec_iterator(m_ptr++); }

   inline __attribute__ ((__always_inline__)) vec_iterator& operator--() noexcept
   { (static_cast <bool> (!!m_ptr) ? void (0) : __assert_fail ("!!m_ptr", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); --m_ptr; return *this; }

   inline __attribute__ ((__always_inline__)) vec_iterator operator--(int) noexcept
   { (static_cast <bool> (!!m_ptr) ? void (0) : __assert_fail ("!!m_ptr", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); return vec_iterator(m_ptr--); }


   inline __attribute__ ((__always_inline__)) vec_iterator& operator+=(difference_type off) noexcept
   { (static_cast <bool> (m_ptr || !off) ? void (0) : __assert_fail ("m_ptr || !off", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); m_ptr += off; return *this; }

   inline __attribute__ ((__always_inline__)) vec_iterator& operator-=(difference_type off) noexcept
   { (static_cast <bool> (m_ptr || !off) ? void (0) : __assert_fail ("m_ptr || !off", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); m_ptr -= off; return *this; }

   [[nodiscard]] inline __attribute__ ((__always_inline__))
      friend vec_iterator operator+(const vec_iterator &x, difference_type off) noexcept
   { (static_cast <bool> (x.m_ptr || !off) ? void (0) : __assert_fail ("x.m_ptr || !off", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); return vec_iterator(x.m_ptr+off); }

   [[nodiscard]] inline __attribute__ ((__always_inline__))
      friend vec_iterator operator+(difference_type off, vec_iterator right) noexcept
   { (static_cast <bool> (right.m_ptr || !off) ? void (0) : __assert_fail ("right.m_ptr || !off", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); right.m_ptr += off; return right; }

   [[nodiscard]] inline __attribute__ ((__always_inline__))
      friend vec_iterator operator-(vec_iterator left, difference_type off) noexcept
   { (static_cast <bool> (left.m_ptr || !off) ? void (0) : __assert_fail ("left.m_ptr || !off", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); left.m_ptr -= off; return left; }


   [[nodiscard]] inline __attribute__ ((__always_inline__))
      friend difference_type operator-(const vec_iterator &left, const vec_iterator& right) noexcept
   { return left.m_ptr - right.m_ptr; }


   [[nodiscard]] inline __attribute__ ((__always_inline__))
      friend bool operator== (const vec_iterator& l, const vec_iterator& r) noexcept
   { return l.m_ptr == r.m_ptr; }

   [[nodiscard]] inline __attribute__ ((__always_inline__))
      friend bool operator!= (const vec_iterator& l, const vec_iterator& r) noexcept
   { return l.m_ptr != r.m_ptr; }

   [[nodiscard]] inline __attribute__ ((__always_inline__))
      friend bool operator< (const vec_iterator& l, const vec_iterator& r) noexcept
   { return l.m_ptr < r.m_ptr; }

   [[nodiscard]] inline __attribute__ ((__always_inline__))
      friend bool operator<= (const vec_iterator& l, const vec_iterator& r) noexcept
   { return l.m_ptr <= r.m_ptr; }

   [[nodiscard]] inline __attribute__ ((__always_inline__))
      friend bool operator> (const vec_iterator& l, const vec_iterator& r) noexcept
   { return l.m_ptr > r.m_ptr; }

   [[nodiscard]] inline __attribute__ ((__always_inline__))
      friend bool operator>= (const vec_iterator& l, const vec_iterator& r) noexcept
   { return l.m_ptr >= r.m_ptr; }
};

template<class BiDirPosConstIt, class BiDirValueIt>
struct vector_insert_ordered_cursor
{
   typedef typename iterator_traits<BiDirPosConstIt>::value_type size_type;
   typedef typename iterator_traits<BiDirValueIt>::reference reference;

   inline __attribute__ ((__always_inline__)) vector_insert_ordered_cursor(BiDirPosConstIt posit, BiDirValueIt valueit)
      : last_position_it(posit), last_value_it(valueit)
   {}

   void operator --()
   {
      --last_value_it;
      --last_position_it;
      while(this->get_pos() == size_type(-1)){
         --last_value_it;
         --last_position_it;
      }
   }

   inline __attribute__ ((__always_inline__)) size_type get_pos() const
   { return *last_position_it; }

   inline __attribute__ ((__always_inline__)) reference get_val()
   { return *last_value_it; }

   BiDirPosConstIt last_position_it;
   BiDirValueIt last_value_it;
};

template<class Pointer, bool IsConst>
inline __attribute__ ((__always_inline__)) const Pointer &vector_iterator_get_ptr(const vec_iterator<Pointer, IsConst> &it) noexcept
{ return it.get_ptr(); }

template<class Pointer, bool IsConst>
inline __attribute__ ((__always_inline__)) Pointer &get_ptr(vec_iterator<Pointer, IsConst> &it) noexcept
{ return it.get_ptr(); }

struct initial_capacity_t {};

struct vector_uninitialized_size_t {};
static const vector_uninitialized_size_t vector_uninitialized_size = vector_uninitialized_size_t();

struct maybe_initial_capacity_t {};

template <class T>
struct vector_value_traits_base
{
   static const bool trivial_dctr = dtl::is_trivially_destructible<T>::value;
   static const bool trivial_dctr_after_move = has_trivial_destructor_after_move<T>::value;
};

template <class Allocator>
struct vector_value_traits
   : public vector_value_traits_base<typename Allocator::value_type>
{
   typedef vector_value_traits_base<typename Allocator::value_type> base_t;


   typedef typename dtl::if_c
      <base_t::trivial_dctr
      ,dtl::null_scoped_destructor_n<Allocator>
      ,dtl::scoped_destructor_n<Allocator>
      >::type ArrayDestructor;

   typedef dtl::scoped_array_deallocator<Allocator> ArrayDeallocator;
};


template < class Allocator
         , class StoredSizeType
         , class AllocatorVersion = typename dtl::version<Allocator>::type
         >
struct vector_alloc_holder
   : public Allocator
{
   private:
   public: vector_alloc_holder(vector_alloc_holder const &) = delete; vector_alloc_holder& operator=(vector_alloc_holder const &) = delete; public: typedef int boost_move_no_copy_constructor_or_assign; private: public: typedef int boost_move_emulation_t; private:

   public:
   typedef Allocator allocator_type;
   typedef StoredSizeType stored_size_type;
   typedef boost::container::allocator_traits<allocator_type> allocator_traits_type;
   typedef typename allocator_traits_type::pointer pointer;
   typedef typename allocator_traits_type::size_type size_type;
   typedef typename allocator_traits_type::value_type value_type;


   private:

   template<class SizeType>
   void do_initial_capacity(SizeType initial_capacity)
   {
      if (__builtin_expect(initial_capacity > size_type(-1), 0)) {
         boost::container::throw_length_error("get_next_capacity, allocator's max size reached");
      }
      else if (initial_capacity) {
         pointer reuse = pointer();
         size_type final_cap = static_cast<size_type>(initial_capacity);
         m_start = this->allocation_command(allocate_new, final_cap, final_cap, reuse);
         this->set_stored_capacity(final_cap);
      }
   }

   template<class SizeType>
   void do_maybe_initial_capacity(pointer p, SizeType initial_capacity)
   {
      if (__builtin_expect(initial_capacity > size_type(-1), 0)) {
         boost::container::throw_length_error("get_next_capacity, allocator's max size reached");
      }
      else if (p) {
         m_start = p;
      }
      else {
         (static_cast <bool> (initial_capacity > 0) ? void (0) : __assert_fail ("initial_capacity > 0", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
         pointer reuse = pointer();
         size_type final_cap = static_cast<size_type>(initial_capacity);
         m_start = this->allocation_command(allocate_new, final_cap, final_cap, reuse);
         this->set_stored_capacity(final_cap);
      }
   }

   public:

   inline __attribute__ ((__always_inline__))
      static bool is_propagable_from(const allocator_type &from_alloc, pointer p, const allocator_type &to_alloc, bool const propagate_allocator)
   {
      (void)propagate_allocator; (void)p; (void)to_alloc; (void)from_alloc;
      const bool all_storage_propagable = !allocator_traits_type::is_partially_propagable::value ||
                                          !allocator_traits_type::storage_is_unpropagable(from_alloc, p);
      return all_storage_propagable &&
         (propagate_allocator || allocator_traits_type::is_always_equal::value || allocator_traits_type::equal(from_alloc, to_alloc));
   }

   inline __attribute__ ((__always_inline__))
      static bool are_swap_propagable(const allocator_type &l_a, pointer l_p, const allocator_type &r_a, pointer r_p, bool const propagate_allocator)
   {
      (void)propagate_allocator; (void)l_p; (void)r_p; (void)l_a; (void)r_a;
      const bool all_storage_propagable = !allocator_traits_type::is_partially_propagable::value ||
              !(allocator_traits_type::storage_is_unpropagable(l_a, l_p) || allocator_traits_type::storage_is_unpropagable(r_a, r_p));
      return all_storage_propagable && (propagate_allocator || allocator_traits_type::equal(l_a, r_a));
   }


   vector_alloc_holder()
      noexcept((dtl::is_nothrow_default_constructible<allocator_type>::value))
      : allocator_type(), m_start(), m_size(), m_capacity()
   {}


   template<class AllocConvertible>
   explicit vector_alloc_holder(AllocConvertible && a) noexcept
      : allocator_type(boost::forward<AllocConvertible>(a)), m_start(), m_size(), m_capacity()
   {}


   template<class AllocConvertible, class SizeType>
   vector_alloc_holder(vector_uninitialized_size_t, AllocConvertible && a, SizeType initial_size)
      : allocator_type(boost::forward<AllocConvertible>(a))
      , m_start()

      , m_size(static_cast<stored_size_type>(initial_size))
      , m_capacity()
   { this->do_initial_capacity(initial_size); }

   template<class SizeType>
   vector_alloc_holder(vector_uninitialized_size_t, SizeType initial_size)
      : allocator_type()
      , m_start()

      , m_size(static_cast<stored_size_type>(initial_size))
      , m_capacity()
   { this->do_initial_capacity(initial_size); }

   vector_alloc_holder(initial_capacity_t, pointer p, size_type n)
      noexcept((dtl::is_nothrow_default_constructible<allocator_type>::value))
      : allocator_type()
      , m_start(p)
      , m_size()

      , m_capacity(static_cast<stored_size_type>(n))
   {}

   template<class AllocFwd>
   vector_alloc_holder(initial_capacity_t, pointer p, size_type n, AllocFwd && a)
      : allocator_type(::boost::forward<AllocFwd>(a))
      , m_start(p)
      , m_size()
      , m_capacity(n)
   {}

   template<class AllocConvertible, class SizeType>
   vector_alloc_holder(maybe_initial_capacity_t, pointer p, SizeType initial_capacity, AllocConvertible && a)
      : allocator_type(boost::forward<AllocConvertible>(a))


      , m_size()
      , m_capacity(static_cast<stored_size_type>(initial_capacity))
   { this->do_maybe_initial_capacity(p, initial_capacity); }

   template<class SizeType>
   vector_alloc_holder(maybe_initial_capacity_t, pointer p, SizeType initial_capacity)
      : allocator_type()


      , m_size()
      , m_capacity(static_cast<stored_size_type>(initial_capacity))
   { this->do_maybe_initial_capacity(p, initial_capacity); }

   vector_alloc_holder(vector_alloc_holder && holder) noexcept
      : allocator_type(::boost::move((allocator_type&)(holder)))
      , m_start(holder.m_start)
      , m_size(holder.m_size)
      , m_capacity(holder.m_capacity)
   {
      holder.m_start = pointer();
      holder.m_size = holder.m_capacity = 0;
   }

   inline __attribute__ ((__always_inline__)) ~vector_alloc_holder() noexcept
   {
      if(this->m_capacity){
         this->deallocate(this->m_start, this->m_capacity);
      }
   }

   inline __attribute__ ((__always_inline__)) void set_stored_size(size_type s) noexcept
      { this->m_size = static_cast<stored_size_type>(s); }

   inline __attribute__ ((__always_inline__)) void dec_stored_size(size_type s) noexcept
      { this->m_size = static_cast<stored_size_type>(this->m_size - s); }

   inline __attribute__ ((__always_inline__)) void inc_stored_size(size_type s) noexcept
      { this->m_size = static_cast<stored_size_type>(this->m_size + s); }

   inline __attribute__ ((__always_inline__)) void set_stored_capacity(size_type c) noexcept
      { this->m_capacity = static_cast<stored_size_type>(c); }

   inline __attribute__ ((__always_inline__)) pointer allocation_command(boost::container::allocation_type command,
                                 size_type limit_size, size_type &prefer_in_recvd_out_size, pointer &reuse)
   {
      typedef typename dtl::version<allocator_type>::type alloc_version;
      return this->priv_allocation_command(alloc_version(), command, limit_size, prefer_in_recvd_out_size, reuse);
   }

   inline __attribute__ ((__always_inline__)) pointer allocate(size_type n)
   {
      const size_type max_alloc = allocator_traits_type::max_size(this->alloc());
      const size_type max = max_alloc <= stored_size_type(-1) ? max_alloc : stored_size_type(-1);
      if (__builtin_expect(max < n, 0) )
         boost::container::throw_length_error("get_next_capacity, allocator's max size reached");

      return allocator_traits_type::allocate(this->alloc(), n);
   }

   inline __attribute__ ((__always_inline__)) void deallocate(const pointer &p, size_type n)
   {
      allocator_traits_type::deallocate(this->alloc(), p, n);
   }

   bool try_expand_fwd(size_type at_least)
   {

      const size_type new_cap = size_type(this->capacity() + at_least);
      size_type real_cap = new_cap;
      pointer reuse = this->start();
      bool const success = !!this->allocation_command(expand_fwd, new_cap, real_cap, reuse);

      if(success){



         this->capacity(real_cap);
      }
      return success;
   }

   template<class GrowthFactorType>
   size_type next_capacity(size_type additional_objects) const
   {
      (static_cast <bool> (additional_objects > size_type(this->m_capacity - this->m_size)) ? void (0) : __assert_fail ("additional_objects > size_type(this->m_capacity - this->m_size)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      size_type max = allocator_traits_type::max_size(this->alloc());
      (clamp_by_stored_size_type<size_type>)(max, stored_size_type());
      const size_type remaining_cap = size_type(max - size_type(this->m_capacity));
      const size_type min_additional_cap = size_type(additional_objects - size_type(this->m_capacity - this->m_size));

      if ( remaining_cap < min_additional_cap )
         boost::container::throw_length_error("get_next_capacity, allocator's max size reached");

      return GrowthFactorType()( size_type(this->m_capacity), min_additional_cap, max);
   }

   pointer m_start;
   stored_size_type m_size;
   stored_size_type m_capacity;

   void swap_resources(vector_alloc_holder &x) noexcept
   {
      boost::adl_move_swap(this->m_start, x.m_start);
      boost::adl_move_swap(this->m_size, x.m_size);
      boost::adl_move_swap(this->m_capacity, x.m_capacity);
   }

   void steal_resources(vector_alloc_holder &x) noexcept
   {
      this->m_start = x.m_start;
      this->m_size = x.m_size;
      this->m_capacity = x.m_capacity;
      x.m_start = pointer();
      x.m_size = x.m_capacity = 0;
   }

   inline __attribute__ ((__always_inline__)) allocator_type &alloc() noexcept
   { return *this; }

   inline __attribute__ ((__always_inline__)) const allocator_type &alloc() const noexcept
   { return *this; }

   inline __attribute__ ((__always_inline__)) const pointer &start() const noexcept
      { return m_start; }
   inline __attribute__ ((__always_inline__)) size_type capacity() const noexcept
      { return m_capacity; }
   inline __attribute__ ((__always_inline__)) void start(const pointer &p) noexcept
      { m_start = p; }
   inline __attribute__ ((__always_inline__)) void capacity(const size_type &c) noexcept
      { (static_cast <bool> (c <= stored_size_type(-1)) ? void (0) : __assert_fail ("c <= stored_size_type(-1)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); this->set_stored_capacity(c); }

   static inline __attribute__ ((__always_inline__)) void on_capacity_overflow()
   { }

   private:
   void priv_first_allocation(size_type cap)
   {
      if(cap){
         pointer reuse = pointer();
         m_start = this->allocation_command(allocate_new, cap, cap, reuse);
         m_capacity = cap;



      }
   }

   pointer priv_allocation_command(version_1, boost::container::allocation_type command,
                         size_type limit_size,
                         size_type &prefer_in_recvd_out_size,
                         pointer &reuse)
   {
      (void)command;
      (static_cast <bool> ((command & allocate_new)) ? void (0) : __assert_fail ("(command & allocate_new)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      (static_cast <bool> (!(command & nothrow_allocation)) ? void (0) : __assert_fail ("!(command & nothrow_allocation)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));

      if (__builtin_expect(limit_size > stored_size_type(-1), 0)){
         boost::container::throw_length_error("get_next_capacity, allocator's max size reached");
      }
      (clamp_by_stored_size_type<size_type>)(prefer_in_recvd_out_size, stored_size_type());
      pointer const p = this->allocate(prefer_in_recvd_out_size);
      reuse = pointer();
      return p;
   }

   pointer priv_allocation_command(version_2, boost::container::allocation_type command,
                         size_type limit_size,
                         size_type &prefer_in_recvd_out_size,
                         pointer &reuse)
   {

      if (__builtin_expect(limit_size > stored_size_type(-1), 0)){
         boost::container::throw_length_error("get_next_capacity, allocator's max size reached");
      }
      (clamp_by_stored_size_type<size_type>)(prefer_in_recvd_out_size, stored_size_type());

      pointer p = this->alloc().allocation_command(command, limit_size, prefer_in_recvd_out_size, reuse);

      (clamp_by_stored_size_type<size_type>)(prefer_in_recvd_out_size, stored_size_type());
      return p;
   }
};


template <class Allocator, class StoredSizeType>
struct vector_alloc_holder<Allocator, StoredSizeType, version_0>
   : public Allocator
{
   private:
   public: vector_alloc_holder(vector_alloc_holder const &) = delete; vector_alloc_holder& operator=(vector_alloc_holder const &) = delete; public: typedef int boost_move_no_copy_constructor_or_assign; private: public: typedef int boost_move_emulation_t; private:

   public:
   typedef Allocator allocator_type;
   typedef boost::container::
      allocator_traits<allocator_type> allocator_traits_type;
   typedef typename allocator_traits_type::pointer pointer;
   typedef typename allocator_traits_type::size_type size_type;
   typedef typename allocator_traits_type::value_type value_type;
   typedef StoredSizeType stored_size_type;

   template <class OtherAllocator, class OtherStoredSizeType, class OtherAllocatorVersion>
   friend struct vector_alloc_holder;


   vector_alloc_holder()
      noexcept((dtl::is_nothrow_default_constructible<allocator_type>::value))
      : allocator_type(), m_size()
   {}


   template<class AllocConvertible>
   explicit vector_alloc_holder(AllocConvertible && a) noexcept
      : allocator_type(boost::forward<AllocConvertible>(a)), m_size()
   {}


   template<class AllocConvertible>
   vector_alloc_holder(vector_uninitialized_size_t, AllocConvertible && a, size_type initial_size)
      : allocator_type(boost::forward<AllocConvertible>(a))
      , m_size(initial_size)
   {

      this->priv_first_allocation(initial_size);
   }


   vector_alloc_holder(vector_uninitialized_size_t, size_type initial_size)
      : allocator_type()
      , m_size(initial_size)
   {

      this->priv_first_allocation(initial_size);
   }

   vector_alloc_holder(vector_alloc_holder && holder)
      : allocator_type(::boost::move((allocator_type&)(holder)))
      , m_size(holder.m_size)
   {
      ::boost::container::uninitialized_move_alloc_n
         (this->alloc(), boost::movelib::to_raw_pointer(holder.start()), m_size, boost::movelib::to_raw_pointer(this->start()));
      ::boost::container::destroy_alloc_n
         (this->alloc(), boost::movelib::to_raw_pointer(holder.start()), m_size);
      holder.m_size = 0;
   }

   template<class OtherAllocator, class OtherStoredSizeType, class OtherAllocatorVersion>
   vector_alloc_holder( vector_alloc_holder<OtherAllocator, OtherStoredSizeType, OtherAllocatorVersion> && holder)
      : allocator_type()
      , m_size(holder.m_size)
   {

      const size_type n = holder.m_size;
      this->priv_first_allocation(n);
      ::boost::container::uninitialized_move_alloc_n
         (this->alloc(), boost::movelib::to_raw_pointer(holder.start()), n, boost::movelib::to_raw_pointer(this->start()));
   }

   static inline __attribute__ ((__always_inline__)) void on_capacity_overflow()
   { allocator_type::on_capacity_overflow(); }

   inline __attribute__ ((__always_inline__)) void set_stored_size(size_type s) noexcept
      { this->m_size = static_cast<stored_size_type>(s); }

   inline __attribute__ ((__always_inline__)) void dec_stored_size(size_type s) noexcept
      { this->m_size = static_cast<stored_size_type>(this->m_size - s); }

   inline __attribute__ ((__always_inline__)) void inc_stored_size(size_type s) noexcept
      { this->m_size = static_cast<stored_size_type>(this->m_size + s); }

   inline __attribute__ ((__always_inline__)) void priv_first_allocation(size_type cap)
   {
      if(cap > allocator_type::internal_capacity){
         on_capacity_overflow();
      }
   }

   inline __attribute__ ((__always_inline__)) void deep_swap(vector_alloc_holder &x)
      { this->priv_deep_swap(x); }

   template<class OtherAllocator, class OtherStoredSizeType, class OtherAllocatorVersion>
   void deep_swap(vector_alloc_holder<OtherAllocator, OtherStoredSizeType, OtherAllocatorVersion> &x)
   {
      typedef typename real_allocator<value_type, OtherAllocator>::type other_allocator_type;
      if(this->m_size > other_allocator_type::internal_capacity || x.m_size > allocator_type::internal_capacity){
         on_capacity_overflow();
      }
      this->priv_deep_swap(x);
   }

   inline __attribute__ ((__always_inline__)) void swap_resources(vector_alloc_holder &) noexcept
   {
      on_capacity_overflow();
   }

   inline __attribute__ ((__always_inline__)) void steal_resources(vector_alloc_holder &)
   {
      on_capacity_overflow();
   }

   inline __attribute__ ((__always_inline__)) allocator_type &alloc() noexcept
   { return *this; }

   inline __attribute__ ((__always_inline__)) const allocator_type &alloc() const noexcept
   { return *this; }

   inline __attribute__ ((__always_inline__)) bool try_expand_fwd(size_type at_least)
   { return !at_least; }

   inline __attribute__ ((__always_inline__)) pointer start() const noexcept
   { return allocator_type::internal_storage(); }

   inline __attribute__ ((__always_inline__)) size_type capacity() const noexcept
   { return allocator_type::internal_capacity; }

   stored_size_type m_size;

   private:

   template<class OtherAllocator, class OtherStoredSizeType, class OtherAllocatorVersion>
   void priv_deep_swap(vector_alloc_holder<OtherAllocator, OtherStoredSizeType, OtherAllocatorVersion> &x)
   {
      const size_type MaxTmpStorage = sizeof(value_type)*allocator_type::internal_capacity;
      value_type *const first_this = boost::movelib::to_raw_pointer(this->start());
      value_type *const first_x = boost::movelib::to_raw_pointer(x.start());

      if(this->m_size < x.m_size){
         boost::container::deep_swap_alloc_n<MaxTmpStorage>(this->alloc(), first_this, this->m_size, first_x, x.m_size);
      }
      else{
         boost::container::deep_swap_alloc_n<MaxTmpStorage>(this->alloc(), first_x, x.m_size, first_this, this->m_size);
      }
      boost::adl_move_swap(this->m_size, x.m_size);
   }
};

struct growth_factor_60;
struct growth_factor_100;

template<class Options, class AllocatorSizeType>
struct get_vector_opt
{
   typedef vector_opt< typename default_if_void<typename Options::growth_factor_type, growth_factor_60>::type
                     , typename default_if_void<typename Options::stored_size_type, AllocatorSizeType>::type
                     > type;
};

template<class AllocatorSizeType>
struct get_vector_opt<void, AllocatorSizeType>
{
   typedef vector_opt<growth_factor_60, AllocatorSizeType> type;
};
# 789 "/usr/include/boost/container/vector.hpp" 3 4
template <class T, class A , class Options >
class vector
{
public:





   typedef T value_type;
   typedef typename real_allocator<T , A>::type allocator_type;

   typedef ::boost::container::allocator_traits<allocator_type> allocator_traits_t;
   typedef typename allocator_traits<allocator_type>::pointer pointer;
   typedef typename allocator_traits<allocator_type>::const_pointer const_pointer;
   typedef typename allocator_traits<allocator_type>::reference reference;
   typedef typename allocator_traits<allocator_type>::const_reference const_reference;
   typedef typename allocator_traits<allocator_type>::size_type size_type;
   typedef typename allocator_traits<allocator_type>::difference_type difference_type;
   typedef allocator_type stored_allocator_type;
   typedef vec_iterator<pointer , false> iterator;
   typedef vec_iterator<pointer , true > const_iterator;
   typedef boost::container::reverse_iterator<iterator> reverse_iterator;
   typedef boost::container::reverse_iterator<const_iterator> const_reverse_iterator;

private:


   typedef typename boost::container::
      allocator_traits<allocator_type>::size_type alloc_size_type;
   typedef typename get_vector_opt<Options, alloc_size_type>::type options_type;
   typedef typename options_type::growth_factor_type growth_factor_type;
   typedef typename options_type::stored_size_type stored_size_type;
   typedef value_less<T> value_less_t;


   static_assert((sizeof(stored_size_type) < sizeof(alloc_size_type) || dtl::is_same<stored_size_type, alloc_size_type>::value), "(sizeof(stored_size_type) < sizeof(alloc_size_type) || dtl::is_same<stored_size_type, alloc_size_type>::value)");


   typedef typename dtl::version<allocator_type>::type alloc_version;
   typedef boost::container::vector_alloc_holder
      <allocator_type, stored_size_type> alloc_holder_t;

   alloc_holder_t m_holder;

   typedef allocator_traits<allocator_type> allocator_traits_type;
   template <class U, class UA, class UOptions>
   friend class vector;


   protected:
   inline __attribute__ ((__always_inline__))
      static bool is_propagable_from(const allocator_type &from_alloc, pointer p, const allocator_type &to_alloc, bool const propagate_allocator)
   { return alloc_holder_t::is_propagable_from(from_alloc, p, to_alloc, propagate_allocator); }

   inline __attribute__ ((__always_inline__))
      static bool are_swap_propagable( const allocator_type &l_a, pointer l_p
                                     , const allocator_type &r_a, pointer r_p, bool const propagate_allocator)
   { return alloc_holder_t::are_swap_propagable(l_a, l_p, r_a, r_p, propagate_allocator); }



   private:

   typedef vector_value_traits<allocator_type> value_traits;
   typedef constant_iterator<T> cvalue_iterator;

   protected:

   inline __attribute__ ((__always_inline__)) void steal_resources(vector &x)
   { return this->m_holder.steal_resources(x.m_holder); }

   inline __attribute__ ((__always_inline__)) void protected_set_size(size_type n)
   { this->m_holder.m_size = static_cast<stored_size_type>(n); }

   template<class AllocFwd>
   inline __attribute__ ((__always_inline__)) vector(initial_capacity_t, pointer initial_memory, size_type cap, AllocFwd && a)
      : m_holder(initial_capacity_t(), initial_memory, cap, ::boost::forward<AllocFwd>(a))
   {}

   inline __attribute__ ((__always_inline__)) vector(initial_capacity_t, pointer initial_memory, size_type cap)
      : m_holder(initial_capacity_t(), initial_memory, cap)
   {}

   template<class SizeType, class AllocFwd>
   inline __attribute__ ((__always_inline__)) vector(maybe_initial_capacity_t, pointer p, SizeType initial_capacity, AllocFwd && a)
      : m_holder(maybe_initial_capacity_t(), p, initial_capacity, ::boost::forward<AllocFwd>(a))
   {



   }

   template<class SizeType>
   inline __attribute__ ((__always_inline__)) vector(maybe_initial_capacity_t, pointer p, SizeType initial_capacity)
      : m_holder(maybe_initial_capacity_t(), p, initial_capacity)
   {



   }

   template <class U>
   void protected_init_n(const size_type new_size, const U& u)
   {
      (static_cast <bool> (this->empty()) ? void (0) : __assert_fail ("this->empty()", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      this->priv_resize_proxy(u).uninitialized_copy_n_and_update(this->m_holder.alloc(), this->priv_raw_begin(), new_size);
      this->m_holder.set_stored_size(new_size);
   }



   public:
# 913 "/usr/include/boost/container/vector.hpp" 3 4
   vector() noexcept((dtl::is_nothrow_default_constructible<allocator_type>::value))
      : m_holder()
   {}






   explicit vector(const allocator_type& a) noexcept
      : m_holder(a)
   {}







   explicit vector(size_type n)
      : m_holder(vector_uninitialized_size, n)
   {



      boost::container::uninitialized_value_init_alloc_n
         (this->m_holder.alloc(), n, this->priv_raw_begin());
   }
# 949 "/usr/include/boost/container/vector.hpp" 3 4
   explicit vector(size_type n, const allocator_type &a)
      : m_holder(vector_uninitialized_size, a, n)
   {



      boost::container::uninitialized_value_init_alloc_n
         (this->m_holder.alloc(), n, this->priv_raw_begin());
   }
# 968 "/usr/include/boost/container/vector.hpp" 3 4
   vector(size_type n, default_init_t)
      : m_holder(vector_uninitialized_size, n)
   {



      boost::container::uninitialized_default_init_alloc_n
         (this->m_holder.alloc(), n, this->priv_raw_begin());
   }
# 987 "/usr/include/boost/container/vector.hpp" 3 4
   vector(size_type n, default_init_t, const allocator_type &a)
      : m_holder(vector_uninitialized_size, a, n)
   {



      boost::container::uninitialized_default_init_alloc_n
         (this->m_holder.alloc(), n, this->priv_raw_begin());
   }
# 1004 "/usr/include/boost/container/vector.hpp" 3 4
   vector(size_type n, const T& value)
      : m_holder(vector_uninitialized_size, n)
   {



      boost::container::uninitialized_fill_alloc_n
         (this->m_holder.alloc(), value, n, this->priv_raw_begin());
   }
# 1021 "/usr/include/boost/container/vector.hpp" 3 4
   vector(size_type n, const T& value, const allocator_type& a)
      : m_holder(vector_uninitialized_size, a, n)
   {



      boost::container::uninitialized_fill_alloc_n
         (this->m_holder.alloc(), value, n, this->priv_raw_begin());
   }
# 1044 "/usr/include/boost/container/vector.hpp" 3 4
   template <class InIt>
   vector(InIt first, InIt last
      , typename dtl::disable_if_c < dtl::is_convertible<InIt , size_type>::value , dtl::nat >::type * = 0


      )
      : m_holder()
   { this->assign(first, last); }
# 1060 "/usr/include/boost/container/vector.hpp" 3 4
   template <class InIt>
   vector(InIt first, InIt last, const allocator_type& a
      , typename dtl::disable_if_c < dtl::is_convertible<InIt , size_type>::value , dtl::nat >::type * = 0


      )
      : m_holder(a)
   { this->assign(first, last); }
# 1077 "/usr/include/boost/container/vector.hpp" 3 4
   vector(const vector &x)
      : m_holder( vector_uninitialized_size
                 , allocator_traits_type::select_on_container_copy_construction(x.m_holder.alloc())
                 , x.size())
   {



      ::boost::container::uninitialized_copy_alloc_n
         ( this->m_holder.alloc(), x.priv_raw_begin()
         , x.size(), this->priv_raw_begin());
   }






   vector(vector && x) noexcept
      : m_holder(boost::move(x.m_holder))
   { static_assert((!allocator_traits_type::is_partially_propagable::value), "(!allocator_traits_type::is_partially_propagable::value)"); }
# 1106 "/usr/include/boost/container/vector.hpp" 3 4
   vector(std::initializer_list<value_type> il, const allocator_type& a = allocator_type())
      : m_holder(vector_uninitialized_size, a, il.size())
   {



      ::boost::container::uninitialized_copy_alloc_n_source
         ( this->m_holder.alloc(), il.begin()
         , static_cast<size_type>(il.size()), this->priv_raw_begin());
   }
# 1127 "/usr/include/boost/container/vector.hpp" 3 4
   template<class OtherA>
   vector( vector<T, OtherA, Options> && x
         , typename dtl::enable_if_c
            < dtl::is_version<typename real_allocator<T, OtherA>::type, 0>::value>::type * = 0
         )
      : m_holder(boost::move(x.m_holder))
   {}
# 1145 "/usr/include/boost/container/vector.hpp" 3 4
   vector(const vector &x, const allocator_type &a)
      : m_holder(vector_uninitialized_size, a, x.size())
   {



      ::boost::container::uninitialized_copy_alloc_n_source
         ( this->m_holder.alloc(), x.priv_raw_begin()
         , x.size(), this->priv_raw_begin());
   }
# 1163 "/usr/include/boost/container/vector.hpp" 3 4
   vector(vector && x, const allocator_type &a)
      : m_holder( vector_uninitialized_size, a

                 , is_propagable_from(x.get_stored_allocator(), x.m_holder.start(), a, false) ? 0 : x.size()
                 )
   {

      if(is_propagable_from(x.get_stored_allocator(), x.m_holder.start(), a, false)){
         this->m_holder.steal_resources(x.m_holder);
      }
      else{
         const size_type n = x.size();



         ::boost::container::uninitialized_move_alloc_n_source
            ( this->m_holder.alloc(), x.priv_raw_begin()
            , n, this->priv_raw_begin());
      }
   }







   ~vector() noexcept
   {
      boost::container::destroy_alloc_n
         (this->get_stored_allocator(), this->priv_raw_begin(), this->m_holder.m_size);

   }
# 1205 "/usr/include/boost/container/vector.hpp" 3 4
   inline __attribute__ ((__always_inline__)) vector& operator=(const vector & x)
   {
      if (__builtin_expect(&x != this, 1)){
         this->priv_copy_assign(x);
      }
      return *this;
   }





   inline __attribute__ ((__always_inline__)) vector& operator=(std::initializer_list<value_type> il)
   {
      this->assign(il.begin(), il.end());
      return *this;
   }
# 1235 "/usr/include/boost/container/vector.hpp" 3 4
   inline __attribute__ ((__always_inline__)) vector& operator=(vector && x)
      noexcept((allocator_traits_type::propagate_on_container_move_assignment::value || allocator_traits_type::is_always_equal::value))

   {
      if (__builtin_expect(&x != this, 1)){
         this->priv_move_assign(boost::move(x));
      }
      return *this;
   }
# 1257 "/usr/include/boost/container/vector.hpp" 3 4
   template<class OtherA>
   inline __attribute__ ((__always_inline__)) typename dtl::enable_if_and
                           < vector&
                           , dtl::is_version<typename real_allocator<T, OtherA>::type, 0>
                           , dtl::is_different<typename real_allocator<T, OtherA>::type, allocator_type>
                           >::type
      operator=( vector<value_type, OtherA, Options> && x)
   {
      this->priv_move_assign(boost::move(x));
      return *this;
   }
# 1279 "/usr/include/boost/container/vector.hpp" 3 4
   template<class OtherA>
   inline __attribute__ ((__always_inline__)) typename dtl::enable_if_and
                           < vector&
                           , dtl::is_version<typename real_allocator<T, OtherA>::type, 0>
                           , dtl::is_different<typename real_allocator<T, OtherA>::type, allocator_type>
                           >::type
      operator=(const vector<value_type, OtherA, Options> &x)
   {
      this->priv_copy_assign(x);
      return *this;
   }
# 1299 "/usr/include/boost/container/vector.hpp" 3 4
   template <class InIt>
   void assign(InIt first, InIt last

      , typename dtl::disable_if_or < void , dtl::is_convertible<InIt , size_type> , dtl::and_ < dtl::is_different<alloc_version , version_0> , dtl::is_not_input_iterator<InIt> > >::type * = 0







      )
   {

      iterator cur = this->begin();
      const iterator end_it = this->end();
      for ( ; first != last && cur != end_it; ++cur, ++first){
         *cur = *first;
      }

      if (first == last){

         T* const end_pos = this->priv_raw_end();
         const size_type n = static_cast<size_type>(end_pos - boost::movelib::iterator_to_raw_pointer(cur));
         this->priv_destroy_last_n(n);
      }
      else{

         this->insert(this->cend(), first, last);
      }
   }







   inline __attribute__ ((__always_inline__)) void assign(std::initializer_list<T> il)
   {
      this->assign(il.begin(), il.end());
   }
# 1349 "/usr/include/boost/container/vector.hpp" 3 4
   template <class FwdIt>
   void assign(FwdIt first, FwdIt last

      , typename dtl::disable_if_or < void , dtl::is_same<alloc_version , version_0> , dtl::is_convertible<FwdIt , size_type> , dtl::is_input_iterator<FwdIt> >::type * = 0





      )
   {
      typedef typename iter_size<FwdIt>::type it_size_type;


      const it_size_type sz = boost::container::iterator_udistance(first, last);
      if (__builtin_expect(sz > size_type(-1), 0)){
         boost::container::throw_length_error("vector::assign, FwdIt's max length reached");
      }

      const size_type input_sz = static_cast<size_type>(sz);
      const size_type old_capacity = this->capacity();
      if(input_sz > old_capacity){
         size_type real_cap = 0;
         pointer reuse(this->m_holder.start());
         pointer const ret(this->m_holder.allocation_command(allocate_new|expand_fwd, input_sz, real_cap = input_sz, reuse));
         if(!reuse){



            pointer const old_p = this->m_holder.start();
            if(old_p){
               this->priv_destroy_all();
               this->m_holder.deallocate(old_p, old_capacity);
            }
            this->m_holder.start(ret);
            this->m_holder.capacity(real_cap);
            this->m_holder.m_size = 0;
            this->priv_uninitialized_construct_at_end(first, last);
            return;
         }
         else{



            this->m_holder.capacity(real_cap);

         }
      }

      boost::container::copy_assign_range_alloc_n(this->m_holder.alloc(), first, input_sz, this->priv_raw_begin(), this->size());
      m_holder.set_stored_size(input_sz);
   }







   inline __attribute__ ((__always_inline__)) void assign(size_type n, const value_type& val)
   { this->assign(cvalue_iterator(val, n), cvalue_iterator()); }






   [[nodiscard]] inline __attribute__ ((__always_inline__)) allocator_type get_allocator() const noexcept
   { return this->m_holder.alloc(); }
# 1426 "/usr/include/boost/container/vector.hpp" 3 4
   [[nodiscard]] inline __attribute__ ((__always_inline__))
      stored_allocator_type &get_stored_allocator() noexcept
   { return this->m_holder.alloc(); }
# 1437 "/usr/include/boost/container/vector.hpp" 3 4
   [[nodiscard]] inline __attribute__ ((__always_inline__))
      const stored_allocator_type &get_stored_allocator() const noexcept
   { return this->m_holder.alloc(); }
# 1452 "/usr/include/boost/container/vector.hpp" 3 4
   [[nodiscard]] inline __attribute__ ((__always_inline__)) iterator begin() noexcept
   { return iterator(this->m_holder.start()); }






   [[nodiscard]] inline __attribute__ ((__always_inline__)) const_iterator begin() const noexcept
   { return const_iterator(this->m_holder.start()); }






   [[nodiscard]] inline __attribute__ ((__always_inline__)) iterator end() noexcept
   {
      iterator it (this->m_holder.start());
      it += difference_type(this->m_holder.m_size);
      return it;
   }






   [[nodiscard]] inline __attribute__ ((__always_inline__)) const_iterator end() const noexcept
   { return this->cend(); }







   [[nodiscard]] inline __attribute__ ((__always_inline__)) reverse_iterator rbegin() noexcept
   { return reverse_iterator(this->end()); }







   [[nodiscard]] inline __attribute__ ((__always_inline__)) const_reverse_iterator rbegin() const noexcept
   { return this->crbegin(); }







   [[nodiscard]] inline __attribute__ ((__always_inline__)) reverse_iterator rend() noexcept
   { return reverse_iterator(this->begin()); }







   [[nodiscard]] inline __attribute__ ((__always_inline__)) const_reverse_iterator rend() const noexcept
   { return this->crend(); }






   [[nodiscard]] inline __attribute__ ((__always_inline__)) const_iterator cbegin() const noexcept
   { return const_iterator(this->m_holder.start()); }






   [[nodiscard]] inline __attribute__ ((__always_inline__)) const_iterator cend() const noexcept
   {
      const_iterator it (this->m_holder.start());
      it += difference_type(this->m_holder.m_size);
      return it;
   }







   [[nodiscard]] inline __attribute__ ((__always_inline__)) const_reverse_iterator crbegin() const noexcept
   { return const_reverse_iterator(this->end());}







   [[nodiscard]] inline __attribute__ ((__always_inline__)) const_reverse_iterator crend() const noexcept
   { return const_reverse_iterator(this->begin()); }
# 1568 "/usr/include/boost/container/vector.hpp" 3 4
   [[nodiscard]] inline __attribute__ ((__always_inline__)) bool empty() const noexcept
   { return !this->m_holder.m_size; }






   [[nodiscard]] inline __attribute__ ((__always_inline__)) size_type size() const noexcept
   { return this->m_holder.m_size; }






   [[nodiscard]] inline __attribute__ ((__always_inline__)) size_type max_size() const noexcept
   { return allocator_traits_type::max_size(this->m_holder.alloc()); }







   inline __attribute__ ((__always_inline__)) void resize(size_type new_size)
   { this->priv_resize(new_size, value_init, alloc_version()); }
# 1604 "/usr/include/boost/container/vector.hpp" 3 4
   inline __attribute__ ((__always_inline__)) void resize(size_type new_size, default_init_t)
   { this->priv_resize(new_size, default_init, alloc_version()); }







   inline __attribute__ ((__always_inline__)) void resize(size_type new_size, const T& x)
   { this->priv_resize(new_size, x, alloc_version()); }







   [[nodiscard]] inline __attribute__ ((__always_inline__)) size_type capacity() const noexcept
   { return this->m_holder.capacity(); }







   inline __attribute__ ((__always_inline__)) void reserve(size_type new_cap)
   {
      if (this->capacity() < new_cap){
         this->priv_move_to_new_buffer(new_cap, alloc_version());
      }
   }







   inline __attribute__ ((__always_inline__)) void shrink_to_fit()
   { this->priv_shrink_to_fit(alloc_version()); }
# 1661 "/usr/include/boost/container/vector.hpp" 3 4
   [[nodiscard]] inline __attribute__ ((__always_inline__)) reference front() noexcept
   {
      (static_cast <bool> (!this->empty()) ? void (0) : __assert_fail ("!this->empty()", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      return *this->m_holder.start();
   }
# 1675 "/usr/include/boost/container/vector.hpp" 3 4
   [[nodiscard]] inline __attribute__ ((__always_inline__)) const_reference front() const noexcept
   {
      (static_cast <bool> (!this->empty()) ? void (0) : __assert_fail ("!this->empty()", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      return *this->m_holder.start();
   }
# 1689 "/usr/include/boost/container/vector.hpp" 3 4
   [[nodiscard]] inline __attribute__ ((__always_inline__)) reference back() noexcept
   {
      (static_cast <bool> (!this->empty()) ? void (0) : __assert_fail ("!this->empty()", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      return this->m_holder.start()[difference_type(this->m_holder.m_size - 1u)];
   }
# 1703 "/usr/include/boost/container/vector.hpp" 3 4
   [[nodiscard]] inline __attribute__ ((__always_inline__)) const_reference back() const noexcept
   {
      (static_cast <bool> (!this->empty()) ? void (0) : __assert_fail ("!this->empty()", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      return this->m_holder.start()[this->m_holder.m_size - 1];
   }
# 1717 "/usr/include/boost/container/vector.hpp" 3 4
   [[nodiscard]] inline __attribute__ ((__always_inline__)) reference operator[](size_type n) noexcept
   {
      (static_cast <bool> (this->m_holder.m_size > n) ? void (0) : __assert_fail ("this->m_holder.m_size > n", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      return this->m_holder.start()[difference_type(n)];
   }
# 1731 "/usr/include/boost/container/vector.hpp" 3 4
   [[nodiscard]] inline __attribute__ ((__always_inline__))
      const_reference operator[](size_type n) const noexcept
   {
      (static_cast <bool> (this->m_holder.m_size > n) ? void (0) : __assert_fail ("this->m_holder.m_size > n", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      return this->m_holder.start()[n];
   }
# 1749 "/usr/include/boost/container/vector.hpp" 3 4
   [[nodiscard]] inline __attribute__ ((__always_inline__))
      iterator nth(size_type n) noexcept
   {
      (static_cast <bool> (this->m_holder.m_size >= n) ? void (0) : __assert_fail ("this->m_holder.m_size >= n", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      return iterator(this->m_holder.start()+difference_type(n));
   }
# 1767 "/usr/include/boost/container/vector.hpp" 3 4
   [[nodiscard]] inline __attribute__ ((__always_inline__))
      const_iterator nth(size_type n) const noexcept
   {
      (static_cast <bool> (this->m_holder.m_size >= n) ? void (0) : __assert_fail ("this->m_holder.m_size >= n", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      return const_iterator(this->m_holder.start()+difference_type(n));
   }
# 1784 "/usr/include/boost/container/vector.hpp" 3 4
   [[nodiscard]] inline __attribute__ ((__always_inline__))
      size_type index_of(iterator p) noexcept
   {

      return this->priv_index_of(vector_iterator_get_ptr(p));
   }
# 1801 "/usr/include/boost/container/vector.hpp" 3 4
   [[nodiscard]] inline __attribute__ ((__always_inline__))
      size_type index_of(const_iterator p) const noexcept
   {

      return this->priv_index_of(vector_iterator_get_ptr(p));
   }
# 1816 "/usr/include/boost/container/vector.hpp" 3 4
   [[nodiscard]] inline __attribute__ ((__always_inline__)) reference at(size_type n)
   {
      this->priv_throw_if_out_of_range(n);
      return this->m_holder.start()[difference_type(n)];
   }
# 1830 "/usr/include/boost/container/vector.hpp" 3 4
   [[nodiscard]] inline __attribute__ ((__always_inline__)) const_reference at(size_type n) const
   {
      this->priv_throw_if_out_of_range(n);
      return this->m_holder.start()[n];
   }
# 1848 "/usr/include/boost/container/vector.hpp" 3 4
   [[nodiscard]] inline __attribute__ ((__always_inline__)) T* data() noexcept
   { return this->priv_raw_begin(); }







   [[nodiscard]] inline __attribute__ ((__always_inline__)) const T * data() const noexcept
   { return this->priv_raw_begin(); }
# 1876 "/usr/include/boost/container/vector.hpp" 3 4
   template<class ...Args>
   inline __attribute__ ((__always_inline__)) reference emplace_back(Args &&...args)
   {
      T* const p = this->priv_raw_end();
      if (__builtin_expect(this->room_enough(), 1)){

         allocator_traits_type::construct(this->m_holder.alloc(), p, ::boost::forward<Args>(args)...);
         ++this->m_holder.m_size;
         return *p;
      }
      else{
         typedef dtl::insert_emplace_proxy<allocator_type, Args...> proxy_t;
         return *this->priv_insert_forward_range_no_capacity
            (p, 1, proxy_t(::boost::forward<Args>(args)...), alloc_version());
      }
   }
# 1901 "/usr/include/boost/container/vector.hpp" 3 4
   template<class ...Args>
   inline __attribute__ ((__always_inline__)) bool stable_emplace_back(Args &&...args)
   {
      const bool is_room_enough = this->room_enough() || (alloc_version::value == 2 && this->m_holder.try_expand_fwd(1u));
      if (__builtin_expect(is_room_enough, 1)){

         allocator_traits_type::construct(this->m_holder.alloc(), this->priv_raw_end(), ::boost::forward<Args>(args)...);
         ++this->m_holder.m_size;
      }
      return is_room_enough;
   }
# 1923 "/usr/include/boost/container/vector.hpp" 3 4
   template<class ...Args>
   inline __attribute__ ((__always_inline__)) iterator emplace(const_iterator position, Args && ...args)
   {
      (static_cast <bool> (this->priv_in_range_or_end(position)) ? void (0) : __assert_fail ("this->priv_in_range_or_end(position)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));

      typedef dtl::insert_emplace_proxy<allocator_type, Args...> proxy_t;
      return this->priv_insert_forward_range( vector_iterator_get_ptr(position), 1
                                            , proxy_t(::boost::forward<Args>(args)...));
   }
# 1996 "/usr/include/boost/container/vector.hpp" 3 4
   inline __attribute__ ((__always_inline__)) void push_back(const T & x) { return priv_push_back(x); } inline __attribute__ ((__always_inline__)) void push_back(T && x) { return priv_push_back(::boost::move(x)); }
# 2020 "/usr/include/boost/container/vector.hpp" 3 4
   inline __attribute__ ((__always_inline__)) iterator insert(const_iterator arg1, const T & x) { return priv_insert(arg1, static_cast<const T&>(x)); } inline __attribute__ ((__always_inline__)) iterator insert(const_iterator arg1, T && x) { return priv_insert(arg1, ::boost::move(x)); }
# 2032 "/usr/include/boost/container/vector.hpp" 3 4
   inline __attribute__ ((__always_inline__)) iterator insert(const_iterator p, size_type n, const T& x)
   {
      (static_cast <bool> (this->priv_in_range_or_end(p)) ? void (0) : __assert_fail ("this->priv_in_range_or_end(p)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      dtl::insert_n_copies_proxy<allocator_type> proxy(x);
      return this->priv_insert_forward_range(vector_iterator_get_ptr(p), n, proxy);
   }
# 2049 "/usr/include/boost/container/vector.hpp" 3 4
   template <class InIt>
   iterator insert(const_iterator pos, InIt first, InIt last

      , typename dtl::disable_if_or
         < void
         , dtl::is_convertible<InIt, size_type>
         , dtl::is_not_input_iterator<InIt>
         >::type * = 0

      )
   {
      (static_cast <bool> (this->priv_in_range_or_end(pos)) ? void (0) : __assert_fail ("this->priv_in_range_or_end(pos)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      const size_type n_pos = size_type(pos - this->cbegin());
      iterator it(vector_iterator_get_ptr(pos));
      for(;first != last; ++first){
         it = this->emplace(it, *first);
         ++it;
      }
      return iterator(this->m_holder.start() + difference_type(n_pos));
   }


   template <class FwdIt>
   inline __attribute__ ((__always_inline__)) iterator insert(const_iterator pos, FwdIt first, FwdIt last
      , typename dtl::disable_if_or
         < void
         , dtl::is_convertible<FwdIt, size_type>
         , dtl::is_input_iterator<FwdIt>
         >::type * = 0
      )
   {
      typedef typename iter_size<FwdIt>::type it_size_type;
      (static_cast <bool> (this->priv_in_range_or_end(pos)) ? void (0) : __assert_fail ("this->priv_in_range_or_end(pos)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      const it_size_type sz = boost::container::iterator_udistance(first, last);
      if (__builtin_expect(sz > size_type(-1), 0)){
         boost::container::throw_length_error("vector::insert, FwdIt's max length reached");
      }

      dtl::insert_range_proxy<allocator_type, FwdIt> proxy(first);
      return this->priv_insert_forward_range(vector_iterator_get_ptr(pos), static_cast<size_type>(sz), proxy);
   }
# 2108 "/usr/include/boost/container/vector.hpp" 3 4
   template <class InIt>
   inline __attribute__ ((__always_inline__)) iterator insert(const_iterator pos, size_type num, InIt first, InIt last)
   {
      (static_cast <bool> (this->priv_in_range_or_end(pos)) ? void (0) : __assert_fail ("this->priv_in_range_or_end(pos)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      (static_cast <bool> (dtl::is_input_iterator<InIt>::value || num == boost::container::iterator_udistance(first, last)) ? void (0) : __assert_fail ("dtl::is_input_iterator<InIt>::value || num == boost::container::iterator_udistance(first, last)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));

      (void)last;
      dtl::insert_range_proxy<allocator_type, InIt> proxy(first);
      return this->priv_insert_forward_range(vector_iterator_get_ptr(pos), num, proxy);
   }
# 2128 "/usr/include/boost/container/vector.hpp" 3 4
   inline __attribute__ ((__always_inline__)) iterator insert(const_iterator position, std::initializer_list<value_type> il)
   {

      return this->insert(position, il.begin(), il.end());
   }







   inline __attribute__ ((__always_inline__)) void pop_back() noexcept
   {
      (static_cast <bool> (!this->empty()) ? void (0) : __assert_fail ("!this->empty()", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));

      allocator_traits_type::destroy(this->get_stored_allocator(), this->priv_raw_end() - 1);
      --this->m_holder.m_size;
   }







   iterator erase(const_iterator position)
   {
      (static_cast <bool> (this->priv_in_range(position)) ? void (0) : __assert_fail ("this->priv_in_range(position)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      const pointer p = vector_iterator_get_ptr(position);
      T *const pos_ptr = boost::movelib::to_raw_pointer(p);
      T *const end_ptr = this->priv_raw_end();


      (void)::boost::container::move(pos_ptr + 1, end_ptr, pos_ptr);

      T *const last_ptr = end_ptr-1;
      if(!value_traits::trivial_dctr_after_move || pos_ptr == last_ptr){
         allocator_traits_type::destroy(this->get_stored_allocator(), last_ptr);
      }
      --this->m_holder.m_size;
      return iterator(p);
   }







   iterator erase(const_iterator first, const_iterator last)
   {
      (static_cast <bool> (this->priv_in_range_or_end(first)) ? void (0) : __assert_fail ("this->priv_in_range_or_end(first)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      (static_cast <bool> (this->priv_in_range_or_end(last)) ? void (0) : __assert_fail ("this->priv_in_range_or_end(last)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      (static_cast <bool> (first <= last) ? void (0) : __assert_fail ("first <= last", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      if(first != last){
         T* const old_end_ptr = this->priv_raw_end();
         T* const first_ptr = boost::movelib::to_raw_pointer(vector_iterator_get_ptr(first));
         T* const last_ptr = boost::movelib::to_raw_pointer(vector_iterator_get_ptr(last));
         T* const new_last_ptr = boost::movelib::to_raw_pointer(boost::container::move(last_ptr, old_end_ptr, first_ptr));
         const size_type n = static_cast<size_type>(old_end_ptr - new_last_ptr);
         if(!value_traits::trivial_dctr_after_move || old_end_ptr == last_ptr){
            boost::container::destroy_alloc_n(this->get_stored_allocator(), new_last_ptr, n);
         }
         this->m_holder.dec_stored_size(n);
      }
      return iterator(vector_iterator_get_ptr(first));
   }






   inline __attribute__ ((__always_inline__)) void swap(vector& x)
      noexcept((((allocator_traits_type::propagate_on_container_swap::value || allocator_traits_type::is_always_equal::value) && !dtl::is_version<allocator_type, 0>::value)))


   {
      this->priv_swap(x, dtl::bool_<dtl::is_version<allocator_type, 0>::value>());
   }
# 2219 "/usr/include/boost/container/vector.hpp" 3 4
   template<class OtherA>
   inline __attribute__ ((__always_inline__)) void swap(vector<T, OtherA, Options> & x
            , typename dtl::enable_if_and
                     < void
                     , dtl::is_version<typename real_allocator<T, OtherA>::type, 0>
                     , dtl::is_different<typename real_allocator<T, OtherA>::type, allocator_type>
                     >::type * = 0
            )
   { this->m_holder.deep_swap(x.m_holder); }
# 2236 "/usr/include/boost/container/vector.hpp" 3 4
   inline __attribute__ ((__always_inline__)) void clear() noexcept
   { this->priv_destroy_all(); }




   [[nodiscard]] inline __attribute__ ((__always_inline__)) friend bool operator==(const vector& x, const vector& y)
   { return x.size() == y.size() && ::boost::container::algo_equal(x.begin(), x.end(), y.begin()); }




   [[nodiscard]] inline __attribute__ ((__always_inline__)) friend bool operator!=(const vector& x, const vector& y)
   { return !(x == y); }




   [[nodiscard]] friend bool operator<(const vector& x, const vector& y)
   { return boost::container::algo_lexicographical_compare(x.begin(), x.end(), y.begin(), y.end()); }




   [[nodiscard]] inline __attribute__ ((__always_inline__)) friend bool operator>(const vector& x, const vector& y)
   { return y < x; }




   [[nodiscard]] inline __attribute__ ((__always_inline__)) friend bool operator<=(const vector& x, const vector& y)
   { return !(y < x); }




   [[nodiscard]] inline __attribute__ ((__always_inline__)) friend bool operator>=(const vector& x, const vector& y)
   { return !(x < y); }




   inline __attribute__ ((__always_inline__)) friend void swap(vector& x, vector& y)
       noexcept((noexcept(x.swap(y))))
   { x.swap(y); }
# 2292 "/usr/include/boost/container/vector.hpp" 3 4
   bool stable_reserve(size_type new_cap)
   {
      const size_type cp = this->capacity();
      return cp >= new_cap || (alloc_version::value == 2 && this->m_holder.try_expand_fwd(size_type(new_cap - cp)));
   }


   template<class BiDirPosConstIt, class BiDirValueIt>
   inline __attribute__ ((__always_inline__)) void insert_ordered_at(const size_type element_count, BiDirPosConstIt last_position_it, BiDirValueIt last_value_it)
   {
      typedef vector_insert_ordered_cursor<BiDirPosConstIt, BiDirValueIt> inserter_t;
      return this->priv_insert_ordered_at(element_count, inserter_t(last_position_it, last_value_it));
   }

   template<class InputIt>
   inline __attribute__ ((__always_inline__)) void merge(InputIt first, InputIt last)
   { this->merge(first, last, value_less_t()); }

   template<class InputIt, class Compare>
   inline __attribute__ ((__always_inline__)) void merge(InputIt first, InputIt last, Compare comp)
   {
      size_type const s = this->size();
      size_type const c = this->capacity();
      size_type n = 0;
      size_type const free_cap = c - s;

      if(!dtl::is_input_iterator<InputIt>::value &&
         free_cap < (n = boost::container::iterator_udistance(first, last))){
         this->priv_merge_in_new_buffer(first, n, comp, alloc_version());
      }
      else{
         this->insert(this->cend(), first, last);
         T *const raw_beg = this->priv_raw_begin();
         T *const raw_end = this->priv_raw_end();
         T *const raw_pos = raw_beg + s;
         boost::movelib::adaptive_merge(raw_beg, raw_pos, raw_end, comp, raw_end, free_cap - n);
      }
   }

   template<class InputIt>
   inline __attribute__ ((__always_inline__)) void merge_unique(InputIt first, InputIt last)
   { this->merge_unique(first, last, value_less_t()); }

   template<class InputIt, class Compare>
   inline __attribute__ ((__always_inline__)) void merge_unique(InputIt first, InputIt last, Compare comp)
   {
      size_type const old_size = this->size();
      this->priv_set_difference_back(first, last, comp);
      T *const raw_beg = this->priv_raw_begin();
      T *const raw_end = this->priv_raw_end();
      T *raw_pos = raw_beg + old_size;
      boost::movelib::adaptive_merge(raw_beg, raw_pos, raw_end, comp, raw_end, this->capacity() - this->size());
   }

   private:
   template<class PositionValue>
   void priv_insert_ordered_at(const size_type element_count, PositionValue position_value)
   {
      const size_type old_size_pos = this->size();
      this->reserve(old_size_pos + element_count);
      T* const begin_ptr = this->priv_raw_begin();
      size_type insertions_left = element_count;
      size_type prev_pos = old_size_pos;
      size_type old_hole_size = element_count;



      typename value_traits::ArrayDestructor past_hole_values_destroyer
         (begin_ptr + old_size_pos + element_count, this->m_holder.alloc(), size_type(0u));


      while(insertions_left){
         --position_value;
         size_type const pos = position_value.get_pos();
         (static_cast <bool> (pos != size_type(-1) && pos <= old_size_pos && pos <= prev_pos) ? void (0) : __assert_fail ("pos != size_type(-1) && pos <= old_size_pos && pos <= prev_pos", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));



         size_type new_hole_size = (pos != prev_pos)
            ? priv_insert_ordered_at_shift_range(pos, prev_pos, this->size(), insertions_left)
            : old_hole_size
            ;
         if(new_hole_size){

            past_hole_values_destroyer.increment_size_backwards(prev_pos - pos);

            allocator_traits_type::construct(this->m_holder.alloc(), begin_ptr + pos + insertions_left - 1, position_value.get_val());
            if(--new_hole_size){

               past_hole_values_destroyer.increment_size_backwards(size_type(1u));
            }
            else{

               past_hole_values_destroyer.release();
               this->m_holder.inc_stored_size(element_count);
            }
         }
         else{
            if(old_hole_size){

               past_hole_values_destroyer.release();
               this->m_holder.inc_stored_size(element_count);
            }

            begin_ptr[pos + insertions_left - 1] = position_value.get_val();
         }
         --insertions_left;
         old_hole_size = new_hole_size;
         prev_pos = pos;
      }
   }

   template<class InputIt, class Compare>
   void priv_set_difference_back(InputIt first1, InputIt last1, Compare comp)
   {
      T * old_first2 = this->priv_raw_begin();
      T * first2 = old_first2;
      T * last2 = this->priv_raw_end();

      while (first1 != last1) {
         if (first2 == last2){
            this->insert(this->cend(), first1, last1);
            return;
         }

         if (comp(*first1, *first2)) {
            this->emplace_back(*first1);
            T * const raw_begin = this->priv_raw_begin();
            if(old_first2 != raw_begin)
            {

               first2 = raw_begin + (first2 - old_first2);
               last2 = raw_begin + (last2 - old_first2);
               old_first2 = raw_begin;
            }
            ++first1;
         }
         else {
            if (!comp(*first2, *first1)) {
               ++first1;
            }
            ++first2;
         }
      }
   }

   template<class FwdIt, class Compare>
   inline __attribute__ ((__always_inline__)) void priv_merge_in_new_buffer(FwdIt, size_type, Compare, version_0)
   {
      alloc_holder_t::on_capacity_overflow();
   }

   template<class FwdIt, class Compare, class Version>
   void priv_merge_in_new_buffer(FwdIt first, size_type n, Compare comp, Version)
   {
      size_type const new_size = this->size() + n;
      size_type new_cap = new_size;
      pointer p = pointer();
      pointer const new_storage = this->m_holder.allocation_command(allocate_new, new_size, new_cap, p);

      (static_cast <bool> ((new_cap >= this->size() ) && (new_cap - this->size()) >= n) ? void (0) : __assert_fail ("(new_cap >= this->size() ) && (new_cap - this->size()) >= n", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      allocator_type &a = this->m_holder.alloc();
      typename value_traits::ArrayDeallocator new_buffer_deallocator(new_storage, a, new_cap);
      typename value_traits::ArrayDestructor new_values_destroyer(new_storage, a, 0u);
      T* pbeg = this->priv_raw_begin();
      size_type const old_size = this->size();
      T* const pend = pbeg + old_size;
      T* d_first = boost::movelib::to_raw_pointer(new_storage);
      size_type added = n;

      while(1){
         if(!n) {
            ::boost::container::uninitialized_move_alloc(this->m_holder.alloc(), pbeg, pend, d_first);
            break;
         }
         else if(pbeg == pend) {
            ::boost::container::uninitialized_move_alloc_n(this->m_holder.alloc(), first, n, d_first);
            break;
         }

         else if(comp(*first, *pbeg)) {
            allocator_traits_type::construct( this->m_holder.alloc(), d_first, *first );
            new_values_destroyer.increment_size(1u);
            ++first;
            --n;
            ++d_first;
         }
         else{
            allocator_traits_type::construct( this->m_holder.alloc(), d_first, boost::move(*pbeg) );
            new_values_destroyer.increment_size(1u);
            ++pbeg;
            ++d_first;
         }
      }


      pointer const old_p = this->m_holder.start();
      size_type const old_cap = this->m_holder.capacity();
      boost::container::destroy_alloc_n(a, boost::movelib::to_raw_pointer(old_p), old_size);
      if (old_cap > 0) {
         this->m_holder.deallocate(old_p, old_cap);
      }
      m_holder.set_stored_size(old_size + added);
      this->m_holder.start(new_storage);
      this->m_holder.capacity(new_cap);
      new_buffer_deallocator.release();
      new_values_destroyer.release();
   }

   inline __attribute__ ((__always_inline__)) bool room_enough() const
   { return this->m_holder.m_size != this->m_holder.capacity(); }

   inline __attribute__ ((__always_inline__)) pointer back_ptr() const
   { return this->m_holder.start() + difference_type(this->m_holder.m_size); }

   inline __attribute__ ((__always_inline__)) size_type priv_index_of(pointer p) const
   {
      (static_cast <bool> (this->m_holder.start() <= p) ? void (0) : __assert_fail ("this->m_holder.start() <= p", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      (static_cast <bool> (p <= (this->m_holder.start()+difference_type(this->size()))) ? void (0) : __assert_fail ("p <= (this->m_holder.start()+difference_type(this->size()))", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      return static_cast<size_type>(p - this->m_holder.start());
   }

   template<class OtherA>
   void priv_move_assign( vector<T, OtherA, Options> && x
      , typename dtl::enable_if_c
         < dtl::is_version<typename real_allocator<T, OtherA>::type, 0>::value >::type * = 0)
   {
      if(!dtl::is_same<typename real_allocator<T, OtherA>::type, allocator_type>::value &&
          this->capacity() < x.size()){
         alloc_holder_t::on_capacity_overflow();
      }
      T* const this_start = this->priv_raw_begin();
      T* const other_start = x.priv_raw_begin();
      const size_type this_sz = m_holder.m_size;
      const size_type other_sz = static_cast<size_type>(x.m_holder.m_size);
      boost::container::move_assign_range_alloc_n(this->m_holder.alloc(), other_start, other_sz, this_start, this_sz);
      m_holder.set_stored_size(other_sz);


      x.clear();
   }

   template<class OtherA>
   void priv_move_assign( vector<T, OtherA, Options> && x
      , typename dtl::disable_if_or
         < void
         , dtl::is_version<typename real_allocator<T, OtherA>::type, 0>
         , dtl::is_different<typename real_allocator<T, OtherA>::type, allocator_type>
         >::type * = 0)
   {


      (static_cast <bool> (this != &x || x.size() == 0) ? void (0) : __assert_fail ("this != &x || x.size() == 0", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      allocator_type &this_alloc = this->m_holder.alloc();
      allocator_type &x_alloc = x.m_holder.alloc();
      const bool propagate_alloc = allocator_traits_type::propagate_on_container_move_assignment::value;


      const bool is_propagable_from_x = is_propagable_from(x_alloc, x.m_holder.start(), this_alloc, propagate_alloc);



      if(is_propagable_from_x){
         this->clear();
         if(__builtin_expect(!!this->m_holder.m_start, 1))
            this->m_holder.deallocate(this->m_holder.m_start, this->m_holder.m_capacity);
         this->m_holder.steal_resources(x.m_holder);
      }


      else{
         this->assign( boost::make_move_iterator(boost::movelib::iterator_to_raw_pointer(x.begin()))
                     , boost::make_move_iterator(boost::movelib::iterator_to_raw_pointer(x.end() ))
                     );
         x.clear();
      }

      dtl::move_alloc(this_alloc, x_alloc, dtl::bool_<propagate_alloc>());
   }

   template<class OtherA>
   void priv_copy_assign(const vector<T, OtherA, Options> &x
      , typename dtl::enable_if_c
         < dtl::is_version<typename real_allocator<T, OtherA>::type, 0>::value >::type * = 0)
   {
      if(!dtl::is_same<typename real_allocator<T, OtherA>::type, allocator_type>::value &&
         this->capacity() < x.size()){
         alloc_holder_t::on_capacity_overflow();
      }
      T* const this_start = this->priv_raw_begin();
      T* const other_start = x.priv_raw_begin();
      const size_type this_sz = m_holder.m_size;
      const size_type other_sz = static_cast<size_type>(x.m_holder.m_size);
      boost::container::copy_assign_range_alloc_n(this->m_holder.alloc(), other_start, other_sz, this_start, this_sz);
      m_holder.set_stored_size(other_sz);
   }

   template<class OtherA>
   typename dtl::disable_if_or
      < void
      , dtl::is_version<typename real_allocator<T, OtherA>::type, 0>
      , dtl::is_different<typename real_allocator<T, OtherA>::type, allocator_type>
      >::type
      priv_copy_assign(const vector<T, OtherA, Options> &x)
   {
      allocator_type &this_alloc = this->m_holder.alloc();
      const allocator_type &x_alloc = x.m_holder.alloc();
      dtl::bool_<allocator_traits_type::
         propagate_on_container_copy_assignment::value> flag;
      if(flag && this_alloc != x_alloc){
         this->clear();
         this->shrink_to_fit();
      }
      dtl::assign_alloc(this_alloc, x_alloc, flag);
      this->assign( x.priv_raw_begin(), x.priv_raw_end() );
   }

   template<class Vector>
   inline __attribute__ ((__always_inline__)) void priv_swap(Vector &x, dtl::true_type)
   { this->m_holder.deep_swap(x.m_holder); }

   template<class Vector>
   void priv_swap(Vector &x, dtl::false_type)
   {
      const bool propagate_alloc = allocator_traits_type::propagate_on_container_swap::value;
      if (__builtin_expect(&x == this, 0)){
         return;
      }
      else if(are_swap_propagable( this->get_stored_allocator(), this->m_holder.start()
                                 , x.get_stored_allocator(), x.m_holder.start(), propagate_alloc)){

         this->m_holder.swap_resources(x.m_holder);
      }
      else{

         bool const t_smaller = this->size() < x.size();
         vector &sml = t_smaller ? *this : x;
         vector &big = t_smaller ? x : *this;


         if(sml.empty() && is_propagable_from(big.get_stored_allocator(), big.data(), sml.get_allocator(), propagate_alloc)){
            if(__builtin_expect(0u != sml.capacity(), 1))
               sml.m_holder.deallocate(sml.m_holder.m_start, sml.m_holder.m_capacity);
            sml.steal_resources(big);
         }
         else {

            size_type const common_elements = sml.size();
            for(size_type i = 0; i != common_elements; ++i){
               boost::adl_move_swap(sml[i], big[i]);
            }

            sml.insert( sml.cend()
                      , boost::make_move_iterator(boost::movelib::iterator_to_raw_pointer(big.nth(common_elements)))
                      , boost::make_move_iterator(boost::movelib::iterator_to_raw_pointer(big.end()))
                      );

            big.erase(big.nth(common_elements), big.cend());
         }
      }

      dtl::swap_alloc(this->m_holder.alloc(), x.m_holder.alloc(), dtl::bool_<propagate_alloc>());
   }

   inline __attribute__ ((__always_inline__)) void priv_move_to_new_buffer(size_type, version_0)
   { alloc_holder_t::on_capacity_overflow(); }

   inline __attribute__ ((__always_inline__)) dtl::insert_range_proxy<allocator_type, boost::move_iterator<T*> > priv_dummy_empty_proxy()
   {
      return dtl::insert_range_proxy<allocator_type, boost::move_iterator<T*> >
         (::boost::make_move_iterator((T *)0));
   }

   inline __attribute__ ((__always_inline__)) void priv_move_to_new_buffer(size_type new_cap, version_1)
   {


      pointer const p = this->m_holder.allocate(new_cap);




      this->priv_insert_forward_range_new_allocation
         ( boost::movelib::to_raw_pointer(p), new_cap, this->priv_raw_end(), 0, this->priv_dummy_empty_proxy());
   }

   void priv_move_to_new_buffer(size_type new_cap, version_2)
   {


      bool same_buffer_start;
      size_type real_cap = 0;
      pointer reuse(this->m_holder.start());
      pointer const ret(this->m_holder.allocation_command(allocate_new | expand_fwd | expand_bwd, new_cap, real_cap = new_cap, reuse));


      same_buffer_start = reuse && this->m_holder.start() == ret;
      if(same_buffer_start){



         this->m_holder.capacity(real_cap);
      }
      else{
         T * const new_mem = boost::movelib::to_raw_pointer(ret);
         T * const ins_pos = this->priv_raw_end();
         if(reuse){



            this->priv_insert_forward_range_expand_backwards
               ( new_mem, real_cap, ins_pos, 0, this->priv_dummy_empty_proxy());
         }
         else{



            this->priv_insert_forward_range_new_allocation
               ( new_mem, real_cap, ins_pos, 0, this->priv_dummy_empty_proxy());
         }
      }
   }

   void priv_destroy_last_n(const size_type n) noexcept
   {
      (static_cast <bool> (n <= this->m_holder.m_size) ? void (0) : __assert_fail ("n <= this->m_holder.m_size", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      boost::container::destroy_alloc_n(this->get_stored_allocator(), this->priv_raw_end() - n, n);
      this->m_holder.dec_stored_size(n);
   }

   template<class InpIt>
   void priv_uninitialized_construct_at_end(InpIt first, InpIt last)
   {
      T* const old_end_pos = this->priv_raw_end();
      T* const new_end_pos = boost::container::uninitialized_copy_alloc(this->m_holder.alloc(), first, last, old_end_pos);
      this->m_holder.inc_stored_size(static_cast<size_type>(new_end_pos - old_end_pos));
   }

   void priv_destroy_all() noexcept
   {
      boost::container::destroy_alloc_n
         (this->get_stored_allocator(), this->priv_raw_begin(), this->m_holder.m_size);
      this->m_holder.m_size = 0;
   }

   template<class U>
   inline __attribute__ ((__always_inline__)) iterator priv_insert(const const_iterator &p, U && u)
   {
      return this->emplace(p, ::boost::forward<U>(u));
   }

   template <class U>
   inline __attribute__ ((__always_inline__)) void priv_push_back(U && u)
   {
      this->emplace_back(::boost::forward<U>(u));
   }


   inline __attribute__ ((__always_inline__)) void priv_push_back(::boost::move_detail::nat)
   {}

   inline __attribute__ ((__always_inline__)) iterator priv_insert(const_iterator, ::boost::move_detail::nat)
   { return iterator(); }

   inline __attribute__ ((__always_inline__)) dtl::insert_n_copies_proxy<allocator_type> priv_resize_proxy(const T &x)
   { return dtl::insert_n_copies_proxy<allocator_type>(x); }

   inline __attribute__ ((__always_inline__)) dtl::insert_default_initialized_n_proxy<allocator_type> priv_resize_proxy(default_init_t)
   { return dtl::insert_default_initialized_n_proxy<allocator_type>(); }

   inline __attribute__ ((__always_inline__)) dtl::insert_value_initialized_n_proxy<allocator_type> priv_resize_proxy(value_init_t)
   { return dtl::insert_value_initialized_n_proxy<allocator_type>(); }

   inline __attribute__ ((__always_inline__)) void priv_shrink_to_fit(version_0) noexcept
   {}

   void priv_shrink_to_fit(version_1)
   {
      const size_type cp = this->m_holder.capacity();
      if(cp){
         const size_type sz = this->size();
         if(!sz){
            if(__builtin_expect(!!this->m_holder.m_start, 1))
               this->m_holder.deallocate(this->m_holder.m_start, cp);
            this->m_holder.m_start = pointer();
            this->m_holder.m_capacity = 0;
         }
         else if(sz < cp){
            this->priv_move_to_new_buffer(sz, alloc_version());
         }
      }
   }

   void priv_shrink_to_fit(version_2) noexcept
   {
      const size_type cp = this->m_holder.capacity();
      if(cp){
         const size_type sz = this->size();
         if(!sz){
            if(__builtin_expect(!!this->m_holder.m_start, 1))
               this->m_holder.deallocate(this->m_holder.m_start, cp);
            this->m_holder.m_start = pointer();
            this->m_holder.m_capacity = 0;
         }
         else{
            size_type received_size = sz;
            pointer reuse(this->m_holder.start());
            if(this->m_holder.allocation_command
               (shrink_in_place | nothrow_allocation, cp, received_size, reuse)){
               this->m_holder.capacity(received_size);



            }
         }
      }
   }

   template <class InsertionProxy>
   inline __attribute__ ((__always_inline__)) iterator priv_insert_forward_range_no_capacity
      (T * const, const size_type, const InsertionProxy , version_0)
   {
      return alloc_holder_t::on_capacity_overflow(), iterator();
   }

   template <class InsertionProxy>
   __attribute__ ((__noinline__)) iterator priv_insert_forward_range_no_capacity
      (T *const raw_pos, const size_type n, const InsertionProxy insert_range_proxy, version_1)
   {

      const size_type n_pos = static_cast<size_type>(raw_pos - this->priv_raw_begin());

      const size_type new_cap = this->m_holder.template next_capacity<growth_factor_type>(n);

      T * const new_buf = boost::movelib::to_raw_pointer(this->m_holder.allocate(new_cap));



      this->priv_insert_forward_range_new_allocation(new_buf, new_cap, raw_pos, n, insert_range_proxy);
      return iterator(this->m_holder.start() + difference_type(n_pos));
   }

   template <class InsertionProxy>
   __attribute__ ((__noinline__)) iterator priv_insert_forward_range_no_capacity
      (T *const raw_pos, const size_type n, const InsertionProxy insert_range_proxy, version_2)
   {

      const size_type n_pos = size_type(raw_pos - this->priv_raw_begin());



      size_type real_cap = this->m_holder.template next_capacity<growth_factor_type>(n);
      pointer reuse(this->m_holder.start());
      pointer const ret (this->m_holder.allocation_command
         (allocate_new | expand_fwd | expand_bwd, size_type(this->m_holder.m_size + n), real_cap, reuse));


      if(reuse){

         if(this->m_holder.start() == ret){



            this->m_holder.capacity(real_cap);

            this->priv_insert_forward_range_expand_forward
               (raw_pos, n, insert_range_proxy, dtl::bool_<dtl::is_single_value_proxy<InsertionProxy>::value>());
         }

         else{



            this->priv_insert_forward_range_expand_backwards
               (boost::movelib::to_raw_pointer(ret), real_cap, raw_pos, n, insert_range_proxy);
         }
      }

      else{



         this->priv_insert_forward_range_new_allocation
            ( boost::movelib::to_raw_pointer(ret), real_cap, raw_pos, n, insert_range_proxy);
      }

      return iterator(this->m_holder.start() + (difference_type)(n_pos));
   }

   template <class InsertionProxy>
   inline __attribute__ ((__always_inline__)) iterator priv_insert_forward_range
      (const pointer &pos, const size_type n, const InsertionProxy insert_range_proxy)
   {
      (static_cast <bool> (this->m_holder.capacity() >= this->m_holder.m_size) ? void (0) : __assert_fail ("this->m_holder.capacity() >= this->m_holder.m_size", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      T *const p = boost::movelib::to_raw_pointer(pos);

      if (__builtin_expect(n <= (this->m_holder.capacity() - this->m_holder.m_size), 1)){

         this->priv_insert_forward_range_expand_forward
            (p, n, insert_range_proxy, dtl::bool_<dtl::is_single_value_proxy<InsertionProxy>::value>());
         return iterator(pos);
      }
      else{
         return this->priv_insert_forward_range_no_capacity(p, n, insert_range_proxy, alloc_version());
      }
   }

   template <class U>
   void priv_resize(const size_type new_size, const U &u, version_0)
   {
      const size_type sz = this->m_holder.m_size;
      if (new_size > this->capacity()){

         alloc_holder_t::on_capacity_overflow();
      }
      else if (new_size < sz){

         this->priv_destroy_last_n(sz - new_size);
      }
      else{
         T* const old_finish = this->priv_raw_end();
         this->priv_resize_proxy(u).uninitialized_copy_n_and_update(this->m_holder.alloc(), old_finish, new_size - sz);
         this->m_holder.set_stored_size(new_size);
      }
   }

   template <class U, class AllocVersion>
   void priv_resize(const size_type new_size, const U &u, AllocVersion)
   {
      const size_type sz = this->m_holder.m_size;
      if (new_size < sz){

         this->priv_destroy_last_n(size_type(sz - new_size));
      }
      else {
         this->priv_insert_forward_range(this->back_ptr(), size_type(new_size - sz), this->priv_resize_proxy(u));
      }
   }
# 2982 "/usr/include/boost/container/vector.hpp" 3 4
   size_type priv_insert_ordered_at_shift_range
      (size_type first_pos, size_type last_pos, size_type limit_pos, size_type shift_count)
   {
      (static_cast <bool> (first_pos <= last_pos) ? void (0) : __assert_fail ("first_pos <= last_pos", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      (static_cast <bool> (last_pos <= limit_pos) ? void (0) : __assert_fail ("last_pos <= limit_pos", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));

      T* const begin_ptr = this->priv_raw_begin();
      T* const first_ptr = begin_ptr + first_pos;
      T* const last_ptr = begin_ptr + last_pos;

      size_type hole_size = 0;

      if((last_pos + shift_count) <= limit_pos){

         boost::container::move_backward(first_ptr, last_ptr, last_ptr + shift_count);
      }

      else if((first_pos + shift_count) >= limit_pos){

         ::boost::container::uninitialized_move_alloc
            (this->m_holder.alloc(), first_ptr, last_ptr, first_ptr + shift_count);


         hole_size = static_cast<size_type>(first_pos + shift_count - limit_pos);
      }

      else{

         T* const limit_ptr = begin_ptr + limit_pos;
         T* const boundary_ptr = limit_ptr - shift_count;
         ::boost::container::uninitialized_move_alloc(this->m_holder.alloc(), boundary_ptr, last_ptr, limit_ptr);

         boost::container::move_backward(first_ptr, boundary_ptr, limit_ptr);
      }
      return hole_size;
   }

   private:
   inline __attribute__ ((__always_inline__)) T *priv_raw_begin() const
   { return boost::movelib::to_raw_pointer(m_holder.start()); }

   inline __attribute__ ((__always_inline__)) T* priv_raw_end() const
   { return this->priv_raw_begin() + this->m_holder.m_size; }

   template <class InsertionProxy>
   inline __attribute__ ((__always_inline__)) void priv_insert_forward_range_expand_forward
      (T* const raw_pos, const size_type, InsertionProxy insert_range_proxy, dtl::true_type)
   {
      (static_cast <bool> (this->room_enough()) ? void (0) : __assert_fail ("this->room_enough()", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));

      T* const old_finish = this->priv_raw_end();
      allocator_type & a = this->m_holder.alloc();

      if (old_finish == raw_pos){
         insert_range_proxy.uninitialized_copy_n_and_update(a, old_finish, 1);
         ++this->m_holder.m_size;
      }
      else{


         T * const before_old_finish = old_finish-1;

         allocator_traits_type::construct(a, old_finish, ::boost::move(*before_old_finish));
         ++this->m_holder.m_size;

         boost::container::move_backward(raw_pos, before_old_finish, old_finish);

         insert_range_proxy.copy_n_and_update(a, raw_pos, 1);
      }
   }

   template <class InsertionProxy>
   inline __attribute__ ((__always_inline__)) void priv_insert_forward_range_expand_forward
      (T* const raw_pos, const size_type n, InsertionProxy insert_range_proxy, dtl::false_type)
   {

      boost::container::expand_forward_and_insert_alloc
         ( this->m_holder.alloc(), raw_pos, this->priv_raw_end(), n, insert_range_proxy);
      this->m_holder.inc_stored_size(n);
   }

   template <class InsertionProxy>
   void priv_insert_forward_range_new_allocation
      (T* const new_start, size_type new_cap, T* const pos, const size_type n, InsertionProxy insert_range_proxy)
   {

      allocator_type &a = this->m_holder.alloc();
      T * const raw_old_buffer = this->priv_raw_begin();

      typename value_traits::ArrayDeallocator new_buffer_deallocator(new_start, a, new_cap);
      boost::container::uninitialized_move_and_insert_alloc
         (a, raw_old_buffer, pos, this->priv_raw_end(), new_start, n, insert_range_proxy);
      new_buffer_deallocator.release();


      if(raw_old_buffer){
         if constexpr(!has_trivial_destructor_after_move<value_type>::value)
            boost::container::destroy_alloc_n(a, raw_old_buffer, this->m_holder.m_size);
         this->m_holder.deallocate(this->m_holder.start(), this->m_holder.capacity());
      }

      this->m_holder.start(new_start);
      this->m_holder.inc_stored_size(n);
      this->m_holder.capacity(new_cap);
   }

   template <class InsertionProxy>
   void priv_insert_forward_range_expand_backwards
         (T* const new_start, const size_type new_capacity,
          T* const pos, const size_type n, InsertionProxy insert_range_proxy)
   {
      T* const old_start = this->priv_raw_begin();
      const size_type old_size = this->m_holder.m_size;
      allocator_type& a = this->m_holder.alloc();


      this->m_holder.start(new_start);
      this->m_holder.capacity(new_capacity);
      this->m_holder.m_size = 0;

      expand_backward_forward_and_insert_alloc(old_start, old_size, new_start, pos, n, insert_range_proxy, a);


      this->m_holder.m_size = stored_size_type(old_size + n);
   }

   void priv_throw_if_out_of_range(size_type n) const
   {

      if (n >= this->size()){
         throw_out_of_range("vector::at out of range");
      }
   }

   inline __attribute__ ((__always_inline__)) bool priv_in_range(const_iterator pos) const
   {
      return (this->begin() <= pos) && (pos < this->end());
   }

   inline __attribute__ ((__always_inline__)) bool priv_in_range_or_end(const_iterator pos) const
   {
      return (this->begin() <= pos) && (pos <= this->end());
   }
# 3136 "/usr/include/boost/container/vector.hpp" 3 4
};



template <typename InputIterator>
vector(InputIterator, InputIterator) ->
   vector<typename iter_value<InputIterator>::type>;

template <typename InputIterator, typename Allocator>
vector(InputIterator, InputIterator, Allocator const&) ->
   vector<typename iter_value<InputIterator>::type, Allocator>;




}}



namespace boost {



template <class T, class Allocator, class Options>
struct has_trivial_destructor_after_move<boost::container::vector<T, Allocator, Options> >
{
   typedef typename boost::container::vector<T, Allocator, Options>::allocator_type allocator_type;
   typedef typename ::boost::container::allocator_traits<allocator_type>::pointer pointer;
   static const bool value = ::boost::has_trivial_destructor_after_move<allocator_type>::value &&
                             ::boost::has_trivial_destructor_after_move<pointer>::value;
};

}




namespace std __attribute__ ((__visibility__ ("default"))) {

template <class Pointer, bool IsConst>
struct pointer_traits< boost::container::vec_iterator<Pointer, IsConst> >
   : public boost::intrusive::pointer_traits< boost::container::vec_iterator<Pointer, IsConst> >
{};

 }





# 1 "/usr/include/boost/container/detail/config_end.hpp" 1 3 4
# 3187 "/usr/include/boost/container/vector.hpp" 2 3 4
# 26 "/usr/include/boost/container/static_vector.hpp" 2 3 4






namespace boost { namespace container {



namespace dtl {

template<class T, std::size_t N, std::size_t InplaceAlignment, bool ThrowOnOverflow>
class static_storage_allocator
{
   typedef bool_<ThrowOnOverflow> throw_on_overflow_t;

   static __attribute__ ((__noreturn__)) inline __attribute__ ((__always_inline__)) void on_capacity_overflow(true_type)
   {
      (throw_bad_alloc)();
   }

   static inline __attribute__ ((__always_inline__)) void on_capacity_overflow(false_type)
   {
      (static_cast <bool> ((false)&&("ERROR: static vector capacity overflow")) ? void (0) : __assert_fail ("(false)&&(\"ERROR: static vector capacity overflow\")", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
   }

   public:
   typedef T value_type;

   inline __attribute__ ((__always_inline__)) static_storage_allocator() noexcept
   {}

   inline __attribute__ ((__always_inline__)) static_storage_allocator(const static_storage_allocator &) noexcept
   {}

   inline __attribute__ ((__always_inline__)) static_storage_allocator & operator=(const static_storage_allocator &) noexcept
   { return *this; }

   inline __attribute__ ((__always_inline__)) T* internal_storage() const noexcept
   { return const_cast<T*>(static_cast<const T*>(static_cast<const void*>(storage.data))); }

   inline __attribute__ ((__always_inline__)) T* internal_storage() noexcept
   { return static_cast<T*>(static_cast<void*>(storage.data)); }

   static const std::size_t internal_capacity = N;

   std::size_t max_size() const
   { return N; }

   static inline __attribute__ ((__always_inline__)) void on_capacity_overflow()
   {
      (on_capacity_overflow)(throw_on_overflow_t());
   }

   typedef boost::container::dtl::version_type<static_storage_allocator, 0> version;

   inline __attribute__ ((__always_inline__)) friend bool operator==(const static_storage_allocator &, const static_storage_allocator &) noexcept
   { return false; }

   inline __attribute__ ((__always_inline__)) friend bool operator!=(const static_storage_allocator &, const static_storage_allocator &) noexcept
   { return true; }

   private:
   static_assert(!InplaceAlignment || (InplaceAlignment & (InplaceAlignment-1)) == 0, "Alignment option must be zero or power of two");
   static const std::size_t final_alignment = InplaceAlignment ? InplaceAlignment : dtl::alignment_of<T>::value;
   typename dtl::aligned_storage<sizeof(T)*N, final_alignment>::type storage;
};

template<class Options>
struct get_static_vector_opt
{
   typedef Options type;
};

template<>
struct get_static_vector_opt<void>
{
   typedef static_vector_null_opt type;
};

template <typename T, std::size_t Capacity, class Options>
struct get_static_vector_allocator
{
   typedef typename get_static_vector_opt<Options>::type options_t;
   typedef dtl::static_storage_allocator
      < T
      , Capacity
      , options_t::inplace_alignment
      , options_t::throw_on_overflow
      > type;
};


}
# 151 "/usr/include/boost/container/static_vector.hpp" 3 4
template <typename T, std::size_t Capacity, class Options >
class static_vector
    : public vector<T, typename dtl::get_static_vector_allocator< T, Capacity, Options>::type>
{
   public:

   typedef typename dtl::get_static_vector_allocator< T, Capacity, Options>::type allocator_type;
   typedef vector<T, allocator_type > base_t;



   template<class U, std::size_t OtherCapacity, class OtherOptions>
   friend class static_vector;

   public:


public:

    typedef typename base_t::value_type value_type;

    typedef typename base_t::size_type size_type;

    typedef typename base_t::difference_type difference_type;

    typedef typename base_t::pointer pointer;

    typedef typename base_t::const_pointer const_pointer;

    typedef typename base_t::reference reference;

    typedef typename base_t::const_reference const_reference;

    typedef typename base_t::iterator iterator;

    typedef typename base_t::const_iterator const_iterator;

    typedef typename base_t::reverse_iterator reverse_iterator;

    typedef typename base_t::const_reverse_iterator const_reverse_iterator;


    static const size_type static_capacity = Capacity;
# 202 "/usr/include/boost/container/static_vector.hpp" 3 4
    inline __attribute__ ((__always_inline__)) static_vector() noexcept
        : base_t()
    {}
# 218 "/usr/include/boost/container/static_vector.hpp" 3 4
    inline __attribute__ ((__always_inline__)) explicit static_vector(size_type count)
        : base_t(count)
    {}
# 237 "/usr/include/boost/container/static_vector.hpp" 3 4
    inline __attribute__ ((__always_inline__)) static_vector(size_type count, default_init_t)
        : base_t(count, default_init_t())
    {}
# 254 "/usr/include/boost/container/static_vector.hpp" 3 4
    inline __attribute__ ((__always_inline__)) static_vector(size_type count, value_type const& value)
        : base_t(count, value)
    {}
# 273 "/usr/include/boost/container/static_vector.hpp" 3 4
    template <typename Iterator>
    inline __attribute__ ((__always_inline__)) static_vector(Iterator first, Iterator last)
        : base_t(first, last)
    {}
# 292 "/usr/include/boost/container/static_vector.hpp" 3 4
    inline __attribute__ ((__always_inline__)) static_vector(std::initializer_list<value_type> il)
        : base_t(il)
    {}
# 306 "/usr/include/boost/container/static_vector.hpp" 3 4
    inline __attribute__ ((__always_inline__)) static_vector(static_vector const& other)
        : base_t(other)
    {}

    inline __attribute__ ((__always_inline__)) static_vector(static_vector const& other, const allocator_type &)
       : base_t(other)
    {}

    inline __attribute__ ((__always_inline__)) static_vector(static_vector && other, const allocator_type &)
       noexcept((boost::container::dtl::is_nothrow_move_constructible<value_type>::value))
       : base_t(::boost::move((base_t&)(other)))
    {}

    inline __attribute__ ((__always_inline__)) explicit static_vector(const allocator_type &)
       : base_t()
    {}
# 335 "/usr/include/boost/container/static_vector.hpp" 3 4
    template <std::size_t C, class O>
    inline __attribute__ ((__always_inline__)) static_vector(static_vector<T, C, O> const& other)
        : base_t(other)
    {}
# 350 "/usr/include/boost/container/static_vector.hpp" 3 4
    inline __attribute__ ((__always_inline__)) static_vector(static_vector && other)
      noexcept((boost::container::dtl::is_nothrow_move_constructible<value_type>::value))
        : base_t(::boost::move((base_t&)(other)))
    {}
# 368 "/usr/include/boost/container/static_vector.hpp" 3 4
    template <std::size_t C, class O>
    inline __attribute__ ((__always_inline__)) static_vector( static_vector<T, C, O> && other)
        : base_t(::boost::move((typename static_vector<T , C>::base_t&)(other)))
    {}
# 382 "/usr/include/boost/container/static_vector.hpp" 3 4
    inline __attribute__ ((__always_inline__)) static_vector & operator=(const static_vector & other)
    {
        return static_cast<static_vector&>(base_t::operator=(static_cast<base_t const&>(other)));
    }
# 398 "/usr/include/boost/container/static_vector.hpp" 3 4
    inline __attribute__ ((__always_inline__)) static_vector & operator=(std::initializer_list<value_type> il)
    { return static_cast<static_vector&>(base_t::operator=(il)); }
# 414 "/usr/include/boost/container/static_vector.hpp" 3 4
    template <std::size_t C, class O>
    inline __attribute__ ((__always_inline__)) static_vector & operator=(static_vector<T, C, O> const& other)
    {
        return static_cast<static_vector&>(base_t::operator=
            (static_cast<typename static_vector<T, C, O>::base_t const&>(other)));
    }
# 431 "/usr/include/boost/container/static_vector.hpp" 3 4
    inline __attribute__ ((__always_inline__)) static_vector & operator=(static_vector && other)
       noexcept((boost::container::dtl::is_nothrow_move_assignable<value_type>::value))
    {
        return static_cast<static_vector&>(base_t::operator=(::boost::move((base_t&)(other))));
    }
# 450 "/usr/include/boost/container/static_vector.hpp" 3 4
    template <std::size_t C, class O>
    inline __attribute__ ((__always_inline__)) static_vector & operator=( static_vector<T, C, O> && other)
    {
        return static_cast<static_vector&>(base_t::operator=
         (::boost::move((typename static_vector<T , C>::base_t&)(other))));
    }
# 1158 "/usr/include/boost/container/static_vector.hpp" 3 4
   inline __attribute__ ((__always_inline__)) static size_type capacity() noexcept
   { return static_capacity; }
# 1170 "/usr/include/boost/container/static_vector.hpp" 3 4
   inline __attribute__ ((__always_inline__)) static size_type max_size() noexcept
   { return static_capacity; }
# 1199 "/usr/include/boost/container/static_vector.hpp" 3 4
   inline __attribute__ ((__always_inline__)) friend void swap(static_vector &x, static_vector &y)
       noexcept((noexcept(x.swap(y))))
   {
      x.swap(y);
   }



};
# 1312 "/usr/include/boost/container/static_vector.hpp" 3 4
template<typename V, std::size_t C1, std::size_t C2, class O1, class O2>
inline void swap(static_vector<V, C1, O1> & x, static_vector<V, C2, O2> & y
      , typename dtl::enable_if_c< C1 != C2>::type * = 0)
    noexcept((noexcept(x.swap(y))))
{
   x.swap(y);
}



}}

# 1 "/usr/include/boost/container/detail/config_end.hpp" 1 3 4
# 1325 "/usr/include/boost/container/static_vector.hpp" 2 3 4
# 39 "/home/avi/scylla-maint/seastar/include/seastar/util/backtrace.hh" 2


namespace seastar {

struct shared_object {
    sstring name;
    uintptr_t begin;
    uintptr_t end;
};

struct frame {
    const shared_object* so;
    uintptr_t addr;
};

bool operator==(const frame& a, const frame& b) noexcept;




frame decorate(uintptr_t addr) noexcept;



template<typename Func>
void backtrace(Func&& func) noexcept(noexcept(func(frame()))) {

    constexpr size_t max_backtrace = 100;
    void* buffer[max_backtrace];
    int n = ::backtrace(buffer, max_backtrace);
    for (int i = 0; i < n; ++i) {
        auto ip = reinterpret_cast<uintptr_t>(buffer[i]);
        func(decorate(ip - 1));
    }




}



class simple_backtrace {
public:
    using vector_type = boost::container::static_vector<frame, 64>;
private:
    vector_type _frames;
    size_t _hash;
    char _delimeter;
private:
    size_t calculate_hash() const noexcept;
public:
    simple_backtrace(vector_type f, char delimeter = ' ') noexcept : _frames(std::move(f)), _hash(calculate_hash()), _delimeter(delimeter) {}
    simple_backtrace(char delimeter = ' ') noexcept : simple_backtrace({}, delimeter) {}

    size_t hash() const noexcept { return _hash; }
    char delimeter() const noexcept { return _delimeter; }

    friend std::ostream& operator<<(std::ostream& out, const simple_backtrace&);

    bool operator==(const simple_backtrace& o) const noexcept {
        return _hash == o._hash && _frames == o._frames;
    }

    bool operator!=(const simple_backtrace& o) const noexcept {
        return !(*this == o);
    }
};

using shared_backtrace = seastar::lw_shared_ptr<simple_backtrace>;


class task_entry {
    const std::type_info* _task_type;
public:
    task_entry(const std::type_info& ti) noexcept
        : _task_type(&ti)
    { }

    friend std::ostream& operator<<(std::ostream& out, const task_entry&);

    bool operator==(const task_entry& o) const noexcept {
        return *_task_type == *o._task_type;
    }

    bool operator!=(const task_entry& o) const noexcept {
        return !(*this == o);
    }

    size_t hash() const noexcept { return _task_type->hash_code(); }
};




class tasktrace {
public:
    using entry = std::variant<shared_backtrace, task_entry>;
    using vector_type = boost::container::static_vector<entry, 16>;
private:
    simple_backtrace _main;
    vector_type _prev;
    scheduling_group _sg;
    size_t _hash;
public:
    tasktrace() = default;
    tasktrace(simple_backtrace main, vector_type prev, size_t prev_hash, scheduling_group sg) noexcept;
    tasktrace(const tasktrace&) = default;
    tasktrace& operator=(const tasktrace&) = default;
    ~tasktrace();

    size_t hash() const noexcept { return _hash; }
    char delimeter() const noexcept { return _main.delimeter(); }

    friend std::ostream& operator<<(std::ostream& out, const tasktrace&);

    bool operator==(const tasktrace& o) const noexcept;

    bool operator!=(const tasktrace& o) const noexcept {
        return !(*this == o);
    }
};

}

namespace std {


template<>
struct hash<seastar::simple_backtrace> {
    size_t operator()(const seastar::simple_backtrace& b) const {
        return b.hash();
    }
};


template<>
struct hash<seastar::tasktrace> {
    size_t operator()(const seastar::tasktrace& b) const {
        return b.hash();
    }
};

}


template <> struct fmt::formatter<seastar::tasktrace> : fmt::ostream_formatter {};
template <> struct fmt::formatter<seastar::simple_backtrace> : fmt::ostream_formatter {};


namespace seastar {

using saved_backtrace = tasktrace;

saved_backtrace current_backtrace() noexcept;

tasktrace current_tasktrace() noexcept;


simple_backtrace current_backtrace_tasklocal() noexcept;

std::ostream& operator<<(std::ostream& out, const tasktrace& b);

namespace internal {

template<class Exc>
class backtraced : public Exc {
    std::shared_ptr<sstring> _backtrace;
public:
    template<typename... Args>
    backtraced(Args&&... args)
            : Exc(std::forward<Args>(args)...)
            , _backtrace(std::make_shared<sstring>(format("{} Backtrace: {}", Exc::what(), current_backtrace()))) {}






    virtual const char* what() const noexcept override {
        (static_cast <bool> (_backtrace) ? void (0) : __assert_fail ("_backtrace", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        return _backtrace->c_str();
    }
};

}
# 235 "/home/avi/scylla-maint/seastar/include/seastar/util/backtrace.hh"
template <class Exc, typename... Args>
std::exception_ptr make_backtraced_exception_ptr(Args&&... args) {
    using exc_type = std::decay_t<Exc>;
    static_assert(std::is_base_of_v<std::exception, exc_type>,
            "throw_with_backtrace only works with exception types");
    return std::make_exception_ptr<internal::backtraced<exc_type>>(Exc(std::forward<Args>(args)...));
}
# 253 "/home/avi/scylla-maint/seastar/include/seastar/util/backtrace.hh"
template <class Exc, typename... Args>
[[noreturn]]
void
throw_with_backtrace(Args&&... args) {
    std::rethrow_exception(make_backtraced_exception_ptr<Exc>(std::forward<Args>(args)...));
};

}
# 26 "/home/avi/scylla-maint/seastar/include/seastar/core/task.hh" 2





namespace seastar {


class task {
protected:
    scheduling_group _sg;
private:



protected:




    ~task() = default;

    scheduling_group set_scheduling_group(scheduling_group new_sg) noexcept{
        return std::exchange(_sg, new_sg);
    }
public:
    explicit task(scheduling_group sg = current_scheduling_group()) noexcept : _sg(sg) {}
    virtual void run_and_dispose() noexcept = 0;

    virtual task* waiting_task() noexcept = 0;
    scheduling_group group() const { return _sg; }
    shared_backtrace get_backtrace() const;



    void make_backtrace() noexcept {}

};

inline
shared_backtrace task::get_backtrace() const {



    return {};

}



void schedule(task* t) noexcept;
void schedule_checked(task* t) noexcept;
void schedule_urgent(task* t) noexcept;


}
# 37 "/home/avi/scylla-maint/seastar/include/seastar/core/future.hh" 2
# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/thread_impl.hh" 1
# 24 "/home/avi/scylla-maint/seastar/include/seastar/core/thread_impl.hh"
# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/preempt.hh" 1
# 24 "/home/avi/scylla-maint/seastar/include/seastar/core/preempt.hh"
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/atomic" 1 3
# 36 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/atomic" 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/atomic" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 49 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/atomic" 2 3



namespace std __attribute__ ((__visibility__ ("default")))
{







  template<typename _Tp>
    struct atomic;



  template<>
  struct atomic<bool>
  {
    using value_type = bool;

  private:
    __atomic_base<bool> _M_base;

  public:
    atomic() noexcept = default;
    ~atomic() noexcept = default;
    atomic(const atomic&) = delete;
    atomic& operator=(const atomic&) = delete;
    atomic& operator=(const atomic&) volatile = delete;

    constexpr atomic(bool __i) noexcept : _M_base(__i) { }

    bool
    operator=(bool __i) noexcept
    { return _M_base.operator=(__i); }

    bool
    operator=(bool __i) volatile noexcept
    { return _M_base.operator=(__i); }

    operator bool() const noexcept
    { return _M_base.load(); }

    operator bool() const volatile noexcept
    { return _M_base.load(); }

    bool
    is_lock_free() const noexcept { return _M_base.is_lock_free(); }

    bool
    is_lock_free() const volatile noexcept { return _M_base.is_lock_free(); }


    static constexpr bool is_always_lock_free = 2 == 2;


    void
    store(bool __i, memory_order __m = memory_order_seq_cst) noexcept
    { _M_base.store(__i, __m); }

    void
    store(bool __i, memory_order __m = memory_order_seq_cst) volatile noexcept
    { _M_base.store(__i, __m); }

    bool
    load(memory_order __m = memory_order_seq_cst) const noexcept
    { return _M_base.load(__m); }

    bool
    load(memory_order __m = memory_order_seq_cst) const volatile noexcept
    { return _M_base.load(__m); }

    bool
    exchange(bool __i, memory_order __m = memory_order_seq_cst) noexcept
    { return _M_base.exchange(__i, __m); }

    bool
    exchange(bool __i,
      memory_order __m = memory_order_seq_cst) volatile noexcept
    { return _M_base.exchange(__i, __m); }

    bool
    compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1,
     memory_order __m2) noexcept
    { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); }

    bool
    compare_exchange_weak(bool& __i1, bool __i2, memory_order __m1,
     memory_order __m2) volatile noexcept
    { return _M_base.compare_exchange_weak(__i1, __i2, __m1, __m2); }

    bool
    compare_exchange_weak(bool& __i1, bool __i2,
     memory_order __m = memory_order_seq_cst) noexcept
    { return _M_base.compare_exchange_weak(__i1, __i2, __m); }

    bool
    compare_exchange_weak(bool& __i1, bool __i2,
       memory_order __m = memory_order_seq_cst) volatile noexcept
    { return _M_base.compare_exchange_weak(__i1, __i2, __m); }

    bool
    compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1,
       memory_order __m2) noexcept
    { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); }

    bool
    compare_exchange_strong(bool& __i1, bool __i2, memory_order __m1,
       memory_order __m2) volatile noexcept
    { return _M_base.compare_exchange_strong(__i1, __i2, __m1, __m2); }

    bool
    compare_exchange_strong(bool& __i1, bool __i2,
       memory_order __m = memory_order_seq_cst) noexcept
    { return _M_base.compare_exchange_strong(__i1, __i2, __m); }

    bool
    compare_exchange_strong(bool& __i1, bool __i2,
      memory_order __m = memory_order_seq_cst) volatile noexcept
    { return _M_base.compare_exchange_strong(__i1, __i2, __m); }


    void
    wait(bool __old, memory_order __m = memory_order_seq_cst) const noexcept
    { _M_base.wait(__old, __m); }



    void
    notify_one() noexcept
    { _M_base.notify_one(); }

    void
    notify_all() noexcept
    { _M_base.notify_all(); }

  };
# 202 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/atomic" 3
  template<typename _Tp>
    struct atomic
    {
      using value_type = _Tp;

    private:

      static constexpr int _S_min_alignment
 = (sizeof(_Tp) & (sizeof(_Tp) - 1)) || sizeof(_Tp) > 16
 ? 0 : sizeof(_Tp);

      static constexpr int _S_alignment
        = _S_min_alignment > alignof(_Tp) ? _S_min_alignment : alignof(_Tp);

      alignas(_S_alignment) _Tp _M_i = _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<void *>(-_S_alignment));
      }

      bool
      is_lock_free() const volatile noexcept
      {

 return __atomic_is_lock_free(sizeof(_M_i),
     reinterpret_cast<void *>(-_S_alignment));
      }


      static constexpr bool is_always_lock_free
 = __atomic_always_lock_free(sizeof(_M_i), 0);


      void
      store(_Tp __i, memory_order __m = memory_order_seq_cst) noexcept
      {
 __atomic_store(std::__addressof(_M_i),
         __atomic_impl::__clear_padding(__i),
         int(__m));
      }

      void
      store(_Tp __i, memory_order __m = memory_order_seq_cst) volatile noexcept
      {
 __atomic_store(std::__addressof(_M_i),
         __atomic_impl::__clear_padding(__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),
     __atomic_impl::__clear_padding(__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),
     __atomic_impl::__clear_padding(__i),
     __ptr, int(__m));
 return *__ptr;
      }

      bool
      compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s,
       memory_order __f) noexcept
      {
 return __atomic_impl::__compare_exchange(_M_i, __e, __i, true,
       __s, __f);
      }

      bool
      compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s,
       memory_order __f) volatile noexcept
      {
 return __atomic_impl::__compare_exchange(_M_i, __e, __i, true,
       __s, __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_impl::__compare_exchange(_M_i, __e, __i, false,
       __s, __f);
      }

      bool
      compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s,
         memory_order __f) volatile noexcept
      {
 return __atomic_impl::__compare_exchange(_M_i, __e, __i, false,
       __s, __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)); }


      void
      wait(_Tp __old, memory_order __m = memory_order_seq_cst) const noexcept
      {
 std::__atomic_wait_address_v(&_M_i, __old,
      [__m, this] { return this->load(__m); });
      }



      void
      notify_one() noexcept
      { std::__atomic_notify_address(&_M_i, false); }

      void
      notify_all() noexcept
      { std::__atomic_notify_address(&_M_i, true); }


    };



  template<typename _Tp>
    struct atomic<_Tp*>
    {
      using value_type = _Tp*;
      using difference_type = ptrdiff_t;

      typedef _Tp* __pointer_type;
      typedef __atomic_base<_Tp*> __base_type;
      __base_type _M_b;

      atomic() noexcept = default;
      ~atomic() noexcept = default;
      atomic(const atomic&) = delete;
      atomic& operator=(const atomic&) = delete;
      atomic& operator=(const atomic&) volatile = delete;

      constexpr atomic(__pointer_type __p) noexcept : _M_b(__p) { }

      operator __pointer_type() const noexcept
      { return __pointer_type(_M_b); }

      operator __pointer_type() const volatile noexcept
      { return __pointer_type(_M_b); }

      __pointer_type
      operator=(__pointer_type __p) noexcept
      { return _M_b.operator=(__p); }

      __pointer_type
      operator=(__pointer_type __p) volatile noexcept
      { return _M_b.operator=(__p); }

      __pointer_type
      operator++(int) noexcept
      {

 static_assert( is_object<_Tp>::value, "pointer to object type" );

 return _M_b++;
      }

      __pointer_type
      operator++(int) volatile noexcept
      {

 static_assert( is_object<_Tp>::value, "pointer to object type" );

 return _M_b++;
      }

      __pointer_type
      operator--(int) noexcept
      {

 static_assert( is_object<_Tp>::value, "pointer to object type" );

 return _M_b--;
      }

      __pointer_type
      operator--(int) volatile noexcept
      {

 static_assert( is_object<_Tp>::value, "pointer to object type" );

 return _M_b--;
      }

      __pointer_type
      operator++() noexcept
      {

 static_assert( is_object<_Tp>::value, "pointer to object type" );

 return ++_M_b;
      }

      __pointer_type
      operator++() volatile noexcept
      {

 static_assert( is_object<_Tp>::value, "pointer to object type" );

 return ++_M_b;
      }

      __pointer_type
      operator--() noexcept
      {

 static_assert( is_object<_Tp>::value, "pointer to object type" );

 return --_M_b;
      }

      __pointer_type
      operator--() volatile noexcept
      {

 static_assert( is_object<_Tp>::value, "pointer to object type" );

 return --_M_b;
      }

      __pointer_type
      operator+=(ptrdiff_t __d) noexcept
      {

 static_assert( is_object<_Tp>::value, "pointer to object type" );

 return _M_b.operator+=(__d);
      }

      __pointer_type
      operator+=(ptrdiff_t __d) volatile noexcept
      {

 static_assert( is_object<_Tp>::value, "pointer to object type" );

 return _M_b.operator+=(__d);
      }

      __pointer_type
      operator-=(ptrdiff_t __d) noexcept
      {

 static_assert( is_object<_Tp>::value, "pointer to object type" );

 return _M_b.operator-=(__d);
      }

      __pointer_type
      operator-=(ptrdiff_t __d) volatile noexcept
      {

 static_assert( is_object<_Tp>::value, "pointer to object type" );

 return _M_b.operator-=(__d);
      }

      bool
      is_lock_free() const noexcept
      { return _M_b.is_lock_free(); }

      bool
      is_lock_free() const volatile noexcept
      { return _M_b.is_lock_free(); }


      static constexpr bool is_always_lock_free
 = 2 == 2;


      void
      store(__pointer_type __p,
     memory_order __m = memory_order_seq_cst) noexcept
      { return _M_b.store(__p, __m); }

      void
      store(__pointer_type __p,
     memory_order __m = memory_order_seq_cst) volatile noexcept
      { return _M_b.store(__p, __m); }

      __pointer_type
      load(memory_order __m = memory_order_seq_cst) const noexcept
      { return _M_b.load(__m); }

      __pointer_type
      load(memory_order __m = memory_order_seq_cst) const volatile noexcept
      { return _M_b.load(__m); }

      __pointer_type
      exchange(__pointer_type __p,
        memory_order __m = memory_order_seq_cst) noexcept
      { return _M_b.exchange(__p, __m); }

      __pointer_type
      exchange(__pointer_type __p,
        memory_order __m = memory_order_seq_cst) volatile noexcept
      { return _M_b.exchange(__p, __m); }

      bool
      compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2,
       memory_order __m1, memory_order __m2) noexcept
      { return _M_b.compare_exchange_weak(__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_weak(__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));
      }


    void
    wait(__pointer_type __old, memory_order __m = memory_order_seq_cst) const noexcept
    { _M_b.wait(__old, __m); }



    void
    notify_one() noexcept
    { _M_b.notify_one(); }

    void
    notify_all() noexcept
    { _M_b.notify_all(); }


      __pointer_type
      fetch_add(ptrdiff_t __d,
  memory_order __m = memory_order_seq_cst) noexcept
      {

 static_assert( is_object<_Tp>::value, "pointer to object type" );

 return _M_b.fetch_add(__d, __m);
      }

      __pointer_type
      fetch_add(ptrdiff_t __d,
  memory_order __m = memory_order_seq_cst) volatile noexcept
      {

 static_assert( is_object<_Tp>::value, "pointer to object type" );

 return _M_b.fetch_add(__d, __m);
      }

      __pointer_type
      fetch_sub(ptrdiff_t __d,
  memory_order __m = memory_order_seq_cst) noexcept
      {

 static_assert( is_object<_Tp>::value, "pointer to object type" );

 return _M_b.fetch_sub(__d, __m);
      }

      __pointer_type
      fetch_sub(ptrdiff_t __d,
  memory_order __m = memory_order_seq_cst) volatile noexcept
      {

 static_assert( is_object<_Tp>::value, "pointer to object type" );

 return _M_b.fetch_sub(__d, __m);
      }
    };



  template<>
    struct atomic<char> : __atomic_base<char>
    {
      typedef char __integral_type;
      typedef __atomic_base<char> __base_type;

      atomic() noexcept = default;
      ~atomic() noexcept = default;
      atomic(const atomic&) = delete;
      atomic& operator=(const atomic&) = delete;
      atomic& operator=(const atomic&) volatile = delete;

      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

      using __base_type::operator __integral_type;
      using __base_type::operator=;


      static constexpr bool is_always_lock_free = 2 == 2;

    };


  template<>
    struct atomic<signed char> : __atomic_base<signed char>
    {
      typedef signed char __integral_type;
      typedef __atomic_base<signed char> __base_type;

      atomic() noexcept= default;
      ~atomic() noexcept = default;
      atomic(const atomic&) = delete;
      atomic& operator=(const atomic&) = delete;
      atomic& operator=(const atomic&) volatile = delete;

      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

      using __base_type::operator __integral_type;
      using __base_type::operator=;


      static constexpr bool is_always_lock_free = 2 == 2;

    };


  template<>
    struct atomic<unsigned char> : __atomic_base<unsigned char>
    {
      typedef unsigned char __integral_type;
      typedef __atomic_base<unsigned char> __base_type;

      atomic() noexcept= default;
      ~atomic() noexcept = default;
      atomic(const atomic&) = delete;
      atomic& operator=(const atomic&) = delete;
      atomic& operator=(const atomic&) volatile = delete;

      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

      using __base_type::operator __integral_type;
      using __base_type::operator=;


      static constexpr bool is_always_lock_free = 2 == 2;

    };


  template<>
    struct atomic<short> : __atomic_base<short>
    {
      typedef short __integral_type;
      typedef __atomic_base<short> __base_type;

      atomic() noexcept = default;
      ~atomic() noexcept = default;
      atomic(const atomic&) = delete;
      atomic& operator=(const atomic&) = delete;
      atomic& operator=(const atomic&) volatile = delete;

      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

      using __base_type::operator __integral_type;
      using __base_type::operator=;


      static constexpr bool is_always_lock_free = 2 == 2;

    };


  template<>
    struct atomic<unsigned short> : __atomic_base<unsigned short>
    {
      typedef unsigned short __integral_type;
      typedef __atomic_base<unsigned short> __base_type;

      atomic() noexcept = default;
      ~atomic() noexcept = default;
      atomic(const atomic&) = delete;
      atomic& operator=(const atomic&) = delete;
      atomic& operator=(const atomic&) volatile = delete;

      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

      using __base_type::operator __integral_type;
      using __base_type::operator=;


      static constexpr bool is_always_lock_free = 2 == 2;

    };


  template<>
    struct atomic<int> : __atomic_base<int>
    {
      typedef int __integral_type;
      typedef __atomic_base<int> __base_type;

      atomic() noexcept = default;
      ~atomic() noexcept = default;
      atomic(const atomic&) = delete;
      atomic& operator=(const atomic&) = delete;
      atomic& operator=(const atomic&) volatile = delete;

      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

      using __base_type::operator __integral_type;
      using __base_type::operator=;


      static constexpr bool is_always_lock_free = 2 == 2;

    };


  template<>
    struct atomic<unsigned int> : __atomic_base<unsigned int>
    {
      typedef unsigned int __integral_type;
      typedef __atomic_base<unsigned int> __base_type;

      atomic() noexcept = default;
      ~atomic() noexcept = default;
      atomic(const atomic&) = delete;
      atomic& operator=(const atomic&) = delete;
      atomic& operator=(const atomic&) volatile = delete;

      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

      using __base_type::operator __integral_type;
      using __base_type::operator=;


      static constexpr bool is_always_lock_free = 2 == 2;

    };


  template<>
    struct atomic<long> : __atomic_base<long>
    {
      typedef long __integral_type;
      typedef __atomic_base<long> __base_type;

      atomic() noexcept = default;
      ~atomic() noexcept = default;
      atomic(const atomic&) = delete;
      atomic& operator=(const atomic&) = delete;
      atomic& operator=(const atomic&) volatile = delete;

      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

      using __base_type::operator __integral_type;
      using __base_type::operator=;


      static constexpr bool is_always_lock_free = 2 == 2;

    };


  template<>
    struct atomic<unsigned long> : __atomic_base<unsigned long>
    {
      typedef unsigned long __integral_type;
      typedef __atomic_base<unsigned long> __base_type;

      atomic() noexcept = default;
      ~atomic() noexcept = default;
      atomic(const atomic&) = delete;
      atomic& operator=(const atomic&) = delete;
      atomic& operator=(const atomic&) volatile = delete;

      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

      using __base_type::operator __integral_type;
      using __base_type::operator=;


      static constexpr bool is_always_lock_free = 2 == 2;

    };


  template<>
    struct atomic<long long> : __atomic_base<long long>
    {
      typedef long long __integral_type;
      typedef __atomic_base<long long> __base_type;

      atomic() noexcept = default;
      ~atomic() noexcept = default;
      atomic(const atomic&) = delete;
      atomic& operator=(const atomic&) = delete;
      atomic& operator=(const atomic&) volatile = delete;

      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

      using __base_type::operator __integral_type;
      using __base_type::operator=;


      static constexpr bool is_always_lock_free = 2 == 2;

    };


  template<>
    struct atomic<unsigned long long> : __atomic_base<unsigned long long>
    {
      typedef unsigned long long __integral_type;
      typedef __atomic_base<unsigned long long> __base_type;

      atomic() noexcept = default;
      ~atomic() noexcept = default;
      atomic(const atomic&) = delete;
      atomic& operator=(const atomic&) = delete;
      atomic& operator=(const atomic&) volatile = delete;

      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

      using __base_type::operator __integral_type;
      using __base_type::operator=;


      static constexpr bool is_always_lock_free = 2 == 2;

    };


  template<>
    struct atomic<wchar_t> : __atomic_base<wchar_t>
    {
      typedef wchar_t __integral_type;
      typedef __atomic_base<wchar_t> __base_type;

      atomic() noexcept = default;
      ~atomic() noexcept = default;
      atomic(const atomic&) = delete;
      atomic& operator=(const atomic&) = delete;
      atomic& operator=(const atomic&) volatile = delete;

      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

      using __base_type::operator __integral_type;
      using __base_type::operator=;


      static constexpr bool is_always_lock_free = 2 == 2;

    };



  template<>
    struct atomic<char8_t> : __atomic_base<char8_t>
    {
      typedef char8_t __integral_type;
      typedef __atomic_base<char8_t> __base_type;

      atomic() noexcept = default;
      ~atomic() noexcept = default;
      atomic(const atomic&) = delete;
      atomic& operator=(const atomic&) = delete;
      atomic& operator=(const atomic&) volatile = delete;

      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

      using __base_type::operator __integral_type;
      using __base_type::operator=;


      static constexpr bool is_always_lock_free
 = 2 == 2;

    };



  template<>
    struct atomic<char16_t> : __atomic_base<char16_t>
    {
      typedef char16_t __integral_type;
      typedef __atomic_base<char16_t> __base_type;

      atomic() noexcept = default;
      ~atomic() noexcept = default;
      atomic(const atomic&) = delete;
      atomic& operator=(const atomic&) = delete;
      atomic& operator=(const atomic&) volatile = delete;

      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

      using __base_type::operator __integral_type;
      using __base_type::operator=;


      static constexpr bool is_always_lock_free
 = 2 == 2;

    };


  template<>
    struct atomic<char32_t> : __atomic_base<char32_t>
    {
      typedef char32_t __integral_type;
      typedef __atomic_base<char32_t> __base_type;

      atomic() noexcept = default;
      ~atomic() noexcept = default;
      atomic(const atomic&) = delete;
      atomic& operator=(const atomic&) = delete;
      atomic& operator=(const atomic&) volatile = delete;

      constexpr atomic(__integral_type __i) noexcept : __base_type(__i) { }

      using __base_type::operator __integral_type;
      using __base_type::operator=;


      static constexpr bool is_always_lock_free
 = 2 == 2;

    };



  typedef atomic<bool> atomic_bool;


  typedef atomic<char> atomic_char;


  typedef atomic<signed char> atomic_schar;


  typedef atomic<unsigned char> atomic_uchar;


  typedef atomic<short> atomic_short;


  typedef atomic<unsigned short> atomic_ushort;


  typedef atomic<int> atomic_int;


  typedef atomic<unsigned int> atomic_uint;


  typedef atomic<long> atomic_long;


  typedef atomic<unsigned long> atomic_ulong;


  typedef atomic<long long> atomic_llong;


  typedef atomic<unsigned long long> atomic_ullong;


  typedef atomic<wchar_t> atomic_wchar_t;



  typedef atomic<char8_t> atomic_char8_t;



  typedef atomic<char16_t> atomic_char16_t;


  typedef atomic<char32_t> atomic_char32_t;






  typedef atomic<int8_t> atomic_int8_t;


  typedef atomic<uint8_t> atomic_uint8_t;


  typedef atomic<int16_t> atomic_int16_t;


  typedef atomic<uint16_t> atomic_uint16_t;


  typedef atomic<int32_t> atomic_int32_t;


  typedef atomic<uint32_t> atomic_uint32_t;


  typedef atomic<int64_t> atomic_int64_t;


  typedef atomic<uint64_t> atomic_uint64_t;



  typedef atomic<int_least8_t> atomic_int_least8_t;


  typedef atomic<uint_least8_t> atomic_uint_least8_t;


  typedef atomic<int_least16_t> atomic_int_least16_t;


  typedef atomic<uint_least16_t> atomic_uint_least16_t;


  typedef atomic<int_least32_t> atomic_int_least32_t;


  typedef atomic<uint_least32_t> atomic_uint_least32_t;


  typedef atomic<int_least64_t> atomic_int_least64_t;


  typedef atomic<uint_least64_t> atomic_uint_least64_t;



  typedef atomic<int_fast8_t> atomic_int_fast8_t;


  typedef atomic<uint_fast8_t> atomic_uint_fast8_t;


  typedef atomic<int_fast16_t> atomic_int_fast16_t;


  typedef atomic<uint_fast16_t> atomic_uint_fast16_t;


  typedef atomic<int_fast32_t> atomic_int_fast32_t;


  typedef atomic<uint_fast32_t> atomic_uint_fast32_t;


  typedef atomic<int_fast64_t> atomic_int_fast64_t;


  typedef atomic<uint_fast64_t> atomic_uint_fast64_t;



  typedef atomic<intptr_t> atomic_intptr_t;


  typedef atomic<uintptr_t> atomic_uintptr_t;


  typedef atomic<size_t> atomic_size_t;


  typedef atomic<ptrdiff_t> atomic_ptrdiff_t;


  typedef atomic<intmax_t> atomic_intmax_t;


  typedef atomic<uintmax_t> atomic_uintmax_t;


  inline bool
  atomic_flag_test_and_set_explicit(atomic_flag* __a,
        memory_order __m) noexcept
  { return __a->test_and_set(__m); }

  inline bool
  atomic_flag_test_and_set_explicit(volatile atomic_flag* __a,
        memory_order __m) noexcept
  { return __a->test_and_set(__m); }


  inline bool
  atomic_flag_test(const atomic_flag* __a) noexcept
  { return __a->test(); }

  inline bool
  atomic_flag_test(const volatile atomic_flag* __a) noexcept
  { return __a->test(); }

  inline bool
  atomic_flag_test_explicit(const atomic_flag* __a,
       memory_order __m) noexcept
  { return __a->test(__m); }

  inline bool
  atomic_flag_test_explicit(const volatile atomic_flag* __a,
       memory_order __m) noexcept
  { return __a->test(__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); }


  inline void
  atomic_flag_wait(atomic_flag* __a, bool __old) noexcept
  { __a->wait(__old); }

  inline void
  atomic_flag_wait_explicit(atomic_flag* __a, bool __old,
                                memory_order __m) noexcept
  { __a->wait(__old, __m); }

  inline void
  atomic_flag_notify_one(atomic_flag* __a) noexcept
  { __a->notify_one(); }

  inline void
  atomic_flag_notify_all(atomic_flag* __a) noexcept
  { __a->notify_all(); }





  template<typename _Tp>
    using __atomic_val_t = __type_identity_t<_Tp>;
  template<typename _Tp>
    using __atomic_diff_t = typename atomic<_Tp>::difference_type;




  template<typename _ITp>
    inline bool
    atomic_is_lock_free(const atomic<_ITp>* __a) noexcept
    { return __a->is_lock_free(); }

  template<typename _ITp>
    inline bool
    atomic_is_lock_free(const volatile atomic<_ITp>* __a) noexcept
    { return __a->is_lock_free(); }

  template<typename _ITp>
    inline void
    atomic_init(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept
    { __a->store(__i, memory_order_relaxed); }

  template<typename _ITp>
    inline void
    atomic_init(volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept
    { __a->store(__i, memory_order_relaxed); }

  template<typename _ITp>
    inline void
    atomic_store_explicit(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i,
     memory_order __m) noexcept
    { __a->store(__i, __m); }

  template<typename _ITp>
    inline void
    atomic_store_explicit(volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i,
     memory_order __m) noexcept
    { __a->store(__i, __m); }

  template<typename _ITp>
    inline _ITp
    atomic_load_explicit(const atomic<_ITp>* __a, memory_order __m) noexcept
    { return __a->load(__m); }

  template<typename _ITp>
    inline _ITp
    atomic_load_explicit(const volatile atomic<_ITp>* __a,
    memory_order __m) noexcept
    { return __a->load(__m); }

  template<typename _ITp>
    inline _ITp
    atomic_exchange_explicit(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i,
        memory_order __m) noexcept
    { return __a->exchange(__i, __m); }

  template<typename _ITp>
    inline _ITp
    atomic_exchange_explicit(volatile atomic<_ITp>* __a,
        __atomic_val_t<_ITp> __i,
        memory_order __m) noexcept
    { return __a->exchange(__i, __m); }

  template<typename _ITp>
    inline bool
    atomic_compare_exchange_weak_explicit(atomic<_ITp>* __a,
       __atomic_val_t<_ITp>* __i1,
       __atomic_val_t<_ITp> __i2,
       memory_order __m1,
       memory_order __m2) noexcept
    { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }

  template<typename _ITp>
    inline bool
    atomic_compare_exchange_weak_explicit(volatile atomic<_ITp>* __a,
       __atomic_val_t<_ITp>* __i1,
       __atomic_val_t<_ITp> __i2,
       memory_order __m1,
       memory_order __m2) noexcept
    { return __a->compare_exchange_weak(*__i1, __i2, __m1, __m2); }

  template<typename _ITp>
    inline bool
    atomic_compare_exchange_strong_explicit(atomic<_ITp>* __a,
         __atomic_val_t<_ITp>* __i1,
         __atomic_val_t<_ITp> __i2,
         memory_order __m1,
         memory_order __m2) noexcept
    { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }

  template<typename _ITp>
    inline bool
    atomic_compare_exchange_strong_explicit(volatile atomic<_ITp>* __a,
         __atomic_val_t<_ITp>* __i1,
         __atomic_val_t<_ITp> __i2,
         memory_order __m1,
         memory_order __m2) noexcept
    { return __a->compare_exchange_strong(*__i1, __i2, __m1, __m2); }


  template<typename _ITp>
    inline void
    atomic_store(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept
    { atomic_store_explicit(__a, __i, memory_order_seq_cst); }

  template<typename _ITp>
    inline void
    atomic_store(volatile atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept
    { atomic_store_explicit(__a, __i, memory_order_seq_cst); }

  template<typename _ITp>
    inline _ITp
    atomic_load(const atomic<_ITp>* __a) noexcept
    { return atomic_load_explicit(__a, memory_order_seq_cst); }

  template<typename _ITp>
    inline _ITp
    atomic_load(const volatile atomic<_ITp>* __a) noexcept
    { return atomic_load_explicit(__a, memory_order_seq_cst); }

  template<typename _ITp>
    inline _ITp
    atomic_exchange(atomic<_ITp>* __a, __atomic_val_t<_ITp> __i) noexcept
    { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }

  template<typename _ITp>
    inline _ITp
    atomic_exchange(volatile atomic<_ITp>* __a,
      __atomic_val_t<_ITp> __i) noexcept
    { return atomic_exchange_explicit(__a, __i, memory_order_seq_cst); }

  template<typename _ITp>
    inline bool
    atomic_compare_exchange_weak(atomic<_ITp>* __a,
     __atomic_val_t<_ITp>* __i1,
     __atomic_val_t<_ITp> __i2) noexcept
    {
      return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
         memory_order_seq_cst,
         memory_order_seq_cst);
    }

  template<typename _ITp>
    inline bool
    atomic_compare_exchange_weak(volatile atomic<_ITp>* __a,
     __atomic_val_t<_ITp>* __i1,
     __atomic_val_t<_ITp> __i2) noexcept
    {
      return atomic_compare_exchange_weak_explicit(__a, __i1, __i2,
         memory_order_seq_cst,
         memory_order_seq_cst);
    }

  template<typename _ITp>
    inline bool
    atomic_compare_exchange_strong(atomic<_ITp>* __a,
       __atomic_val_t<_ITp>* __i1,
       __atomic_val_t<_ITp> __i2) noexcept
    {
      return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
           memory_order_seq_cst,
           memory_order_seq_cst);
    }

  template<typename _ITp>
    inline bool
    atomic_compare_exchange_strong(volatile atomic<_ITp>* __a,
       __atomic_val_t<_ITp>* __i1,
       __atomic_val_t<_ITp> __i2) noexcept
    {
      return atomic_compare_exchange_strong_explicit(__a, __i1, __i2,
           memory_order_seq_cst,
           memory_order_seq_cst);
    }



  template<typename _Tp>
    inline void
    atomic_wait(const atomic<_Tp>* __a,
         typename std::atomic<_Tp>::value_type __old) noexcept
    { __a->wait(__old); }

  template<typename _Tp>
    inline void
    atomic_wait_explicit(const atomic<_Tp>* __a,
    typename std::atomic<_Tp>::value_type __old,
    std::memory_order __m) noexcept
    { __a->wait(__old, __m); }

  template<typename _Tp>
    inline void
    atomic_notify_one(atomic<_Tp>* __a) noexcept
    { __a->notify_one(); }

  template<typename _Tp>
    inline void
    atomic_notify_all(atomic<_Tp>* __a) noexcept
    { __a->notify_all(); }






  template<typename _ITp>
    inline _ITp
    atomic_fetch_add_explicit(atomic<_ITp>* __a,
         __atomic_diff_t<_ITp> __i,
         memory_order __m) noexcept
    { return __a->fetch_add(__i, __m); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_add_explicit(volatile atomic<_ITp>* __a,
         __atomic_diff_t<_ITp> __i,
         memory_order __m) noexcept
    { return __a->fetch_add(__i, __m); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_sub_explicit(atomic<_ITp>* __a,
         __atomic_diff_t<_ITp> __i,
         memory_order __m) noexcept
    { return __a->fetch_sub(__i, __m); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_sub_explicit(volatile atomic<_ITp>* __a,
         __atomic_diff_t<_ITp> __i,
         memory_order __m) noexcept
    { return __a->fetch_sub(__i, __m); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_and_explicit(__atomic_base<_ITp>* __a,
         __atomic_val_t<_ITp> __i,
         memory_order __m) noexcept
    { return __a->fetch_and(__i, __m); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_and_explicit(volatile __atomic_base<_ITp>* __a,
         __atomic_val_t<_ITp> __i,
         memory_order __m) noexcept
    { return __a->fetch_and(__i, __m); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_or_explicit(__atomic_base<_ITp>* __a,
        __atomic_val_t<_ITp> __i,
        memory_order __m) noexcept
    { return __a->fetch_or(__i, __m); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_or_explicit(volatile __atomic_base<_ITp>* __a,
        __atomic_val_t<_ITp> __i,
        memory_order __m) noexcept
    { return __a->fetch_or(__i, __m); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_xor_explicit(__atomic_base<_ITp>* __a,
         __atomic_val_t<_ITp> __i,
         memory_order __m) noexcept
    { return __a->fetch_xor(__i, __m); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_xor_explicit(volatile __atomic_base<_ITp>* __a,
         __atomic_val_t<_ITp> __i,
         memory_order __m) noexcept
    { return __a->fetch_xor(__i, __m); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_add(atomic<_ITp>* __a,
       __atomic_diff_t<_ITp> __i) noexcept
    { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_add(volatile atomic<_ITp>* __a,
       __atomic_diff_t<_ITp> __i) noexcept
    { return atomic_fetch_add_explicit(__a, __i, memory_order_seq_cst); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_sub(atomic<_ITp>* __a,
       __atomic_diff_t<_ITp> __i) noexcept
    { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_sub(volatile atomic<_ITp>* __a,
       __atomic_diff_t<_ITp> __i) noexcept
    { return atomic_fetch_sub_explicit(__a, __i, memory_order_seq_cst); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_and(__atomic_base<_ITp>* __a,
       __atomic_val_t<_ITp> __i) noexcept
    { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_and(volatile __atomic_base<_ITp>* __a,
       __atomic_val_t<_ITp> __i) noexcept
    { return atomic_fetch_and_explicit(__a, __i, memory_order_seq_cst); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_or(__atomic_base<_ITp>* __a,
      __atomic_val_t<_ITp> __i) noexcept
    { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_or(volatile __atomic_base<_ITp>* __a,
      __atomic_val_t<_ITp> __i) noexcept
    { return atomic_fetch_or_explicit(__a, __i, memory_order_seq_cst); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_xor(__atomic_base<_ITp>* __a,
       __atomic_val_t<_ITp> __i) noexcept
    { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }

  template<typename _ITp>
    inline _ITp
    atomic_fetch_xor(volatile __atomic_base<_ITp>* __a,
       __atomic_val_t<_ITp> __i) noexcept
    { return atomic_fetch_xor_explicit(__a, __i, memory_order_seq_cst); }


  template<>
    struct atomic<float> : __atomic_float<float>
    {
      atomic() noexcept = default;

      constexpr
      atomic(float __fp) noexcept : __atomic_float<float>(__fp)
      { }

      atomic& operator=(const atomic&) volatile = delete;
      atomic& operator=(const atomic&) = delete;

      using __atomic_float<float>::operator=;
    };

  template<>
    struct atomic<double> : __atomic_float<double>
    {
      atomic() noexcept = default;

      constexpr
      atomic(double __fp) noexcept : __atomic_float<double>(__fp)
      { }

      atomic& operator=(const atomic&) volatile = delete;
      atomic& operator=(const atomic&) = delete;

      using __atomic_float<double>::operator=;
    };

  template<>
    struct atomic<long double> : __atomic_float<long double>
    {
      atomic() noexcept = default;

      constexpr
      atomic(long double __fp) noexcept : __atomic_float<long double>(__fp)
      { }

      atomic& operator=(const atomic&) volatile = delete;
      atomic& operator=(const atomic&) = delete;

      using __atomic_float<long double>::operator=;
    };
# 1756 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/atomic" 3
  template<typename _Tp>
    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=;
    };




  using atomic_signed_lock_free
    = atomic<make_signed_t<__detail::__platform_wait_t>>;
  using atomic_unsigned_lock_free
    = atomic<make_unsigned_t<__detail::__platform_wait_t>>;
# 1794 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/atomic" 3
}
# 25 "/home/avi/scylla-maint/seastar/include/seastar/core/preempt.hh" 2



namespace seastar {

namespace internal {

struct preemption_monitor {



    std::atomic<uint32_t> head;
    std::atomic<uint32_t> tail;
};




inline const preemption_monitor*& get_need_preempt_var() {
    static preemption_monitor bootstrap_preemption_monitor;
    static thread_local const preemption_monitor* g_need_preempt = &bootstrap_preemption_monitor;
    return g_need_preempt;
}


void set_need_preempt_var(const preemption_monitor* pm);

}


inline bool need_preempt() noexcept {


    std::atomic_signal_fence(std::memory_order_seq_cst);
    auto np = internal::get_need_preempt_var();


    auto head = np->head.load(std::memory_order_relaxed);
    auto tail = np->tail.load(std::memory_order_relaxed);


    return __builtin_expect(head != tail, false);



}

namespace internal {






inline
bool
scheduler_need_preempt() {

    return need_preempt();
# 93 "/home/avi/scylla-maint/seastar/include/seastar/core/preempt.hh"
}

}

}
# 25 "/home/avi/scylla-maint/seastar/include/seastar/core/thread_impl.hh" 2

# 1 "/usr/include/setjmp.h" 1 3 4
# 27 "/usr/include/setjmp.h" 3 4
extern "C" {




typedef struct __jmp_buf_tag jmp_buf[1];



extern int setjmp (jmp_buf __env) noexcept (true);




extern int __sigsetjmp (struct __jmp_buf_tag __env[1], int __savemask) noexcept (true);



extern int _setjmp (struct __jmp_buf_tag __env[1]) noexcept (true);
# 54 "/usr/include/setjmp.h" 3 4
extern void longjmp (struct __jmp_buf_tag __env[1], int __val)
     noexcept (true) __attribute__ ((__noreturn__));





extern void _longjmp (struct __jmp_buf_tag __env[1], int __val)
     noexcept (true) __attribute__ ((__noreturn__));







typedef struct __jmp_buf_tag sigjmp_buf[1];
# 80 "/usr/include/setjmp.h" 3 4
extern void siglongjmp (sigjmp_buf __env, int __val)
     noexcept (true) __attribute__ ((__noreturn__));
# 90 "/usr/include/setjmp.h" 3 4
}
# 27 "/home/avi/scylla-maint/seastar/include/seastar/core/thread_impl.hh" 2
# 1 "/usr/include/ucontext.h" 1 3 4
# 26 "/usr/include/ucontext.h" 3 4
# 1 "/usr/include/bits/indirect-return.h" 1 3 4
# 27 "/usr/include/ucontext.h" 2 3 4


# 1 "/usr/include/sys/ucontext.h" 1 3 4
# 25 "/usr/include/sys/ucontext.h" 3 4
# 1 "/usr/include/bits/types/stack_t.h" 1 3 4
# 23 "/usr/include/bits/types/stack_t.h" 3 4
# 1 "/usr/bin/../lib/clang/18/include/stddef.h" 1 3 4
# 77 "/usr/bin/../lib/clang/18/include/stddef.h" 3 4
# 1 "/usr/bin/../lib/clang/18/include/__stddef_size_t.h" 1 3 4
# 18 "/usr/bin/../lib/clang/18/include/__stddef_size_t.h" 3 4
typedef long unsigned int size_t;
# 78 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3 4
# 24 "/usr/include/bits/types/stack_t.h" 2 3 4


typedef struct
  {
    void *ss_sp;
    int ss_flags;
    size_t ss_size;
  } stack_t;
# 26 "/usr/include/sys/ucontext.h" 2 3 4
# 37 "/usr/include/sys/ucontext.h" 3 4
__extension__ typedef long long int greg_t;
# 46 "/usr/include/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;
# 30 "/usr/include/ucontext.h" 2 3 4

extern "C" {


extern int getcontext (ucontext_t *__ucp) noexcept (true);


extern int setcontext (const ucontext_t *__ucp) noexcept (true);



extern int swapcontext (ucontext_t *__restrict __oucp,
   const ucontext_t *__restrict __ucp)
  noexcept (true) ;







extern void makecontext (ucontext_t *__ucp, void (*__func) (void),
    int __argc, ...) noexcept (true);

}
# 28 "/home/avi/scylla-maint/seastar/include/seastar/core/thread_impl.hh" 2


namespace seastar {

using thread_clock = std::chrono::steady_clock;


class thread_context;
class scheduling_group;

struct jmp_buf_link {






    jmp_buf jmpbuf;

    jmp_buf_link* link;
    thread_context* thread;
public:
    void initial_switch_in(ucontext_t* initial_context, const void* stack_bottom, size_t stack_size);
    void switch_in();
    void switch_out();
    void initial_switch_in_completed();
    void final_switch_out();
};

extern thread_local jmp_buf_link* g_current_context;

namespace thread_impl {

inline thread_context* get() {
    return g_current_context->thread;
}

inline bool should_yield() {
    if (need_preempt()) {
        return true;
    } else {
        return false;
    }
}

scheduling_group sched_group(const thread_context*);

void yield();
void switch_in(thread_context* to);
void switch_out(thread_context* from);
void init();

}
}
# 38 "/home/avi/scylla-maint/seastar/include/seastar/core/future.hh" 2

# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/shard_id.hh" 1
# 28 "/home/avi/scylla-maint/seastar/include/seastar/core/shard_id.hh"
namespace seastar {



using shard_id = unsigned;



namespace internal {




inline shard_id* this_shard_id_ptr() noexcept {
    static thread_local shard_id g_this_shard_id;
    return &g_this_shard_id;
}


}




inline shard_id this_shard_id() noexcept {
    return *internal::this_shard_id_ptr();
}




}
# 40 "/home/avi/scylla-maint/seastar/include/seastar/core/future.hh" 2
# 1 "/home/avi/scylla-maint/seastar/include/seastar/util/critical_alloc_section.hh" 1
# 24 "/home/avi/scylla-maint/seastar/include/seastar/util/critical_alloc_section.hh"
namespace seastar {
namespace memory {
# 80 "/home/avi/scylla-maint/seastar/include/seastar/util/critical_alloc_section.hh"
struct [[maybe_unused]] scoped_critical_alloc_section {};

inline bool is_critical_alloc_section() {
    return false;
}



}
}
# 41 "/home/avi/scylla-maint/seastar/include/seastar/core/future.hh" 2
# 1 "/home/avi/scylla-maint/seastar/include/seastar/util/noncopyable_function.hh" 1
# 25 "/home/avi/scylla-maint/seastar/include/seastar/util/noncopyable_function.hh"
# 1 "/home/avi/scylla-maint/seastar/include/seastar/util/used_size.hh" 1
# 25 "/home/avi/scylla-maint/seastar/include/seastar/util/used_size.hh"
# 1 "/usr/bin/../lib/clang/18/include/stddef.h" 1 3
# 72 "/usr/bin/../lib/clang/18/include/stddef.h" 3
# 1 "/usr/bin/../lib/clang/18/include/__stddef_ptrdiff_t.h" 1 3
# 18 "/usr/bin/../lib/clang/18/include/__stddef_ptrdiff_t.h" 3
typedef long int ptrdiff_t;
# 73 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3




# 1 "/usr/bin/../lib/clang/18/include/__stddef_size_t.h" 1 3
# 18 "/usr/bin/../lib/clang/18/include/__stddef_size_t.h" 3
typedef long unsigned int size_t;
# 78 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3
# 87 "/usr/bin/../lib/clang/18/include/stddef.h" 3
# 1 "/usr/bin/../lib/clang/18/include/__stddef_wchar_t.h" 1 3
# 88 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3




# 1 "/usr/bin/../lib/clang/18/include/__stddef_null.h" 1 3
# 93 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3




# 1 "/usr/bin/../lib/clang/18/include/__stddef_nullptr_t.h" 1 3
# 98 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3
# 112 "/usr/bin/../lib/clang/18/include/stddef.h" 3
# 1 "/usr/bin/../lib/clang/18/include/__stddef_offsetof.h" 1 3
# 113 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3
# 26 "/home/avi/scylla-maint/seastar/include/seastar/util/used_size.hh" 2



namespace seastar {
namespace internal {


template<typename T>
struct used_size {
    static constexpr size_t value = std::is_empty_v<T> ? 0 : sizeof(T);
};
}
}
# 26 "/home/avi/scylla-maint/seastar/include/seastar/util/noncopyable_function.hh" 2








namespace seastar {

template <typename Signature>
class noncopyable_function;

namespace internal {

class noncopyable_function_base {
private:
    noncopyable_function_base() = default;
    static constexpr size_t nr_direct = 32;
    union [[gnu::may_alias]] storage {
        char direct[nr_direct];
        void* indirect;
    };
    using move_type = void (*)(noncopyable_function_base* from, noncopyable_function_base* to);
    using destroy_type = void (*)(noncopyable_function_base* func);

    static void empty_move(noncopyable_function_base*, noncopyable_function_base*) {}
    static void empty_destroy(noncopyable_function_base*) {}

    static void indirect_move(noncopyable_function_base* from, noncopyable_function_base* to) {
        using void_ptr = void*;
        new (&to->_storage.indirect) void_ptr(from->_storage.indirect);
    }

    template <size_t N>
    static void trivial_direct_move(noncopyable_function_base* from, noncopyable_function_base* to) {





#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wuninitialized"

        for (unsigned i = 0; i != N; ++i) {
            to->_storage.direct[i] = from->_storage.direct[i];
        }
#pragma GCC diagnostic pop
    }

    static void trivial_direct_destroy(noncopyable_function_base*) {
    }

private:
    storage _storage;

    template <typename Signature>
    friend class seastar::noncopyable_function;
};

template<typename FirstArg = void, typename... RemainingArgs>
struct is_nothrow_if_object {
    static constexpr bool value = is_nothrow_if_object<FirstArg>::value && is_nothrow_if_object<RemainingArgs...>::value;
};

template<typename Arg>
struct is_nothrow_if_object<Arg> {
    static constexpr bool value = !std::is_object_v<Arg> || std::is_nothrow_move_constructible_v<Arg>;
};

template<>
struct is_nothrow_if_object<> {
    static constexpr bool value = true;
};

}




template <typename Ret, typename... Args, bool Noexcept>
class noncopyable_function<Ret (Args...) noexcept(Noexcept)> : private internal::noncopyable_function_base {
    using call_type = Ret (*)(const noncopyable_function* func, Args...);
    struct vtable {
        const call_type call;
        const move_type move;
        const destroy_type destroy;
    };
private:
    const vtable* _vtable;
private:
    static Ret empty_call(const noncopyable_function*, [[maybe_unused]] Args... args) {
        throw std::bad_function_call();
    }

    static constexpr vtable _s_empty_vtable = {empty_call, empty_move, empty_destroy};

    template <typename Func>
    struct direct_vtable_for {
        static Func* access(noncopyable_function* func) { return reinterpret_cast<Func*>(func->_storage.direct); }
        static const Func* access(const noncopyable_function* func) { return reinterpret_cast<const Func*>(func->_storage.direct); }
        static Func* access(noncopyable_function_base* func) { return access(static_cast<noncopyable_function*>(func)); }
        static Ret call(const noncopyable_function* func, Args... args) noexcept(Noexcept) {
            return (*access(const_cast<noncopyable_function*>(func)))(std::forward<Args>(args)...);
        }
        static void move(noncopyable_function_base* from, noncopyable_function_base* to) {
            new (access(to)) Func(std::move(*access(from)));
            destroy(from);
        }
        static constexpr move_type select_move_thunk() {
            bool can_trivially_move = std::is_trivially_move_constructible_v<Func>
                    && std::is_trivially_destructible_v<Func>;
            return can_trivially_move ? trivial_direct_move<internal::used_size<Func>::value> : move;
        }
        static void destroy(noncopyable_function_base* func) {
            access(func)->~Func();
        }
        static constexpr destroy_type select_destroy_thunk() {
            return std::is_trivially_destructible_v<Func> ? trivial_direct_destroy : destroy;
        }
        static void initialize(Func&& from, noncopyable_function* to) {
            new (access(to)) Func(std::move(from));
        }
        static constexpr vtable make_vtable() { return { call, select_move_thunk(), select_destroy_thunk() }; }
        static const vtable s_vtable;
    };
    template <typename Func>
    struct indirect_vtable_for {
        static Func* access(noncopyable_function* func) { return reinterpret_cast<Func*>(func->_storage.indirect); }
        static const Func* access(const noncopyable_function* func) { return reinterpret_cast<const Func*>(func->_storage.indirect); }
        static Func* access(noncopyable_function_base* func) { return access(static_cast<noncopyable_function*>(func)); }
        static Ret call(const noncopyable_function* func, Args... args) noexcept(Noexcept) {
            return (*access(const_cast<noncopyable_function*>(func)))(std::forward<Args>(args)...);
        }
        static void destroy(noncopyable_function_base* func) {
            delete access(func);
        }
        static void initialize(Func&& from, noncopyable_function* to) {
            to->_storage.indirect = new Func(std::move(from));
        }
        static constexpr vtable make_vtable() { return { call, indirect_move, destroy }; }
        static const vtable s_vtable;
    };
    template <typename Func, bool Direct = true>
    struct select_vtable_for : direct_vtable_for<Func> {};
    template <typename Func>
    struct select_vtable_for<Func, false> : indirect_vtable_for<Func> {};
    template <typename Func>
    static constexpr bool is_direct() {
        return sizeof(Func) <= nr_direct && alignof(Func) <= alignof(storage)
                && std::is_nothrow_move_constructible_v<Func>;
    }
    template <typename Func>
    struct vtable_for : select_vtable_for<Func, is_direct<Func>()> {};
public:
    noncopyable_function() noexcept : _vtable(&_s_empty_vtable) {}
    template <typename Func>
    requires std::is_invocable_r_v<Ret, Func, Args...>
    noncopyable_function(Func func) {
        static_assert(!Noexcept || noexcept(std::declval<Func>()(std::declval<Args>()...)));
        vtable_for<Func>::initialize(std::move(func), this);
        _vtable = &vtable_for<Func>::s_vtable;
    }
    template <typename Object, typename... AllButFirstArg>
    noncopyable_function(Ret (Object::*member)(AllButFirstArg...) noexcept(Noexcept)) : noncopyable_function(std::mem_fn(member)) {}
    template <typename Object, typename... AllButFirstArg>
    noncopyable_function(Ret (Object::*member)(AllButFirstArg...) const noexcept(Noexcept)) : noncopyable_function(std::mem_fn(member)) {}

    ~noncopyable_function() {
        _vtable->destroy(this);
    }

    noncopyable_function(const noncopyable_function&) = delete;
    noncopyable_function& operator=(const noncopyable_function&) = delete;

    noncopyable_function(noncopyable_function&& x) noexcept : _vtable(std::exchange(x._vtable, &_s_empty_vtable)) {
        _vtable->move(&x, this);
    }

    noncopyable_function& operator=(noncopyable_function&& x) noexcept {
        if (this != &x) {
            this->~noncopyable_function();
            new (this) noncopyable_function(std::move(x));
        }
        return *this;
    }

    Ret operator()(Args... args) const noexcept(Noexcept) {
        static_assert(!Noexcept || internal::is_nothrow_if_object<Args...>::value);
        return _vtable->call(this, std::forward<Args>(args)...);
    }

    explicit operator bool() const {
        return _vtable != &_s_empty_vtable;
    }
};


template <typename Ret, typename... Args, bool Noexcept>
template <typename Func>
const typename noncopyable_function<Ret (Args...) noexcept(Noexcept)>::vtable noncopyable_function<Ret (Args...) noexcept(Noexcept)>::direct_vtable_for<Func>::s_vtable
        = noncopyable_function<Ret (Args...) noexcept(Noexcept)>::direct_vtable_for<Func>::make_vtable();


template <typename Ret, typename... Args, bool Noexcept>
template <typename Func>
const typename noncopyable_function<Ret (Args...) noexcept(Noexcept)>::vtable noncopyable_function<Ret (Args...) noexcept(Noexcept)>::indirect_vtable_for<Func>::s_vtable
        = noncopyable_function<Ret (Args...) noexcept(Noexcept)>::indirect_vtable_for<Func>::make_vtable();

}
# 42 "/home/avi/scylla-maint/seastar/include/seastar/core/future.hh" 2




namespace seastar {

struct nested_exception : public std::exception {
    std::exception_ptr inner;
    std::exception_ptr outer;
    nested_exception(std::exception_ptr inner, std::exception_ptr outer) noexcept;
    nested_exception(nested_exception&&) noexcept;
    nested_exception(const nested_exception&) noexcept;
    [[noreturn]] void rethrow_nested() const;
    virtual const char* what() const noexcept override;
};
# 149 "/home/avi/scylla-maint/seastar/include/seastar/core/future.hh"
template <class T = void>
class promise;

template <class T>
class future;

template <typename... T>
class shared_future;

struct future_state_base;







template <typename T = void, typename... A>
future<T> make_ready_future(A&&... value) noexcept;



template<typename T>
inline
future<std::remove_cv_t<std::remove_reference_t<T>>> as_ready_future(T&& v) noexcept {
    return make_ready_future<std::remove_cv_t<std::remove_reference_t<T>>>(
        std::forward<T>(v));
}







template <typename T = void>
future<T> make_exception_future(std::exception_ptr&& value) noexcept;

template <typename T = void, typename Exception>
future<T> make_exception_future(Exception&& ex) noexcept;

template <typename T = void>
future<T> make_exception_future(const std::exception_ptr& ex) noexcept {
    return make_exception_future<T>(std::exception_ptr(ex));
}

template <typename T = void>
future<T> make_exception_future(std::exception_ptr& ex) noexcept {
    return make_exception_future<T>(static_cast<const std::exception_ptr&>(ex));
}

template <typename T = void>
future<T> make_exception_future(const std::exception_ptr&& ex) noexcept {

    return make_exception_future<T>(std::exception_ptr(ex));
}


void engine_exit(std::exception_ptr eptr = {});

void report_failed_future(const std::exception_ptr& ex) noexcept;

void report_failed_future(const future_state_base& state) noexcept;
# 222 "/home/avi/scylla-maint/seastar/include/seastar/core/future.hh"
struct broken_promise : std::logic_error {
    broken_promise();
};







template <typename T = void>
future<T> current_exception_as_future() noexcept;


extern template
future<void> current_exception_as_future() noexcept;

namespace internal {
template <class T = void>
class promise_base_with_type;
class promise_base;

struct monostate {};

template <typename... T>
struct future_stored_type;

template <>
struct future_stored_type<> {
    using type = monostate;
};

template <typename T>
struct future_stored_type<T> {
    using type = std::conditional_t<std::is_void_v<T>, internal::monostate, T>;
};

template <typename... T>
using future_stored_type_t = typename future_stored_type<T...>::type;

template<typename T>
using future_tuple_type_t = std::conditional_t<std::is_same_v<T, monostate>, std::tuple<>, std::tuple<T>>;



template <typename T>
struct get0_return_type;

template <>
struct get0_return_type<internal::monostate> {
    using type = void;
    static type get0(internal::monostate) { }
};

template <typename T>
struct get0_return_type {
    using type = T;
    static T get0(T&& v) { return std::move(v); }
};

template<typename T>
using maybe_wrap_ref = std::conditional_t<std::is_reference_v<T>, std::reference_wrapper<std::remove_reference_t<T>>, T>;
# 292 "/home/avi/scylla-maint/seastar/include/seastar/core/future.hh"
template <typename T, bool is_trivial_class>
struct uninitialized_wrapper_base;

template <typename T>
struct uninitialized_wrapper_base<T, false> {
    using tuple_type = future_tuple_type_t<T>;
    union any {
        any() noexcept {}
        ~any() {}

        maybe_wrap_ref<T> value;
    } _v;

public:
    uninitialized_wrapper_base() noexcept = default;
    template<typename... U>
    std::enable_if_t<!std::is_same_v<std::tuple<std::remove_cv_t<U>...>, std::tuple<tuple_type>>, void>
    uninitialized_set(U&&... vs) {
        new (&_v.value) maybe_wrap_ref<T>(T(std::forward<U>(vs)...));
    }
    void uninitialized_set(tuple_type&& v) {
        uninitialized_set(std::move(std::get<0>(v)));
    }
    void uninitialized_set(const tuple_type& v) {
        uninitialized_set(std::get<0>(v));
    }
    maybe_wrap_ref<T>& uninitialized_get() {
        return _v.value;
    }
    const maybe_wrap_ref<T>& uninitialized_get() const {
        return _v.value;
    }
};

template <typename T> struct uninitialized_wrapper_base<T, true> : private T {
    using tuple_type = future_tuple_type_t<T>;
    uninitialized_wrapper_base() noexcept = default;
    template<typename... U>
    std::enable_if_t<!std::is_same_v<std::tuple<std::remove_cv_t<U>...>, std::tuple<tuple_type>>, void>
    uninitialized_set(U&&... vs) {
        new (this) T(std::forward<U>(vs)...);
    }
    void uninitialized_set(tuple_type&& v) {
        if constexpr (std::tuple_size_v<tuple_type> != 0) {
            uninitialized_set(std::move(std::get<0>(v)));
        }
    }
    void uninitialized_set(const tuple_type& v) {
        if constexpr (std::tuple_size_v<tuple_type> != 0) {
            uninitialized_set(std::get<0>(v));
        }
    }
    T& uninitialized_get() {
        return *this;
    }
    const T& uninitialized_get() const {
        return *this;
    }
};

template <typename T>
constexpr bool can_inherit =
        (std::is_trivially_destructible_v<T> && std::is_trivially_constructible_v<T> &&
                std::is_class_v<T> && !std::is_final_v<T>);



template <typename T>
struct uninitialized_wrapper
    : public uninitialized_wrapper_base<T, can_inherit<T>> {};

template <typename T>
struct is_trivially_move_constructible_and_destructible {
    static constexpr bool value = std::is_trivially_move_constructible_v<T> && std::is_trivially_destructible_v<T>;
};

template <bool... v>
struct all_true : std::false_type {};

template <>
struct all_true<> : std::true_type {};

template <bool... v>
struct all_true<true, v...> : public all_true<v...> {};

template<typename T>
struct is_tuple_effectively_trivially_move_constructible_and_destructible_helper;

template <typename... T>
struct is_tuple_effectively_trivially_move_constructible_and_destructible_helper<std::tuple<T...>> {
    static constexpr bool value = all_true<is_trivially_move_constructible_and_destructible<T>::value...>::value;
};

template <typename T>
static constexpr bool is_tuple_effectively_trivially_move_constructible_and_destructible =
    is_tuple_effectively_trivially_move_constructible_and_destructible_helper<T>::value;

}
# 419 "/home/avi/scylla-maint/seastar/include/seastar/core/future.hh"
struct future_state_base {
    static_assert(sizeof(std::exception_ptr) == sizeof(void*), "exception_ptr not a pointer");
    enum class state : uintptr_t {
         invalid = 0,
         future = 1,







         result_unavailable = 2,
         result = 3,
         exception_min = 4,
    };
    union any {
        any() noexcept { st = state::future; }
        any(state s) noexcept { st = s; }
        void set_exception(std::exception_ptr&& e) noexcept {
            new (&ex) std::exception_ptr(std::move(e));
            (static_cast <bool> (st >= state::exception_min) ? void (0) : __assert_fail ("st >= state::exception_min", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        }
        any(std::exception_ptr&& e) noexcept {
            set_exception(std::move(e));
        }

        bool valid() const noexcept { return st != state::invalid && st != state::result_unavailable; }
        bool available() const noexcept { return st == state::result || st >= state::exception_min; }
        bool failed() const noexcept { return __builtin_expect(st >= state::exception_min, false); }
        void check_failure() noexcept;
        ~any() noexcept { }
        std::exception_ptr take_exception() noexcept {
            std::exception_ptr ret(std::move(ex));
# 462 "/home/avi/scylla-maint/seastar/include/seastar/core/future.hh"
            st = state::invalid;
            return ret;
        }
        void move_it(any&& x) noexcept {
# 474 "/home/avi/scylla-maint/seastar/include/seastar/core/future.hh"
            memmove(static_cast<void*>(this), &x, sizeof(any));
            x.st = state::invalid;
# 484 "/home/avi/scylla-maint/seastar/include/seastar/core/future.hh"
        }
        any(any&& x) noexcept {
            move_it(std::move(x));
        }
        any& operator=(any&& x) noexcept {
            check_failure();



            move_it(std::move(x));
            return *this;
        }
        bool has_result() const noexcept {
            return st == state::result || st == state::result_unavailable;
        }
        state st;
        std::exception_ptr ex;
    } _u;

    future_state_base() noexcept = default;
    future_state_base(state st) noexcept : _u(st) { }
    future_state_base(std::exception_ptr&& ex) noexcept : _u(std::move(ex)) { }
    future_state_base(future_state_base&& x) noexcept : _u(std::move(x._u)) { }



protected:
    struct current_exception_future_marker {};
    future_state_base(current_exception_future_marker) noexcept;
    struct nested_exception_marker {};
    future_state_base(nested_exception_marker, future_state_base&& old) noexcept;
    future_state_base(nested_exception_marker, future_state_base&& n, future_state_base&& old) noexcept;
    ~future_state_base() noexcept = default;

    void rethrow_exception() &&;
    void rethrow_exception() const&;

public:

    bool valid() const noexcept { return _u.valid(); }
    bool available() const noexcept { return _u.available(); }
    bool failed() const noexcept { return _u.failed(); }

    void ignore() noexcept;

    void set_exception(std::exception_ptr&& ex) noexcept {
        (static_cast <bool> (_u.st == state::future) ? void (0) : __assert_fail ("_u.st == state::future", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        _u.set_exception(std::move(ex));
    }
    future_state_base& operator=(future_state_base&& x) noexcept = default;
    void set_exception(future_state_base&& state) noexcept {
        (static_cast <bool> (_u.st == state::future) ? void (0) : __assert_fail ("_u.st == state::future", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        *this = std::move(state);
    }
    std::exception_ptr get_exception() && noexcept {
        (static_cast <bool> (_u.st >= state::exception_min) ? void (0) : __assert_fail ("_u.st >= state::exception_min", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));

        return _u.take_exception();
    }
    const std::exception_ptr& get_exception() const& noexcept {
        (static_cast <bool> (_u.st >= state::exception_min) ? void (0) : __assert_fail ("_u.st >= state::exception_min", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        return _u.ex;
    }
    template <typename U>
    friend struct future_state;
    template <typename U>
    friend future<U> current_exception_as_future() noexcept;
    template <typename U>
    friend class future;
    template <typename T>
    friend struct futurize;
};

void report_failed_future(future_state_base::any&& state) noexcept;

inline void future_state_base::any::check_failure() noexcept {
    if (failed()) {
        report_failed_future(std::move(*this));
    }
}

struct ready_future_marker {};
struct exception_future_marker {};
struct future_for_get_promise_marker {};


template <typename T>
struct future_state : public future_state_base, private internal::uninitialized_wrapper<T> {
    static constexpr bool copy_noexcept = std::is_nothrow_copy_constructible_v<T>;
    static constexpr bool has_trivial_move_and_destroy = internal::is_trivially_move_constructible_and_destructible<T>::value;
    static_assert(std::is_nothrow_move_constructible_v<T>,
                  "Types must be no-throw move constructible");
    static_assert(std::is_nothrow_destructible_v<T>,
                  "Types must be no-throw destructible");
    future_state() noexcept = default;
    void move_it(future_state&& x) noexcept {
        if constexpr (has_trivial_move_and_destroy) {
#pragma GCC diagnostic push




#pragma GCC diagnostic ignored "-Wuninitialized"
            memmove(reinterpret_cast<char*>(&this->uninitialized_get()),
                   &x.uninitialized_get(),
                   internal::used_size<internal::maybe_wrap_ref<T>>::value);
#pragma GCC diagnostic pop
        } else if (_u.has_result()) {
            this->uninitialized_set(std::move(x.uninitialized_get()));
            std::destroy_at(&x.uninitialized_get());
        }
    }

    [[gnu::always_inline]]
    future_state(future_state&& x) noexcept : future_state_base(std::move(x)) {
        move_it(std::move(x));
    }

    void clear() noexcept {
        if (_u.has_result()) {
            std::destroy_at(&this->uninitialized_get());
        } else {
            _u.check_failure();
        }
    }
    __attribute__((always_inline))
    ~future_state() noexcept {
        clear();
    }
    future_state& operator=(future_state&& x) noexcept {
        clear();
        future_state_base::operator=(std::move(x));


        move_it(std::move(x));
        return *this;
    }
    template <typename... A>
    future_state(ready_future_marker, A&&... a) noexcept : future_state_base(state::result) {
      try {
        this->uninitialized_set(std::forward<A>(a)...);
      } catch (...) {
        new (this) future_state(current_exception_future_marker());
      }
    }
    template <typename... A>
    void set(A&&... a) noexcept {
        (static_cast <bool> (_u.st == state::future) ? void (0) : __assert_fail ("_u.st == state::future", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        new (this) future_state(ready_future_marker(), std::forward<A>(a)...);
    }
    future_state(exception_future_marker, std::exception_ptr&& ex) noexcept : future_state_base(std::move(ex)) { }
    future_state(exception_future_marker, future_state_base&& state) noexcept : future_state_base(std::move(state)) { }
    future_state(current_exception_future_marker m) noexcept : future_state_base(m) { }
    future_state(nested_exception_marker m, future_state_base&& old) noexcept : future_state_base(m, std::move(old)) { }
    future_state(nested_exception_marker m, future_state_base&& n, future_state_base&& old) noexcept : future_state_base(m, std::move(n), std::move(old)) { }
    T&& get_value() && noexcept {
        (static_cast <bool> (_u.st == state::result) ? void (0) : __assert_fail ("_u.st == state::result", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        return static_cast<T&&>(this->uninitialized_get());
    }
    T&& take_value() && noexcept {
        (static_cast <bool> (_u.st == state::result) ? void (0) : __assert_fail ("_u.st == state::result", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        _u.st = state::result_unavailable;
        return static_cast<T&&>(this->uninitialized_get());
    }
    template<typename U = T>
    const std::enable_if_t<std::is_copy_constructible_v<U>, U>& get_value() const& noexcept(copy_noexcept) {
        (static_cast <bool> (_u.st == state::result) ? void (0) : __assert_fail ("_u.st == state::result", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        return this->uninitialized_get();
    }
    T&& take() && {
        (static_cast <bool> (available()) ? void (0) : __assert_fail ("available()", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        if (_u.st >= state::exception_min) {
            std::move(*this).rethrow_exception();
        }
        _u.st = state::result_unavailable;
        return static_cast<T&&>(this->uninitialized_get());
    }
    T&& get() && {
        (static_cast <bool> (available()) ? void (0) : __assert_fail ("available()", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        if (_u.st >= state::exception_min) {
            std::move(*this).rethrow_exception();
        }
        return static_cast<T&&>(this->uninitialized_get());
    }
    const T& get() const& {
        (static_cast <bool> (available()) ? void (0) : __assert_fail ("available()", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        if (_u.st >= state::exception_min) {
            rethrow_exception();
        }
        return this->uninitialized_get();
    }
    using get0_return_type = typename internal::get0_return_type<T>::type;
    static get0_return_type get0(T&& x) {
        return internal::get0_return_type<T>::get0(std::move(x));
    }

    get0_return_type get0() {
        return std::move(*this).get();
    }
};

template <typename T = void>
class continuation_base : public task {
protected:
    using future_state = seastar::future_state<internal::future_stored_type_t<T>>;
    future_state _state;
    using future_type = future<T>;
    using promise_type = promise<T>;
public:
    continuation_base() noexcept = default;
    void set_state(future_state&& state) noexcept {
        _state = std::move(state);
    }




    virtual task* waiting_task() noexcept override { return nullptr; }
    friend class internal::promise_base_with_type<T>;
    friend class promise<T>;
    friend class future<T>;
};


template <typename Future>
struct continuation_base_from_future;

template <typename... T>
struct continuation_base_from_future<future<T...>> {
    using type = continuation_base<T...>;
};

template <typename Future>
using continuation_base_from_future_t = typename continuation_base_from_future<Future>::type;

template <typename Promise, typename T = void>
class continuation_base_with_promise : public continuation_base<T> {
    friend class internal::promise_base_with_type<T>;
protected:
    continuation_base_with_promise(Promise&& pr) noexcept : _pr(std::move(pr)) {
        task::make_backtrace();
    }
    virtual task* waiting_task() noexcept override;
    Promise _pr;
};

template <typename Promise, typename Func, typename Wrapper, typename T = void>
struct continuation final : continuation_base_with_promise<Promise, T> {
# 742 "/home/avi/scylla-maint/seastar/include/seastar/core/future.hh"
    continuation(Promise&& pr, Func&& func, Wrapper&& wrapper) noexcept
        : continuation_base_with_promise<Promise, T>(std::move(pr))
        , _func(std::move(func))
        , _wrapper(std::move(wrapper)) {}
    virtual void run_and_dispose() noexcept override {
        try {
            _wrapper(std::move(this->_pr), _func, std::move(this->_state));
        } catch (...) {
            this->_pr.set_to_current_exception();
        }
        delete this;
    }
    Func _func;
    [[no_unique_address]] Wrapper _wrapper;
};

namespace internal {

template <typename T = void>
future<T> make_exception_future(future_state_base&& state) noexcept;

template <typename T = void>
void set_callback(future<T>&& fut, continuation_base<T>* callback) noexcept;

class future_base;

class promise_base {
protected:
    enum class urgent { no, yes };
    future_base* _future = nullptr;




    future_state_base* _state;

    task* _task = nullptr;
# 788 "/home/avi/scylla-maint/seastar/include/seastar/core/future.hh"
    void set_task(task* task) noexcept {
        _task = task;
    }
    void assert_task_shard() const noexcept { }


    promise_base(const promise_base&) = delete;
    promise_base(future_state_base* state) noexcept : _state(state) {}
    promise_base(future_base* future, future_state_base* state) noexcept;
    void move_it(promise_base&& x) noexcept;
    promise_base(promise_base&& x) noexcept;

    void clear() noexcept;



    ~promise_base() noexcept {
        clear();
    }

    void operator=(const promise_base&) = delete;
    promise_base& operator=(promise_base&& x) noexcept;

    template<urgent Urgent>
    void make_ready() noexcept;

    template<typename T>
    void set_exception_impl(T&& val) noexcept {
        if (_state) {
            _state->set_exception(std::move(val));
            make_ready<urgent::no>();
        } else {







            report_failed_future(val);
        }
    }

    void set_exception(future_state_base&& state) noexcept {
        set_exception_impl(std::move(state));
    }

    void set_exception(std::exception_ptr&& ex) noexcept {
        set_exception_impl(std::move(ex));
    }

    void set_exception(const std::exception_ptr& ex) noexcept {
        set_exception(std::exception_ptr(ex));
    }

    template<typename Exception>
    std::enable_if_t<!std::is_same_v<std::remove_reference_t<Exception>, std::exception_ptr>, void> set_exception(Exception&& e) noexcept {
        set_exception(std::make_exception_ptr(std::forward<Exception>(e)));
    }

    friend class future_base;
    template <typename U> friend class seastar::future;

public:




    void set_to_current_exception() noexcept;


    task* waiting_task() const noexcept { return _task; }
};







template <typename T>
class promise_base_with_type : protected internal::promise_base {
protected:
    using future_state = seastar::future_state<future_stored_type_t<T>>;
    future_state* get_state() noexcept {
        return static_cast<future_state*>(_state);
    }
    static constexpr bool copy_noexcept = future_state::copy_noexcept;
public:
    promise_base_with_type(future_state_base* state) noexcept : promise_base(state) { }
    promise_base_with_type(future<T>* future) noexcept : promise_base(future, &future->_state) { }
    promise_base_with_type(promise_base_with_type&& x) noexcept = default;
    promise_base_with_type(const promise_base_with_type&) = delete;
    promise_base_with_type& operator=(promise_base_with_type&& x) noexcept = default;
    void operator=(const promise_base_with_type&) = delete;

    void set_urgent_state(future_state&& state) noexcept {
        auto* ptr = get_state();


        if (ptr) {



            (static_cast <bool> (ptr->_u.st == future_state_base::state::future) ? void (0) : __assert_fail ("ptr->_u.st == future_state_base::state::future", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
            new (ptr) future_state(std::move(state));
            make_ready<urgent::yes>();
        }
    }

    template <typename... A>
    void set_value(A&&... a) noexcept {
        if (auto *s = get_state()) {
            s->set(std::forward<A>(a)...);
            make_ready<urgent::no>();
        }
    }





    void set_to_current_exception() noexcept {
        internal::promise_base::set_to_current_exception();
    }


    using internal::promise_base::waiting_task;

private:

    template <typename U>
    friend class seastar::future;

    friend future_state;
};
}
# 933 "/home/avi/scylla-maint/seastar/include/seastar/core/future.hh"
template <typename T>
class promise : private internal::promise_base_with_type<T> {
    using future_state = typename internal::promise_base_with_type<T>::future_state;
    future_state _local_state;

public:



    promise() noexcept : internal::promise_base_with_type<T>(&_local_state) {}


    void move_it(promise&& x) noexcept;
    promise(promise&& x) noexcept : internal::promise_base_with_type<T>(std::move(x)) {
        move_it(std::move(x));
    }
    promise(const promise&) = delete;
    promise& operator=(promise&& x) noexcept {
        internal::promise_base_with_type<T>::operator=(std::move(x));


        move_it(std::move(x));
        return *this;
    }
    void operator=(const promise&) = delete;





    void set_to_current_exception() noexcept {
        internal::promise_base::set_to_current_exception();
    }


    using internal::promise_base::waiting_task;







    future<T> get_future() noexcept;
# 989 "/home/avi/scylla-maint/seastar/include/seastar/core/future.hh"
    template <typename... A>
    void set_value(A&&... a) noexcept {
        internal::promise_base_with_type<T>::set_value(std::forward<A>(a)...);
    }





    void set_exception(std::exception_ptr&& ex) noexcept {
        internal::promise_base::set_exception(std::move(ex));
    }

    void set_exception(const std::exception_ptr& ex) noexcept {
        internal::promise_base::set_exception(ex);
    }





    template<typename Exception>
    std::enable_if_t<!std::is_same_v<std::remove_reference_t<Exception>, std::exception_ptr>, void> set_exception(Exception&& e) noexcept {
        internal::promise_base::set_exception(std::forward<Exception>(e));
    }

    using internal::promise_base_with_type<T>::set_urgent_state;

    template <typename U>
    friend class future;
};
# 1032 "/home/avi/scylla-maint/seastar/include/seastar/core/future.hh"
template <typename... T> struct is_future : std::false_type {};



template <typename... T> struct is_future<future<T...>> : std::true_type {};
# 1045 "/home/avi/scylla-maint/seastar/include/seastar/core/future.hh"
template <typename T>
struct futurize;

template <typename T>
concept Future = is_future<T>::value;

template <typename Func, typename... T>
concept CanInvoke = std::invocable<Func, T...>;


template <typename Func, typename... T>
concept CanApply = CanInvoke<Func, T...>;

template <typename Func, typename... T>
concept CanApplyTuple
    = sizeof...(T) == 1
        && requires (Func func, std::tuple<T...> wrapped_val) {
        { std::apply(func, std::get<0>(std::move(wrapped_val))) };
    };


template <typename Func, typename Return, typename... T>
concept InvokeReturns = requires (Func f, T... args) {
    { f(std::forward<T>(args)...) } -> std::same_as<Return>;
};


template <typename Func, typename Return, typename... T>
concept ApplyReturns = InvokeReturns<Func, Return, T...>;

template <typename Func, typename... T>
concept InvokeReturnsAnyFuture = Future<std::invoke_result_t<Func, T...>>;


template <typename Func, typename... T>
concept ApplyReturnsAnyFuture = InvokeReturnsAnyFuture<Func, T...>;




template <typename T>
using futurize_t = typename futurize<T>::type;



template<typename Func, typename... Args>
auto futurize_invoke(Func&& func, Args&&... args) noexcept;

template<typename Func, typename... Args>
auto futurize_apply(Func&& func, std::tuple<Args...>&& args) noexcept;



namespace internal {
class future_base {
protected:
    promise_base* _promise;
    future_base() noexcept : _promise(nullptr) {}
    future_base(promise_base* promise, future_state_base* state) noexcept : _promise(promise) {
        _promise->_future = this;
        _promise->_state = state;
    }

    void move_it(future_base&& x, future_state_base* state) noexcept {
        _promise = x._promise;
        if (auto* p = _promise) {
            x.detach_promise();
            p->_future = this;
            p->_state = state;
        }
    }

    future_base(future_base&& x, future_state_base* state) noexcept {
        move_it(std::move(x), state);
    }

    void clear() noexcept {
        if (_promise) {
            detach_promise();
        }
    }

    ~future_base() noexcept {
        clear();
    }

    promise_base* detach_promise() noexcept {
        _promise->_state = nullptr;
        _promise->_future = nullptr;
        return std::exchange(_promise, nullptr);
    }

    void schedule(task* tws, future_state_base* state) noexcept {
        promise_base* p = detach_promise();
        p->_state = state;
        p->set_task(tws);
    }

    void do_wait() noexcept;

    void set_coroutine(task& coroutine) noexcept;

    friend class promise_base;
};

template <typename Func, typename... T>
struct future_result {
    using type = std::invoke_result_t<Func, T...>;
    using future_type = futurize_t<type>;
    using func_type = future_type (T&&...);
};

template <typename Func>
struct future_result<Func, void> {
    using type = std::invoke_result_t<Func>;
    using future_type = futurize_t<type>;
    using func_type = future_type ();
};

template <typename Func, typename T>
using future_result_t = typename future_result<Func, T>::type;

template <typename Func, typename T>
auto future_invoke(Func&& func, T&& v) {
    if constexpr (std::is_same_v<T, monostate>) {
        return std::invoke(std::forward<Func>(func));
    } else {
        return std::invoke(std::forward<Func>(func), std::forward<T>(v));
    }
}

template <typename Func, typename... T>
struct result_of_apply {

};

template <typename Func, typename... T>
struct result_of_apply<Func, std::tuple<T...>> : std::invoke_result<Func, T...> {

};

template <typename Func, typename... T>
using result_of_apply_t = typename result_of_apply<Func, T...>::type;

}

template <typename Promise, typename T>
task* continuation_base_with_promise<Promise, T>::waiting_task() noexcept {
    return _pr.waiting_task();
}
# 1239 "/home/avi/scylla-maint/seastar/include/seastar/core/future.hh"
template <typename T>
class [[nodiscard]] future : private internal::future_base {
    using future_state = seastar::future_state<internal::future_stored_type_t<T>>;
    future_state _state;
    static constexpr bool copy_noexcept = future_state::copy_noexcept;

private:






    future(future_for_get_promise_marker) noexcept { }

    future(promise<T>* pr) noexcept : future_base(pr, &_state), _state(std::move(pr->_local_state)) { }
    template <typename... A>
    future(ready_future_marker m, A&&... a) noexcept : _state(m, std::forward<A>(a)...) { }
    future(future_state_base::current_exception_future_marker m) noexcept : _state(m) {}
    future(future_state_base::nested_exception_marker m, future_state_base&& old) noexcept : _state(m, std::move(old)) {}
    future(future_state_base::nested_exception_marker m, future_state_base&& n, future_state_base&& old) noexcept : _state(m, std::move(n), std::move(old)) {}
    future(exception_future_marker m, std::exception_ptr&& ex) noexcept : _state(m, std::move(ex)) { }
    future(exception_future_marker m, future_state_base&& state) noexcept : _state(m, std::move(state)) { }
    [[gnu::always_inline]]
    explicit future(future_state&& state) noexcept
            : _state(std::move(state)) {
    }
    internal::promise_base_with_type<T> get_promise() noexcept {
        (static_cast <bool> (!_promise) ? void (0) : __assert_fail ("!_promise", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        return internal::promise_base_with_type<T>(this);
    }
    internal::promise_base_with_type<T>* detach_promise() noexcept {
        return static_cast<internal::promise_base_with_type<T>*>(future_base::detach_promise());
    }
    void schedule(continuation_base<T>* tws) noexcept {
        future_base::schedule(tws, &tws->_state);
    }
    template <typename Pr, typename Func, typename Wrapper>
    void schedule(Pr&& pr, Func&& func, Wrapper&& wrapper) noexcept {




        memory::scoped_critical_alloc_section _;
        auto tws = new continuation<Pr, Func, Wrapper, T>(std::move(pr), std::move(func), std::move(wrapper));
# 1293 "/home/avi/scylla-maint/seastar/include/seastar/core/future.hh"
        schedule(tws);
        _state._u.st = future_state_base::state::invalid;
    }

    [[gnu::always_inline]]
    future_state&& get_available_state_ref() noexcept {
        if (_promise) {
            detach_promise();
        }
        return std::move(_state);
    }

    future<T> rethrow_with_nested(future_state_base&& n) noexcept {
        return future<T>(future_state_base::nested_exception_marker(), std::move(n), std::move(_state));
    }

    future<T> rethrow_with_nested() noexcept {
        return future<T>(future_state_base::nested_exception_marker(), std::move(_state));
    }

    template<typename... U>
    friend class shared_future;
public:

    using value_type = internal::future_stored_type_t<T>;
    using tuple_type = internal::future_tuple_type_t<value_type>;

    using promise_type = promise<T>;

    [[gnu::always_inline]]
    future(future&& x) noexcept : future_base(std::move(x), &_state), _state(std::move(x._state)) { }
    future(const future&) = delete;
    future& operator=(future&& x) noexcept {
        clear();
        move_it(std::move(x), &_state);
        _state = std::move(x._state);
        return *this;
    }
    void operator=(const future&) = delete;
# 1341 "/home/avi/scylla-maint/seastar/include/seastar/core/future.hh"
    [[gnu::always_inline]]
    value_type&& get() {
        wait();
        return get_available_state_ref().take();
    }

    [[gnu::always_inline]]
    std::exception_ptr get_exception() noexcept {
        return get_available_state_ref().get_exception();
    }
# 1372 "/home/avi/scylla-maint/seastar/include/seastar/core/future.hh"
    using get0_return_type = typename future_state::get0_return_type;
    [[deprecated("Use get() instead")]]
    get0_return_type get0() {
        return (get0_return_type)get();
    }






    void wait() noexcept {
        if (_state.available()) {
            return;
        }
        do_wait();
    }




    [[gnu::always_inline]]
    bool available() const noexcept {
        return _state.available();
    }




    [[gnu::always_inline]]
    bool failed() const noexcept {
        return _state.failed();
    }
# 1421 "/home/avi/scylla-maint/seastar/include/seastar/core/future.hh"
    template <typename Func, typename Result = typename internal::future_result<Func, T>::future_type>
    requires std::invocable<Func, T>
                 || (std::same_as<void, T> && std::invocable<Func>)
    Result
    then(Func&& func) noexcept {

        return then_impl(std::move(func));
# 1439 "/home/avi/scylla-maint/seastar/include/seastar/core/future.hh"
    }
# 1460 "/home/avi/scylla-maint/seastar/include/seastar/core/future.hh"
    template <typename Func, typename Result = futurize_t<internal::result_of_apply_t<Func, T>>>
    requires ::seastar::CanApplyTuple<Func, T>
    Result
    then_unpack(Func&& func) noexcept {
        return then([func = std::forward<Func>(func)] (T&& tuple) mutable {

            return std::apply(func, std::move(tuple));
        });
    }

private:


    template <typename Func, typename Result>
    Result then_impl_nrvo(Func&& func) noexcept {
        using futurator = futurize<internal::future_result_t<Func, T>>;
        typename futurator::type fut(future_for_get_promise_marker{});
        using pr_type = decltype(fut.get_promise());
        schedule(fut.get_promise(), std::move(func), [](pr_type&& pr, Func& func, future_state&& state) {
            if (state.failed()) {
                pr.set_exception(static_cast<future_state_base&&>(std::move(state)));
            } else {
                futurator::satisfy_with_result_of(std::move(pr), [&func, &state] {


                    (void)state;
                    return internal::future_invoke(func, std::move(state).get_value());
                });
            }
        });
        return fut;
    }

    template <typename Func, typename Result = futurize_t<internal::future_result_t<Func, T>>>
    Result
    then_impl(Func&& func) noexcept {

        using futurator = futurize<internal::future_result_t<Func, T>>;
        if (failed()) {
            return futurator::make_exception_future(static_cast<future_state_base&&>(get_available_state_ref()));
        } else if (available()) {
            return futurator::invoke(std::forward<Func>(func), get_available_state_ref().take_value());
        }

        return then_impl_nrvo<Func, Result>(std::forward<Func>(func));
    }

public:
# 1523 "/home/avi/scylla-maint/seastar/include/seastar/core/future.hh"
    template <std::invocable<future> Func, typename FuncResult = std::invoke_result_t<Func, future>>
    futurize_t<FuncResult>
    then_wrapped(Func&& func) & noexcept {
        return then_wrapped_maybe_erase<false, FuncResult>(std::forward<Func>(func));
    }

    template <std::invocable<future&&> Func, typename FuncResult = std::invoke_result_t<Func, future&&>>
    futurize_t<FuncResult>
    then_wrapped(Func&& func) && noexcept {
        return then_wrapped_maybe_erase<true, FuncResult>(std::forward<Func>(func));
    }

private:

    template <bool AsSelf, typename FuncResult, typename Func>
    futurize_t<FuncResult>
    then_wrapped_maybe_erase(Func&& func) noexcept {

        return then_wrapped_common<AsSelf, FuncResult>(std::forward<Func>(func));
# 1554 "/home/avi/scylla-maint/seastar/include/seastar/core/future.hh"
    }


    template <typename FuncResult, typename Func>
    futurize_t<FuncResult>
    then_wrapped_nrvo(Func&& func) noexcept {
        using futurator = futurize<FuncResult>;
        typename futurator::type fut(future_for_get_promise_marker{});
        using pr_type = decltype(fut.get_promise());
        schedule(fut.get_promise(), std::move(func), [](pr_type&& pr, Func& func, future_state&& state) {
            futurator::satisfy_with_result_of(std::move(pr), [&func, &state] {
                return func(future(std::move(state)));
            });
        });
        return fut;
    }


    template <bool AsSelf, typename FuncResult, typename Func>
    futurize_t<FuncResult>
    then_wrapped_common(Func&& func) noexcept {

        using futurator = futurize<FuncResult>;
        if (available()) {
            if constexpr (AsSelf) {
                if (_promise) {
                    detach_promise();
                }
                return futurator::invoke(std::forward<Func>(func), std::move(*this));
            } else {
                return futurator::invoke(std::forward<Func>(func), future(get_available_state_ref()));
            }
        }

        return then_wrapped_nrvo<FuncResult, Func>(std::forward<Func>(func));
    }

    void forward_to(internal::promise_base_with_type<T>&& pr) noexcept {
        if (_state.available()) {
            pr.set_urgent_state(std::move(_state));
        } else {
            *detach_promise() = std::move(pr);
        }
    }

public:
# 1610 "/home/avi/scylla-maint/seastar/include/seastar/core/future.hh"
    void forward_to(promise<T>&& pr) noexcept {
        if (_state.available()) {
            pr.set_urgent_state(std::move(_state));
        } else if (&pr._local_state != pr._state) {




            *detach_promise() = std::move(pr);
        }
    }
# 1639 "/home/avi/scylla-maint/seastar/include/seastar/core/future.hh"
    template <std::invocable Func>
    future<T> finally(Func&& func) noexcept {
        return then_wrapped(finally_body<Func, is_future<std::invoke_result_t<Func>>::value>(std::forward<Func>(func)));
    }


    template <typename Func, bool FuncReturnsFuture>
    struct finally_body;

    template <typename Func>
    struct finally_body<Func, true> {
        Func _func;

        finally_body(Func&& func) noexcept : _func(std::forward<Func>(func))
        { }

        future<T> operator()(future<T>&& result) noexcept {
            return futurize_invoke(_func).then_wrapped([result = std::move(result)](auto&& f_res) mutable {
                if (!f_res.failed()) {
                    return std::move(result);
                } else {
                    return result.rethrow_with_nested(std::move(f_res._state));
                }
            });
        }
    };

    template <typename Func>
    struct finally_body<Func, false> {
        Func _func;

        finally_body(Func&& func) noexcept : _func(std::forward<Func>(func))
        { }

        future<T> operator()(future<T>&& result) noexcept {
            try {
                _func();
                return std::move(result);
            } catch (...) {
                return result.rethrow_with_nested();
            }
        };
    };





    future<> or_terminate() noexcept {
        return then_wrapped([] (auto&& f) {
            try {
                f.get();
            } catch (...) {
                engine_exit(std::current_exception());
            }
        });
    }





    future<> discard_result() noexcept {


        return then([] (auto&&...) {});
    }
# 1720 "/home/avi/scylla-maint/seastar/include/seastar/core/future.hh"
    template <typename Func>
    requires std::is_invocable_r_v<future<T> ,Func, std::exception_ptr>
                    || (std::tuple_size_v<tuple_type> == 0 && std::is_invocable_r_v<void, Func, std::exception_ptr>)
                    || (std::tuple_size_v<tuple_type> == 1 && std::is_invocable_r_v<T, Func, std::exception_ptr>)
                    || (std::tuple_size_v<tuple_type> > 1 && std::is_invocable_r_v<tuple_type ,Func, std::exception_ptr>)
    future<T> handle_exception(Func&& func) noexcept {
        return then_wrapped([func = std::forward<Func>(func)]
                             (auto&& fut) mutable -> future<T> {
            if (!fut.failed()) {
                return make_ready_future<T>(fut.get());
            } else {
                return futurize_invoke(func, fut.get_exception());
            }
        });
    }
# 1746 "/home/avi/scylla-maint/seastar/include/seastar/core/future.hh"
    template <typename Func>
    future<T> handle_exception_type(Func&& func) noexcept {
        using trait = function_traits<Func>;
        static_assert(trait::arity == 1, "func can take only one parameter");
        using ex_type = typename trait::template arg<0>::type;
        return then_wrapped([func = std::forward<Func>(func)]
                             (auto&& fut) mutable -> future<T> {
            try {
                return make_ready_future<T>(fut.get());
            } catch(ex_type& ex) {
                return futurize_invoke(func, ex);
            }
        });
    }






    void ignore_ready_future() noexcept {
        _state.ignore();
    }

    using future_base::set_coroutine;

private:
    void set_task(task& t) noexcept {
        (static_cast <bool> (_promise) ? void (0) : __assert_fail ("_promise", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        _promise->set_task(&t);
    }

    void set_callback(continuation_base<T>* callback) noexcept {
        if (_state.available()) {
            callback->set_state(get_available_state_ref());
            ::seastar::schedule(callback);
        } else {
            (static_cast <bool> (_promise) ? void (0) : __assert_fail ("_promise", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
            schedule(callback);
        }

    }


    template <typename U>
    friend class future;
    template <typename U>
    friend class promise;
    template <typename U>
    friend struct futurize;
    template <typename U>
    friend class internal::promise_base_with_type;
    template <typename U, typename... A>
    friend future<U> make_ready_future(A&&... value) noexcept;
    template <typename U>
    friend future<U> make_exception_future(std::exception_ptr&& ex) noexcept;
    template <typename U, typename Exception>
    friend future<U> make_exception_future(Exception&& ex) noexcept;
    template <typename U>
    friend future<U> internal::make_exception_future(future_state_base&& state) noexcept;
    template <typename U>
    friend future<U> current_exception_as_future() noexcept;
    template <typename U>
    friend void internal::set_callback(future<U>&&, continuation_base<U>*) noexcept;

};


namespace internal {
template <typename T>
struct futurize_base {

    using type = future<T>;

    using promise_type = promise<T>;
    using promise_base_with_type = internal::promise_base_with_type<T>;


    static inline type convert(T&& value) { return make_ready_future<T>(std::move(value)); }
    static inline type convert(type&& value) { return std::move(value); }


    template <typename Arg>
    static inline type make_exception_future(Arg&& arg) noexcept;
};

template <>
struct futurize_base<void> {
    using type = future<>;
    using promise_type = promise<>;
    using promise_base_with_type = internal::promise_base_with_type<>;

    static inline type convert(type&& value) {
        return std::move(value);
    }
    template <typename Arg>
    static inline type make_exception_future(Arg&& arg) noexcept;
};

template <typename T>
struct futurize_base<future<T>> : public futurize_base<T> {};

template <>
struct futurize_base<future<>> : public futurize_base<void> {};
}

template <typename T>
struct futurize : public internal::futurize_base<T> {
    using base = internal::futurize_base<T>;
    using type = typename base::type;
    using promise_type = typename base::promise_type;
    using promise_base_with_type = typename base::promise_base_with_type;

    using value_type = typename type::value_type;
    using tuple_type = typename type::tuple_type;
    using base::convert;
    using base::make_exception_future;



    template<typename Func, typename... FuncArgs>
    static inline type apply(Func&& func, std::tuple<FuncArgs...>&& args) noexcept;



    template<typename Func, typename... FuncArgs>
    static inline type invoke(Func&& func, FuncArgs&&... args) noexcept;

    template<typename Func>
    static inline type invoke(Func&& func, internal::monostate) noexcept {
        return invoke(std::forward<Func>(func));
    }


    template<typename Func, typename... FuncArgs>
    [[deprecated("Use invoke for varargs")]]
    static inline type apply(Func&& func, FuncArgs&&... args) noexcept {
        return invoke(std::forward<Func>(func), std::forward<FuncArgs>(args)...);
    }

    static type current_exception_as_future() noexcept {
        return type(future_state_base::current_exception_future_marker());
    }


    static type from_tuple(tuple_type&& value) {
        return type(ready_future_marker(), std::move(value));
    }

    static type from_tuple(const tuple_type& value) {
        return type(ready_future_marker(), value);
    }


    static type from_tuple(value_type&& value) {
        return type(ready_future_marker(), std::move(value));
    }

    static type from_tuple(const value_type& value) {
        return type(ready_future_marker(), value);
    }
private:



    template<std::invocable Func>
    static void satisfy_with_result_of(promise_base_with_type&&, Func&& func);

    template <typename U>
    friend class future;
};

inline internal::promise_base::promise_base(future_base* future, future_state_base* state) noexcept
    : _future(future), _state(state) {
    _future->_promise = this;
}

template <typename T>
inline
future<T>
promise<T>::get_future() noexcept {
    (static_cast <bool> (!this->_future && this->_state && !this->_task) ? void (0) : __assert_fail ("!this->_future && this->_state && !this->_task", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
    return future<T>(this);
}

template <typename T>
inline
void promise<T>::move_it(promise&& x) noexcept {
    if (this->_state == &x._local_state) {
        this->_state = &_local_state;
        new (&_local_state) future_state(std::move(x._local_state));
    }
}


template <typename T, typename... A>
inline
future<T> make_ready_future(A&&... value) noexcept {
    return future<T>(ready_future_marker(), std::forward<A>(value)...);
}

template <typename T>
inline
future<T> make_exception_future(std::exception_ptr&& ex) noexcept {
    return future<T>(exception_future_marker(), std::move(ex));
}


template <typename T>
inline
future<T> internal::make_exception_future(future_state_base&& state) noexcept {
    return future<T>(exception_future_marker(), std::move(state));
}


template <typename T>
future<T> current_exception_as_future() noexcept {
    return future<T>(future_state_base::current_exception_future_marker());
}

void log_exception_trace() noexcept;







template <typename T, typename Exception>
inline
future<T> make_exception_future(Exception&& ex) noexcept {
    log_exception_trace();
    return make_exception_future<T>(std::make_exception_ptr(std::forward<Exception>(ex)));
}

template <typename T, typename Exception>
future<T> make_exception_future_with_backtrace(Exception&& ex) noexcept {
    return make_exception_future<T>(make_backtraced_exception_ptr<Exception>(std::forward<Exception>(ex)));
}






template<typename T>
template<typename Func, typename... FuncArgs>
typename futurize<T>::type futurize<T>::apply(Func&& func, std::tuple<FuncArgs...>&& args) noexcept {
    try {
        using ret_t = decltype(std::apply(std::forward<Func>(func), std::move(args)));
        if constexpr (std::is_void_v<ret_t>) {
            std::apply(std::forward<Func>(func), std::move(args));
            return make_ready_future<>();
        } else if constexpr (is_future<ret_t>::value){
            return std::apply(std::forward<Func>(func), std::move(args));
        } else {
            return convert(std::apply(std::forward<Func>(func), std::move(args)));
        }
    } catch (...) {
        return current_exception_as_future();
    }
}

template<typename T>
template<std::invocable Func>
void futurize<T>::satisfy_with_result_of(promise_base_with_type&& pr, Func&& func) {
    using ret_t = decltype(func());
    if constexpr (std::is_void_v<ret_t>) {
        func();
        pr.set_value();
    } else if constexpr (is_future<ret_t>::value) {
        func().forward_to(std::move(pr));
    } else {
        pr.set_value(func());
    }
}

template<typename T>
template<typename Func, typename... FuncArgs>
typename futurize<T>::type futurize<T>::invoke(Func&& func, FuncArgs&&... args) noexcept {
    try {
        using ret_t = decltype(func(std::forward<FuncArgs>(args)...));
        if constexpr (std::is_void_v<ret_t>) {
            func(std::forward<FuncArgs>(args)...);
            return make_ready_future<>();
        } else if constexpr (is_future<ret_t>::value) {
            return func(std::forward<FuncArgs>(args)...);
        } else {
            return convert(func(std::forward<FuncArgs>(args)...));
        }
    } catch (...) {
        return current_exception_as_future();
    }
}

template <typename T>
template <typename Arg>
inline
future<T>
internal::futurize_base<T>::make_exception_future(Arg&& arg) noexcept {
    using ::seastar::make_exception_future;
    using ::seastar::internal::make_exception_future;
    return make_exception_future<T>(std::forward<Arg>(arg));
}

template <typename Arg>
inline
future<>
internal::futurize_base<void>::make_exception_future(Arg&& arg) noexcept {
    using ::seastar::make_exception_future;
    using ::seastar::internal::make_exception_future;
    return make_exception_future<>(std::forward<Arg>(arg));
}

template<typename Func, typename... Args>
auto futurize_invoke(Func&& func, Args&&... args) noexcept {
    using futurator = futurize<std::invoke_result_t<Func, Args&&...>>;
    return futurator::invoke(std::forward<Func>(func), std::forward<Args>(args)...);
}

template<typename Func, typename... Args>
[[deprecated("Use futurize_invoke for varargs")]]
auto futurize_apply(Func&& func, Args&&... args) noexcept {
    return futurize_invoke(std::forward<Func>(func), std::forward<Args>(args)...);
}

template<typename Func, typename... Args>
auto futurize_apply(Func&& func, std::tuple<Args...>&& args) noexcept {
    using futurator = futurize<std::invoke_result_t<Func, Args&&...>>;
    return futurator::apply(std::forward<Func>(func), std::move(args));
}

namespace internal {

template <typename T>
inline
void set_callback(future<T>&& fut, continuation_base<T>* callback) noexcept {
    return std::move(fut).set_callback(callback);
}

}




}
# 30 "/home/avi/scylla-maint/seastar/include/seastar/rpc/rpc.hh" 2
# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/seastar.hh" 1
# 52 "/home/avi/scylla-maint/seastar/include/seastar/core/seastar.hh"
# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/file-types.hh" 1
# 25 "/home/avi/scylla-maint/seastar/include/seastar/core/file-types.hh"
# 1 "/usr/include/fcntl.h" 1 3 4
# 28 "/usr/include/fcntl.h" 3 4
extern "C" {






# 1 "/usr/include/bits/fcntl.h" 1 3 4
# 35 "/usr/include/bits/fcntl.h" 3 4
struct flock
  {
    short int l_type;
    short int l_whence;

    __off_t l_start;
    __off_t l_len;




    __pid_t l_pid;
  };


struct flock64
  {
    short int l_type;
    short int l_whence;
    __off64_t l_start;
    __off64_t l_len;
    __pid_t l_pid;
  };



# 1 "/usr/include/bits/fcntl-linux.h" 1 3 4
# 38 "/usr/include/bits/fcntl-linux.h" 3 4
# 1 "/usr/include/bits/types/struct_iovec.h" 1 3 4
# 23 "/usr/include/bits/types/struct_iovec.h" 3 4
# 1 "/usr/bin/../lib/clang/18/include/stddef.h" 1 3 4
# 77 "/usr/bin/../lib/clang/18/include/stddef.h" 3 4
# 1 "/usr/bin/../lib/clang/18/include/__stddef_size_t.h" 1 3 4
# 18 "/usr/bin/../lib/clang/18/include/__stddef_size_t.h" 3 4
typedef long unsigned int size_t;
# 78 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3 4
# 24 "/usr/include/bits/types/struct_iovec.h" 2 3 4


struct iovec
  {
    void *iov_base;
    size_t iov_len;
  };
# 39 "/usr/include/bits/fcntl-linux.h" 2 3 4
# 265 "/usr/include/bits/fcntl-linux.h" 3 4
enum __pid_type
  {
    F_OWNER_TID = 0,
    F_OWNER_PID,
    F_OWNER_PGRP,
    F_OWNER_GID = F_OWNER_PGRP
  };


struct f_owner_ex
  {
    enum __pid_type type;
    __pid_t pid;
  };
# 355 "/usr/include/bits/fcntl-linux.h" 3 4
# 1 "/usr/include/linux/falloc.h" 1 3 4
# 356 "/usr/include/bits/fcntl-linux.h" 2 3 4



struct file_handle
{
  unsigned int handle_bytes;
  int handle_type;

  unsigned char f_handle[0];
};
# 382 "/usr/include/bits/fcntl-linux.h" 3 4
extern "C" {




extern __ssize_t readahead (int __fd, __off64_t __offset, size_t __count)
    noexcept (true);






extern int sync_file_range (int __fd, __off64_t __offset, __off64_t __count,
       unsigned int __flags);






extern __ssize_t vmsplice (int __fdout, const struct iovec *__iov,
      size_t __count, unsigned int __flags);





extern __ssize_t splice (int __fdin, __off64_t *__offin, int __fdout,
    __off64_t *__offout, size_t __len,
    unsigned int __flags);





extern __ssize_t tee (int __fdin, int __fdout, size_t __len,
        unsigned int __flags);






extern int fallocate (int __fd, int __mode, __off_t __offset, __off_t __len);
# 437 "/usr/include/bits/fcntl-linux.h" 3 4
extern int fallocate64 (int __fd, int __mode, __off64_t __offset,
   __off64_t __len);




extern int name_to_handle_at (int __dfd, const char *__name,
         struct file_handle *__handle, int *__mnt_id,
         int __flags) noexcept (true);





extern int open_by_handle_at (int __mountdirfd, struct file_handle *__handle,
         int __flags);



}
# 62 "/usr/include/bits/fcntl.h" 2 3 4
# 36 "/usr/include/fcntl.h" 2 3 4
# 78 "/usr/include/fcntl.h" 3 4
# 1 "/usr/include/bits/stat.h" 1 3 4
# 25 "/usr/include/bits/stat.h" 3 4
# 1 "/usr/include/bits/struct_stat.h" 1 3 4
# 26 "/usr/include/bits/struct_stat.h" 3 4
struct stat
  {



    __dev_t st_dev;




    __ino_t st_ino;







    __nlink_t st_nlink;
    __mode_t st_mode;

    __uid_t st_uid;
    __gid_t st_gid;

    int __pad0;

    __dev_t st_rdev;




    __off_t st_size;



    __blksize_t st_blksize;

    __blkcnt_t st_blocks;
# 74 "/usr/include/bits/struct_stat.h" 3 4
    struct timespec st_atim;
    struct timespec st_mtim;
    struct timespec st_ctim;
# 89 "/usr/include/bits/struct_stat.h" 3 4
    __syscall_slong_t __glibc_reserved[3];
# 99 "/usr/include/bits/struct_stat.h" 3 4
  };



struct stat64
  {



    __dev_t st_dev;

    __ino64_t st_ino;
    __nlink_t st_nlink;
    __mode_t st_mode;






    __uid_t st_uid;
    __gid_t st_gid;

    int __pad0;
    __dev_t st_rdev;
    __off_t st_size;





    __blksize_t st_blksize;
    __blkcnt64_t st_blocks;







    struct timespec st_atim;
    struct timespec st_mtim;
    struct timespec st_ctim;
# 151 "/usr/include/bits/struct_stat.h" 3 4
    __syscall_slong_t __glibc_reserved[3];




  };
# 26 "/usr/include/bits/stat.h" 2 3 4
# 79 "/usr/include/fcntl.h" 2 3 4
# 177 "/usr/include/fcntl.h" 3 4
extern int fcntl (int __fd, int __cmd, ...);
# 186 "/usr/include/fcntl.h" 3 4
extern int fcntl64 (int __fd, int __cmd, ...);
# 209 "/usr/include/fcntl.h" 3 4
extern int open (const char *__file, int __oflag, ...) __attribute__ ((__nonnull__ (1)));
# 219 "/usr/include/fcntl.h" 3 4
extern int open64 (const char *__file, int __oflag, ...) __attribute__ ((__nonnull__ (1)));
# 233 "/usr/include/fcntl.h" 3 4
extern int openat (int __fd, const char *__file, int __oflag, ...)
     __attribute__ ((__nonnull__ (2)));
# 244 "/usr/include/fcntl.h" 3 4
extern int openat64 (int __fd, const char *__file, int __oflag, ...)
     __attribute__ ((__nonnull__ (2)));
# 255 "/usr/include/fcntl.h" 3 4
extern int creat (const char *__file, mode_t __mode) __attribute__ ((__nonnull__ (1)));
# 265 "/usr/include/fcntl.h" 3 4
extern int creat64 (const char *__file, mode_t __mode) __attribute__ ((__nonnull__ (1)));
# 301 "/usr/include/fcntl.h" 3 4
extern int posix_fadvise (int __fd, off_t __offset, off_t __len,
     int __advise) noexcept (true);
# 313 "/usr/include/fcntl.h" 3 4
extern int posix_fadvise64 (int __fd, off64_t __offset, off64_t __len,
       int __advise) noexcept (true);
# 323 "/usr/include/fcntl.h" 3 4
extern int posix_fallocate (int __fd, off_t __offset, off_t __len);
# 334 "/usr/include/fcntl.h" 3 4
extern int posix_fallocate64 (int __fd, off64_t __offset, off64_t __len);
# 345 "/usr/include/fcntl.h" 3 4
}
# 26 "/home/avi/scylla-maint/seastar/include/seastar/core/file-types.hh" 2
# 1 "/usr/include/sys/stat.h" 1 3 4
# 99 "/usr/include/sys/stat.h" 3 4
extern "C" {

# 1 "/usr/include/bits/stat.h" 1 3 4
# 102 "/usr/include/sys/stat.h" 2 3 4
# 205 "/usr/include/sys/stat.h" 3 4
extern int stat (const char *__restrict __file,
   struct stat *__restrict __buf) noexcept (true) __attribute__ ((__nonnull__ (1, 2)));



extern int fstat (int __fd, struct stat *__buf) noexcept (true) __attribute__ ((__nonnull__ (2)));
# 240 "/usr/include/sys/stat.h" 3 4
extern int stat64 (const char *__restrict __file,
     struct stat64 *__restrict __buf) noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
extern int fstat64 (int __fd, struct stat64 *__buf) noexcept (true) __attribute__ ((__nonnull__ (2)));
# 264 "/usr/include/sys/stat.h" 3 4
extern int fstatat (int __fd, const char *__restrict __file,
      struct stat *__restrict __buf, int __flag)
     noexcept (true) __attribute__ ((__nonnull__ (2, 3)));
# 291 "/usr/include/sys/stat.h" 3 4
extern int fstatat64 (int __fd, const char *__restrict __file,
        struct stat64 *__restrict __buf, int __flag)
     noexcept (true) __attribute__ ((__nonnull__ (2, 3)));
# 313 "/usr/include/sys/stat.h" 3 4
extern int lstat (const char *__restrict __file,
    struct stat *__restrict __buf) noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
# 338 "/usr/include/sys/stat.h" 3 4
extern int lstat64 (const char *__restrict __file,
      struct stat64 *__restrict __buf)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));
# 352 "/usr/include/sys/stat.h" 3 4
extern int chmod (const char *__file, __mode_t __mode)
     noexcept (true) __attribute__ ((__nonnull__ (1)));





extern int lchmod (const char *__file, __mode_t __mode)
     noexcept (true) __attribute__ ((__nonnull__ (1)));




extern int fchmod (int __fd, __mode_t __mode) noexcept (true);





extern int fchmodat (int __fd, const char *__file, __mode_t __mode,
       int __flag)
     noexcept (true) __attribute__ ((__nonnull__ (2))) ;






extern __mode_t umask (__mode_t __mask) noexcept (true);




extern __mode_t getumask (void) noexcept (true);



extern int mkdir (const char *__path, __mode_t __mode)
     noexcept (true) __attribute__ ((__nonnull__ (1)));





extern int mkdirat (int __fd, const char *__path, __mode_t __mode)
     noexcept (true) __attribute__ ((__nonnull__ (2)));






extern int mknod (const char *__path, __mode_t __mode, __dev_t __dev)
     noexcept (true) __attribute__ ((__nonnull__ (1)));





extern int mknodat (int __fd, const char *__path, __mode_t __mode,
      __dev_t __dev) noexcept (true) __attribute__ ((__nonnull__ (2)));





extern int mkfifo (const char *__path, __mode_t __mode)
     noexcept (true) __attribute__ ((__nonnull__ (1)));





extern int mkfifoat (int __fd, const char *__path, __mode_t __mode)
     noexcept (true) __attribute__ ((__nonnull__ (2)));






extern int utimensat (int __fd, const char *__path,
        const struct timespec __times[2],
        int __flags)
     noexcept (true) __attribute__ ((__nonnull__ (2)));
# 452 "/usr/include/sys/stat.h" 3 4
extern int futimens (int __fd, const struct timespec __times[2]) noexcept (true);
# 465 "/usr/include/sys/stat.h" 3 4
# 1 "/usr/include/bits/statx.h" 1 3 4
# 31 "/usr/include/bits/statx.h" 3 4
# 1 "/usr/include/linux/stat.h" 1 3 4




# 1 "/usr/include/linux/types.h" 1 3 4




# 1 "/usr/include/asm/types.h" 1 3 4
# 1 "/usr/include/asm-generic/types.h" 1 3 4






# 1 "/usr/include/asm-generic/int-ll64.h" 1 3 4
# 12 "/usr/include/asm-generic/int-ll64.h" 3 4
# 1 "/usr/include/asm/bitsperlong.h" 1 3 4
# 11 "/usr/include/asm/bitsperlong.h" 3 4
# 1 "/usr/include/asm-generic/bitsperlong.h" 1 3 4
# 12 "/usr/include/asm/bitsperlong.h" 2 3 4
# 13 "/usr/include/asm-generic/int-ll64.h" 2 3 4







typedef __signed__ char __s8;
typedef unsigned char __u8;

typedef __signed__ short __s16;
typedef unsigned short __u16;

typedef __signed__ int __s32;
typedef unsigned int __u32;


__extension__ typedef __signed__ long long __s64;
__extension__ typedef unsigned long long __u64;
# 8 "/usr/include/asm-generic/types.h" 2 3 4
# 2 "/usr/include/asm/types.h" 2 3 4
# 6 "/usr/include/linux/types.h" 2 3 4



# 1 "/usr/include/linux/posix_types.h" 1 3 4




# 1 "/usr/include/linux/stddef.h" 1 3 4
# 6 "/usr/include/linux/posix_types.h" 2 3 4
# 25 "/usr/include/linux/posix_types.h" 3 4
typedef struct {
 unsigned long fds_bits[1024 / (8 * sizeof(long))];
} __kernel_fd_set;


typedef void (*__kernel_sighandler_t)(int);


typedef int __kernel_key_t;
typedef int __kernel_mqd_t;

# 1 "/usr/include/asm/posix_types.h" 1 3 4






# 1 "/usr/include/asm/posix_types_64.h" 1 3 4
# 11 "/usr/include/asm/posix_types_64.h" 3 4
typedef unsigned short __kernel_old_uid_t;
typedef unsigned short __kernel_old_gid_t;


typedef unsigned long __kernel_old_dev_t;


# 1 "/usr/include/asm-generic/posix_types.h" 1 3 4
# 15 "/usr/include/asm-generic/posix_types.h" 3 4
typedef long __kernel_long_t;
typedef unsigned long __kernel_ulong_t;



typedef __kernel_ulong_t __kernel_ino_t;



typedef unsigned int __kernel_mode_t;



typedef int __kernel_pid_t;



typedef int __kernel_ipc_pid_t;



typedef unsigned int __kernel_uid_t;
typedef unsigned int __kernel_gid_t;



typedef __kernel_long_t __kernel_suseconds_t;



typedef int __kernel_daddr_t;



typedef unsigned int __kernel_uid32_t;
typedef unsigned int __kernel_gid32_t;
# 72 "/usr/include/asm-generic/posix_types.h" 3 4
typedef __kernel_ulong_t __kernel_size_t;
typedef __kernel_long_t __kernel_ssize_t;
typedef __kernel_long_t __kernel_ptrdiff_t;




typedef struct {
 int val[2];
} __kernel_fsid_t;





typedef __kernel_long_t __kernel_off_t;
typedef long long __kernel_loff_t;
typedef __kernel_long_t __kernel_old_time_t;
typedef __kernel_long_t __kernel_time_t;
typedef long long __kernel_time64_t;
typedef __kernel_long_t __kernel_clock_t;
typedef int __kernel_timer_t;
typedef int __kernel_clockid_t;
typedef char * __kernel_caddr_t;
typedef unsigned short __kernel_uid16_t;
typedef unsigned short __kernel_gid16_t;
# 19 "/usr/include/asm/posix_types_64.h" 2 3 4
# 8 "/usr/include/asm/posix_types.h" 2 3 4
# 37 "/usr/include/linux/posix_types.h" 2 3 4
# 10 "/usr/include/linux/types.h" 2 3 4


typedef __signed__ __int128 __s128 __attribute__((aligned(16)));
typedef unsigned __int128 __u128 __attribute__((aligned(16)));
# 31 "/usr/include/linux/types.h" 3 4
typedef __u16 __le16;
typedef __u16 __be16;
typedef __u32 __le32;
typedef __u32 __be32;
typedef __u64 __le64;
typedef __u64 __be64;

typedef __u16 __sum16;
typedef __u32 __wsum;
# 54 "/usr/include/linux/types.h" 3 4
typedef unsigned __poll_t;
# 6 "/usr/include/linux/stat.h" 2 3 4
# 56 "/usr/include/linux/stat.h" 3 4
struct statx_timestamp {
 __s64 tv_sec;
 __u32 tv_nsec;
 __s32 __reserved;
};
# 99 "/usr/include/linux/stat.h" 3 4
struct statx {

 __u32 stx_mask;
 __u32 stx_blksize;
 __u64 stx_attributes;

 __u32 stx_nlink;
 __u32 stx_uid;
 __u32 stx_gid;
 __u16 stx_mode;
 __u16 __spare0[1];

 __u64 stx_ino;
 __u64 stx_size;
 __u64 stx_blocks;
 __u64 stx_attributes_mask;

 struct statx_timestamp stx_atime;
 struct statx_timestamp stx_btime;
 struct statx_timestamp stx_ctime;
 struct statx_timestamp stx_mtime;

 __u32 stx_rdev_major;
 __u32 stx_rdev_minor;
 __u32 stx_dev_major;
 __u32 stx_dev_minor;

 __u64 stx_mnt_id;
 __u32 stx_dio_mem_align;
 __u32 stx_dio_offset_align;

 __u64 __spare3[12];

};
# 32 "/usr/include/bits/statx.h" 2 3 4







# 1 "/usr/include/bits/statx-generic.h" 1 3 4
# 25 "/usr/include/bits/statx-generic.h" 3 4
# 1 "/usr/include/bits/types/struct_statx_timestamp.h" 1 3 4
# 26 "/usr/include/bits/statx-generic.h" 2 3 4
# 1 "/usr/include/bits/types/struct_statx.h" 1 3 4
# 27 "/usr/include/bits/statx-generic.h" 2 3 4
# 58 "/usr/include/bits/statx-generic.h" 3 4
extern "C" {


int statx (int __dirfd, const char *__restrict __path, int __flags,
           unsigned int __mask, struct statx *__restrict __buf)
  noexcept (true) __attribute__ ((__nonnull__ (2, 5)));

}
# 40 "/usr/include/bits/statx.h" 2 3 4
# 466 "/usr/include/sys/stat.h" 2 3 4


}
# 27 "/home/avi/scylla-maint/seastar/include/seastar/core/file-types.hh" 2




namespace seastar {
# 41 "/home/avi/scylla-maint/seastar/include/seastar/core/file-types.hh"
enum class open_flags {
    rw = 02,
    ro = 00,
    wo = 01,
    create = 0100,
    truncate = 01000,
    exclusive = 0200,
    dsync = 010000,
};

inline open_flags operator|(open_flags a, open_flags b) {
    return open_flags(std::underlying_type_t<open_flags>(a) | std::underlying_type_t<open_flags>(b));
}

inline void operator|=(open_flags& a, open_flags b) {
    a = (a | b);
}

inline open_flags operator&(open_flags a, open_flags b) {
    return open_flags(std::underlying_type_t<open_flags>(a) & std::underlying_type_t<open_flags>(b));
}

inline void operator&=(open_flags& a, open_flags b) {
    a = (a & b);
}




enum class directory_entry_type {
    unknown,
    block_device,
    char_device,
    directory,
    fifo,
    link,
    regular,
    socket,
};

namespace internal::linux_abi {



static_assert(sizeof(ino_t) == 8, "large file support not enabled");
static_assert(sizeof(off_t) == 8, "large file support not enabled");


struct linux_dirent64 {
    ino_t d_ino;
    off_t d_off;
    unsigned short d_reclen;
    unsigned char d_type;
    char d_name[];
};

}


enum class fs_type {
    other,
    xfs,
    ext2,
    ext3,
    ext4,
    btrfs,
    hfs,
    tmpfs,
};


enum class access_flags {
    exists = 0,
    read = 4,
    write = 2,
    execute = 1,


    lookup = execute,
};

inline access_flags operator|(access_flags a, access_flags b) {
    return access_flags(std::underlying_type_t<access_flags>(a) | std::underlying_type_t<access_flags>(b));
}

inline access_flags operator&(access_flags a, access_flags b) {
    return access_flags(std::underlying_type_t<access_flags>(a) & std::underlying_type_t<access_flags>(b));
}


enum class file_permissions {
    user_read = 0400,
    user_write = 0200,
    user_execute = 0100,

    group_read = (0400 >> 3),
    group_write = (0200 >> 3),
    group_execute = (0100 >> 3),

    others_read = ((0400 >> 3) >> 3),
    others_write = ((0200 >> 3) >> 3),
    others_execute = ((0100 >> 3) >> 3),

    user_permissions = user_read | user_write | user_execute,
    group_permissions = group_read | group_write | group_execute,
    others_permissions = others_read | others_write | others_execute,
    all_permissions = user_permissions | group_permissions | others_permissions,

    default_file_permissions = user_read | user_write | group_read | group_write | others_read | others_write,
    default_dir_permissions = all_permissions,
};

inline constexpr file_permissions operator|(file_permissions a, file_permissions b) {
    return file_permissions(std::underlying_type_t<file_permissions>(a) | std::underlying_type_t<file_permissions>(b));
}

inline constexpr file_permissions operator&(file_permissions a, file_permissions b) {
    return file_permissions(std::underlying_type_t<file_permissions>(a) & std::underlying_type_t<file_permissions>(b));
}





}
# 53 "/home/avi/scylla-maint/seastar/include/seastar/core/seastar.hh" 2
# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/posix.hh" 1
# 25 "/home/avi/scylla-maint/seastar/include/seastar/core/posix.hh"
# 1 "/usr/include/sys/epoll.h" 1 3 4
# 28 "/usr/include/sys/epoll.h" 3 4
# 1 "/usr/include/bits/epoll.h" 1 3 4
# 23 "/usr/include/bits/epoll.h" 3 4
enum
  {
    EPOLL_CLOEXEC = 02000000

  };
# 29 "/usr/include/sys/epoll.h" 2 3 4






enum EPOLL_EVENTS
  {
    EPOLLIN = 0x001,

    EPOLLPRI = 0x002,

    EPOLLOUT = 0x004,

    EPOLLRDNORM = 0x040,

    EPOLLRDBAND = 0x080,

    EPOLLWRNORM = 0x100,

    EPOLLWRBAND = 0x200,

    EPOLLMSG = 0x400,

    EPOLLERR = 0x008,

    EPOLLHUP = 0x010,

    EPOLLRDHUP = 0x2000,

    EPOLLEXCLUSIVE = 1u << 28,

    EPOLLWAKEUP = 1u << 29,

    EPOLLONESHOT = 1u << 30,

    EPOLLET = 1u << 31

  };
# 76 "/usr/include/sys/epoll.h" 3 4
typedef union epoll_data
{
  void *ptr;
  int fd;
  uint32_t u32;
  uint64_t u64;
} epoll_data_t;

struct epoll_event
{
  uint32_t events;
  epoll_data_t data;
} __attribute__ ((__packed__));


extern "C" {





extern int epoll_create (int __size) noexcept (true);



extern int epoll_create1 (int __flags) noexcept (true);
# 110 "/usr/include/sys/epoll.h" 3 4
extern int epoll_ctl (int __epfd, int __op, int __fd,
        struct epoll_event *__event) noexcept (true);
# 124 "/usr/include/sys/epoll.h" 3 4
extern int epoll_wait (int __epfd, struct epoll_event *__events,
         int __maxevents, int __timeout)
                                        __attribute__ ((__nonnull__ (2)));







extern int epoll_pwait (int __epfd, struct epoll_event *__events,
   int __maxevents, int __timeout,
   const __sigset_t *__ss)
                                        __attribute__ ((__nonnull__ (2)));






extern int epoll_pwait2 (int __epfd, struct epoll_event *__events,
    int __maxevents, const struct timespec *__timeout,
    const __sigset_t *__ss)
                                        __attribute__ ((__nonnull__ (2)));
# 161 "/usr/include/sys/epoll.h" 3 4
}
# 26 "/home/avi/scylla-maint/seastar/include/seastar/core/posix.hh" 2
# 1 "/usr/include/sys/eventfd.h" 1 3 4
# 24 "/usr/include/sys/eventfd.h" 3 4
# 1 "/usr/include/bits/eventfd.h" 1 3 4
# 23 "/usr/include/bits/eventfd.h" 3 4
enum
  {
    EFD_SEMAPHORE = 00000001,

    EFD_CLOEXEC = 02000000,

    EFD_NONBLOCK = 00004000

  };
# 25 "/usr/include/sys/eventfd.h" 2 3 4


typedef uint64_t eventfd_t;


extern "C" {



extern int eventfd (unsigned int __count, int __flags) noexcept (true);


extern int eventfd_read (int __fd, eventfd_t *__value);


extern int eventfd_write (int __fd, eventfd_t __value);

}
# 27 "/home/avi/scylla-maint/seastar/include/seastar/core/posix.hh" 2
# 1 "/usr/include/sys/ioctl.h" 1 3 4
# 23 "/usr/include/sys/ioctl.h" 3 4
extern "C" {


# 1 "/usr/include/bits/ioctls.h" 1 3 4
# 23 "/usr/include/bits/ioctls.h" 3 4
# 1 "/usr/include/asm/ioctls.h" 1 3 4
# 1 "/usr/include/asm-generic/ioctls.h" 1 3 4




# 1 "/usr/include/linux/ioctl.h" 1 3 4




# 1 "/usr/include/asm/ioctl.h" 1 3 4
# 1 "/usr/include/asm-generic/ioctl.h" 1 3 4
# 2 "/usr/include/asm/ioctl.h" 2 3 4
# 6 "/usr/include/linux/ioctl.h" 2 3 4
# 6 "/usr/include/asm-generic/ioctls.h" 2 3 4
# 2 "/usr/include/asm/ioctls.h" 2 3 4
# 24 "/usr/include/bits/ioctls.h" 2 3 4
# 27 "/usr/include/sys/ioctl.h" 2 3 4


# 1 "/usr/include/bits/ioctl-types.h" 1 3 4
# 24 "/usr/include/bits/ioctl-types.h" 3 4
# 1 "/usr/include/asm/ioctls.h" 1 3 4
# 25 "/usr/include/bits/ioctl-types.h" 2 3 4


struct winsize
  {
    unsigned short int ws_row;
    unsigned short int ws_col;
    unsigned short int ws_xpixel;
    unsigned short int ws_ypixel;
  };


struct termio
  {
    unsigned short int c_iflag;
    unsigned short int c_oflag;
    unsigned short int c_cflag;
    unsigned short int c_lflag;
    unsigned char c_line;
    unsigned char c_cc[8];
};
# 30 "/usr/include/sys/ioctl.h" 2 3 4






# 1 "/usr/include/sys/ttydefaults.h" 1 3 4
# 37 "/usr/include/sys/ioctl.h" 2 3 4





extern int ioctl (int __fd, unsigned long int __request, ...) noexcept (true);
# 53 "/usr/include/sys/ioctl.h" 3 4
}
# 28 "/home/avi/scylla-maint/seastar/include/seastar/core/posix.hh" 2
# 1 "/usr/include/sys/mman.h" 1 3 4
# 25 "/usr/include/sys/mman.h" 3 4
# 1 "/usr/bin/../lib/clang/18/include/stddef.h" 1 3 4
# 77 "/usr/bin/../lib/clang/18/include/stddef.h" 3 4
# 1 "/usr/bin/../lib/clang/18/include/__stddef_size_t.h" 1 3 4
# 18 "/usr/bin/../lib/clang/18/include/__stddef_size_t.h" 3 4
typedef long unsigned int size_t;
# 78 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3 4
# 26 "/usr/include/sys/mman.h" 2 3 4
# 41 "/usr/include/sys/mman.h" 3 4
# 1 "/usr/include/bits/mman.h" 1 3 4
# 35 "/usr/include/bits/mman.h" 3 4
# 1 "/usr/include/bits/mman-map-flags-generic.h" 1 3 4
# 36 "/usr/include/bits/mman.h" 2 3 4


# 1 "/usr/include/bits/mman-linux.h" 1 3 4
# 116 "/usr/include/bits/mman-linux.h" 3 4
# 1 "/usr/include/bits/mman-shared.h" 1 3 4
# 51 "/usr/include/bits/mman-shared.h" 3 4
extern "C" {



int memfd_create (const char *__name, unsigned int __flags) noexcept (true);



int mlock2 (const void *__addr, size_t __length, unsigned int __flags) noexcept (true);





int pkey_alloc (unsigned int __flags, unsigned int __access_rights) noexcept (true);



int pkey_set (int __key, unsigned int __access_rights) noexcept (true);



int pkey_get (int __key) noexcept (true);



int pkey_free (int __key) noexcept (true);



int pkey_mprotect (void *__addr, size_t __len, int __prot, int __pkey) noexcept (true);

}
# 117 "/usr/include/bits/mman-linux.h" 2 3 4
# 39 "/usr/include/bits/mman.h" 2 3 4
# 42 "/usr/include/sys/mman.h" 2 3 4




extern "C" {
# 57 "/usr/include/sys/mman.h" 3 4
extern void *mmap (void *__addr, size_t __len, int __prot,
     int __flags, int __fd, __off_t __offset) noexcept (true);
# 70 "/usr/include/sys/mman.h" 3 4
extern void *mmap64 (void *__addr, size_t __len, int __prot,
       int __flags, int __fd, __off64_t __offset) noexcept (true);




extern int munmap (void *__addr, size_t __len) noexcept (true);




extern int mprotect (void *__addr, size_t __len, int __prot) noexcept (true);







extern int msync (void *__addr, size_t __len, int __flags);




extern int madvise (void *__addr, size_t __len, int __advice) noexcept (true);



extern int posix_madvise (void *__addr, size_t __len, int __advice) noexcept (true);




extern int mlock (const void *__addr, size_t __len) noexcept (true);


extern int munlock (const void *__addr, size_t __len) noexcept (true);




extern int mlockall (int __flags) noexcept (true);



extern int munlockall (void) noexcept (true);







extern int mincore (void *__start, size_t __len, unsigned char *__vec)
     noexcept (true);
# 133 "/usr/include/sys/mman.h" 3 4
extern void *mremap (void *__addr, size_t __old_len, size_t __new_len,
       int __flags, ...) noexcept (true);



extern int remap_file_pages (void *__start, size_t __size, int __prot,
        size_t __pgoff, int __flags) noexcept (true);




extern int shm_open (const char *__name, int __oflag, mode_t __mode);


extern int shm_unlink (const char *__name);


# 1 "/usr/include/bits/mman_ext.h" 1 3 4
# 24 "/usr/include/bits/mman_ext.h" 3 4
struct iovec;
extern __ssize_t process_madvise (int __pid_fd, const struct iovec *__iov,
      size_t __count, int __advice,
      unsigned __flags)
  noexcept (true);

extern int process_mrelease (int pidfd, unsigned int flags) noexcept (true);
# 151 "/usr/include/sys/mman.h" 2 3 4

}
# 29 "/home/avi/scylla-maint/seastar/include/seastar/core/posix.hh" 2
# 1 "/usr/include/sys/socket.h" 1 3 4
# 24 "/usr/include/sys/socket.h" 3 4
extern "C" {



# 1 "/usr/bin/../lib/clang/18/include/stddef.h" 1 3 4
# 77 "/usr/bin/../lib/clang/18/include/stddef.h" 3 4
# 1 "/usr/bin/../lib/clang/18/include/__stddef_size_t.h" 1 3 4
# 18 "/usr/bin/../lib/clang/18/include/__stddef_size_t.h" 3 4
typedef long unsigned int size_t;
# 78 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3 4
# 29 "/usr/include/sys/socket.h" 2 3 4




# 1 "/usr/include/bits/socket.h" 1 3 4
# 27 "/usr/include/bits/socket.h" 3 4
# 1 "/usr/bin/../lib/clang/18/include/stddef.h" 1 3 4
# 77 "/usr/bin/../lib/clang/18/include/stddef.h" 3 4
# 1 "/usr/bin/../lib/clang/18/include/__stddef_size_t.h" 1 3 4
# 18 "/usr/bin/../lib/clang/18/include/__stddef_size_t.h" 3 4
typedef long unsigned int size_t;
# 78 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3 4
# 28 "/usr/include/bits/socket.h" 2 3 4
# 38 "/usr/include/bits/socket.h" 3 4
# 1 "/usr/include/bits/socket_type.h" 1 3 4
# 24 "/usr/include/bits/socket_type.h" 3 4
enum __socket_type
{
  SOCK_STREAM = 1,


  SOCK_DGRAM = 2,


  SOCK_RAW = 3,

  SOCK_RDM = 4,

  SOCK_SEQPACKET = 5,


  SOCK_DCCP = 6,

  SOCK_PACKET = 10,







  SOCK_CLOEXEC = 02000000,


  SOCK_NONBLOCK = 00004000


};
# 39 "/usr/include/bits/socket.h" 2 3 4
# 180 "/usr/include/bits/socket.h" 3 4
# 1 "/usr/include/bits/sockaddr.h" 1 3 4
# 28 "/usr/include/bits/sockaddr.h" 3 4
typedef unsigned short int sa_family_t;
# 181 "/usr/include/bits/socket.h" 2 3 4


struct __attribute__ ((__may_alias__)) sockaddr
  {
    sa_family_t sa_family;
    char sa_data[14];
  };
# 196 "/usr/include/bits/socket.h" 3 4
struct __attribute__ ((__may_alias__)) sockaddr_storage
  {
    sa_family_t ss_family;
    char __ss_padding[(128 - (sizeof (unsigned short int)) - sizeof (unsigned long int))];
    unsigned long int __ss_align;
  };



enum
  {
    MSG_OOB = 0x01,

    MSG_PEEK = 0x02,

    MSG_DONTROUTE = 0x04,



    MSG_TRYHARD = MSG_DONTROUTE,


    MSG_CTRUNC = 0x08,

    MSG_PROXY = 0x10,

    MSG_TRUNC = 0x20,

    MSG_DONTWAIT = 0x40,

    MSG_EOR = 0x80,

    MSG_WAITALL = 0x100,

    MSG_FIN = 0x200,

    MSG_SYN = 0x400,

    MSG_CONFIRM = 0x800,

    MSG_RST = 0x1000,

    MSG_ERRQUEUE = 0x2000,

    MSG_NOSIGNAL = 0x4000,

    MSG_MORE = 0x8000,

    MSG_WAITFORONE = 0x10000,

    MSG_BATCH = 0x40000,

    MSG_ZEROCOPY = 0x4000000,

    MSG_FASTOPEN = 0x20000000,


    MSG_CMSG_CLOEXEC = 0x40000000



  };




struct msghdr
  {
    void *msg_name;
    socklen_t msg_namelen;

    struct iovec *msg_iov;
    size_t msg_iovlen;

    void *msg_control;
    size_t msg_controllen;




    int msg_flags;
  };


struct cmsghdr
  {
    size_t cmsg_len;




    int cmsg_level;
    int cmsg_type;

    __extension__ unsigned char __cmsg_data [];

  };
# 316 "/usr/include/bits/socket.h" 3 4
extern struct cmsghdr *__cmsg_nxthdr (struct msghdr *__mhdr,
          struct cmsghdr *__cmsg) noexcept (true);




extern __inline __attribute__ ((__gnu_inline__)) struct cmsghdr *
 __cmsg_nxthdr (struct msghdr *__mhdr, struct cmsghdr *__cmsg) noexcept (true)
{







  unsigned char * __msg_control_ptr = (unsigned char *) __mhdr->msg_control;
  unsigned char * __cmsg_ptr = (unsigned char *) __cmsg;

  size_t __size_needed = sizeof (struct cmsghdr)
                         + ((sizeof (size_t) - ((__cmsg->cmsg_len) & (sizeof (size_t) - 1))) & (sizeof (size_t) - 1));


  if ((size_t) __cmsg->cmsg_len < sizeof (struct cmsghdr))
    return (struct cmsghdr *) 0;



  if (((size_t)
         (__msg_control_ptr + __mhdr->msg_controllen - __cmsg_ptr)
       < __size_needed)
      || ((size_t)
            (__msg_control_ptr + __mhdr->msg_controllen - __cmsg_ptr
             - __size_needed)
          < __cmsg->cmsg_len))

    return (struct cmsghdr *) 0;


  __cmsg = (struct cmsghdr *) ((unsigned char *) __cmsg
          + (((__cmsg->cmsg_len) + sizeof (size_t) - 1) & (size_t) ~(sizeof (size_t) - 1)));
  return __cmsg;
}




enum
  {
    SCM_RIGHTS = 0x01


    , SCM_CREDENTIALS = 0x02

    , SCM_SECURITY = 0x03

    , SCM_PIDFD = 0x04


  };



struct ucred
{
  pid_t pid;
  uid_t uid;
  gid_t gid;
};




# 1 "/usr/include/asm/socket.h" 1 3 4
# 1 "/usr/include/asm-generic/socket.h" 1 3 4





# 1 "/usr/include/asm/sockios.h" 1 3 4
# 1 "/usr/include/asm-generic/sockios.h" 1 3 4
# 2 "/usr/include/asm/sockios.h" 2 3 4
# 7 "/usr/include/asm-generic/socket.h" 2 3 4
# 2 "/usr/include/asm/socket.h" 2 3 4
# 390 "/usr/include/bits/socket.h" 2 3 4






struct linger
  {
    int l_onoff;
    int l_linger;
  };
# 34 "/usr/include/sys/socket.h" 2 3 4


# 1 "/usr/include/bits/types/struct_osockaddr.h" 1 3 4





struct osockaddr
{
  unsigned short int sa_family;
  unsigned char sa_data[14];
};
# 37 "/usr/include/sys/socket.h" 2 3 4




enum
{
  SHUT_RD = 0,

  SHUT_WR,

  SHUT_RDWR

};
# 90 "/usr/include/sys/socket.h" 3 4
struct mmsghdr
  {
    struct msghdr msg_hdr;
    unsigned int msg_len;

  };






extern int socket (int __domain, int __type, int __protocol) noexcept (true);





extern int socketpair (int __domain, int __type, int __protocol,
         int __fds[2]) noexcept (true);


extern int bind (int __fd, const struct sockaddr * __addr, socklen_t __len)
     noexcept (true);


extern int getsockname (int __fd, struct sockaddr *__restrict __addr,
   socklen_t *__restrict __len) noexcept (true);
# 126 "/usr/include/sys/socket.h" 3 4
extern int connect (int __fd, const struct sockaddr * __addr, socklen_t __len);



extern int getpeername (int __fd, struct sockaddr *__restrict __addr,
   socklen_t *__restrict __len) noexcept (true);






extern ssize_t send (int __fd, const void *__buf, size_t __n, int __flags);






extern ssize_t recv (int __fd, void *__buf, size_t __n, int __flags);






extern ssize_t sendto (int __fd, const void *__buf, size_t __n,
         int __flags, const struct sockaddr * __addr,
         socklen_t __addr_len);
# 163 "/usr/include/sys/socket.h" 3 4
extern ssize_t recvfrom (int __fd, void *__restrict __buf, size_t __n,
    int __flags, struct sockaddr *__restrict __addr,
    socklen_t *__restrict __addr_len);
# 174 "/usr/include/sys/socket.h" 3 4
extern ssize_t sendmsg (int __fd, const struct msghdr *__message,
   int __flags);
# 195 "/usr/include/sys/socket.h" 3 4
extern int sendmmsg (int __fd, struct mmsghdr *__vmessages,
       unsigned int __vlen, int __flags);
# 216 "/usr/include/sys/socket.h" 3 4
extern ssize_t recvmsg (int __fd, struct msghdr *__message, int __flags);
# 235 "/usr/include/sys/socket.h" 3 4
extern int recvmmsg (int __fd, struct mmsghdr *__vmessages,
       unsigned int __vlen, int __flags,
       struct timespec *__tmo);
# 255 "/usr/include/sys/socket.h" 3 4
extern int getsockopt (int __fd, int __level, int __optname,
         void *__restrict __optval,
         socklen_t *__restrict __optlen) noexcept (true);
# 277 "/usr/include/sys/socket.h" 3 4
extern int setsockopt (int __fd, int __level, int __optname,
         const void *__optval, socklen_t __optlen) noexcept (true);
# 296 "/usr/include/sys/socket.h" 3 4
extern int listen (int __fd, int __n) noexcept (true);
# 306 "/usr/include/sys/socket.h" 3 4
extern int accept (int __fd, struct sockaddr *__restrict __addr,
     socklen_t *__restrict __addr_len);






extern int accept4 (int __fd, struct sockaddr *__restrict __addr,
      socklen_t *__restrict __addr_len, int __flags);
# 324 "/usr/include/sys/socket.h" 3 4
extern int shutdown (int __fd, int __how) noexcept (true);




extern int sockatmark (int __fd) noexcept (true);







extern int isfdtype (int __fd, int __fdtype) noexcept (true);
# 346 "/usr/include/sys/socket.h" 3 4
}
# 30 "/home/avi/scylla-maint/seastar/include/seastar/core/posix.hh" 2

# 1 "/usr/include/sys/timerfd.h" 1 3 4
# 25 "/usr/include/sys/timerfd.h" 3 4
# 1 "/usr/include/bits/timerfd.h" 1 3 4
# 23 "/usr/include/bits/timerfd.h" 3 4
enum
  {
    TFD_CLOEXEC = 02000000,

    TFD_NONBLOCK = 00004000

  };
# 26 "/usr/include/sys/timerfd.h" 2 3 4



enum
  {
    TFD_TIMER_ABSTIME = 1 << 0,

    TFD_TIMER_CANCEL_ON_SET = 1 << 1

  };


extern "C" {


extern int timerfd_create (__clockid_t __clock_id, int __flags) noexcept (true);




extern int timerfd_settime (int __ufd, int __flags,
       const struct itimerspec *__utmr,
       struct itimerspec *__otmr) noexcept (true);
# 63 "/usr/include/sys/timerfd.h" 3 4
extern int timerfd_gettime (int __ufd, struct itimerspec *__otmr) noexcept (true);
# 75 "/usr/include/sys/timerfd.h" 3 4
}
# 32 "/home/avi/scylla-maint/seastar/include/seastar/core/posix.hh" 2

# 1 "/usr/include/sys/uio.h" 1 3 4
# 31 "/usr/include/sys/uio.h" 3 4
extern "C" {
# 41 "/usr/include/sys/uio.h" 3 4
extern ssize_t readv (int __fd, const struct iovec *__iovec, int __count)
                                             ;
# 52 "/usr/include/sys/uio.h" 3 4
extern ssize_t writev (int __fd, const struct iovec *__iovec, int __count)
                                             ;
# 67 "/usr/include/sys/uio.h" 3 4
extern ssize_t preadv (int __fd, const struct iovec *__iovec, int __count,
         __off_t __offset)
                                             ;
# 80 "/usr/include/sys/uio.h" 3 4
extern ssize_t pwritev (int __fd, const struct iovec *__iovec, int __count,
   __off_t __offset)
                                             ;
# 110 "/usr/include/sys/uio.h" 3 4
extern ssize_t preadv64 (int __fd, const struct iovec *__iovec, int __count,
    __off64_t __offset)
                                             ;
# 123 "/usr/include/sys/uio.h" 3 4
extern ssize_t pwritev64 (int __fd, const struct iovec *__iovec, int __count,
     __off64_t __offset)
                                             ;







extern ssize_t preadv2 (int __fp, const struct iovec *__iovec, int __count,
   __off_t __offset, int ___flags)
                                             ;


extern ssize_t pwritev2 (int __fd, const struct iovec *__iodev, int __count,
    __off_t __offset, int __flags) ;
# 161 "/usr/include/sys/uio.h" 3 4
extern ssize_t preadv64v2 (int __fp, const struct iovec *__iovec,
      int __count, __off64_t __offset,
      int ___flags)
                                             ;


extern ssize_t pwritev64v2 (int __fd, const struct iovec *__iodev,
       int __count, __off64_t __offset,
       int __flags)
                                             ;



}




# 1 "/usr/include/bits/uio-ext.h" 1 3 4
# 26 "/usr/include/bits/uio-ext.h" 3 4
extern "C" {


extern ssize_t process_vm_readv (pid_t __pid, const struct iovec *__lvec,
     unsigned long int __liovcnt,
     const struct iovec *__rvec,
     unsigned long int __riovcnt,
     unsigned long int __flags)
  noexcept (true);


extern ssize_t process_vm_writev (pid_t __pid, const struct iovec *__lvec,
      unsigned long int __liovcnt,
      const struct iovec *__rvec,
      unsigned long int __riovcnt,
      unsigned long int __flags)
  noexcept (true);
# 52 "/usr/include/bits/uio-ext.h" 3 4
}
# 180 "/usr/include/sys/uio.h" 2 3 4
# 34 "/home/avi/scylla-maint/seastar/include/seastar/core/posix.hh" 2
# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 35 "/home/avi/scylla-maint/seastar/include/seastar/core/posix.hh" 2


# 1 "/usr/include/signal.h" 1 3 4
# 27 "/usr/include/signal.h" 3 4
extern "C" {


# 1 "/usr/include/bits/signum-generic.h" 1 3 4
# 76 "/usr/include/bits/signum-generic.h" 3 4
# 1 "/usr/include/bits/signum-arch.h" 1 3 4
# 77 "/usr/include/bits/signum-generic.h" 2 3 4
# 31 "/usr/include/signal.h" 2 3 4

# 1 "/usr/include/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/bits/types/siginfo_t.h" 1 3 4



# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 5 "/usr/include/bits/types/siginfo_t.h" 2 3 4

# 1 "/usr/include/bits/types/__sigval_t.h" 1 3 4
# 24 "/usr/include/bits/types/__sigval_t.h" 3 4
union sigval
{
  int sival_int;
  void *sival_ptr;
};

typedef union sigval __sigval_t;
# 7 "/usr/include/bits/types/siginfo_t.h" 2 3 4
# 16 "/usr/include/bits/types/siginfo_t.h" 3 4
# 1 "/usr/include/bits/siginfo-arch.h" 1 3 4
# 17 "/usr/include/bits/types/siginfo_t.h" 2 3 4
# 36 "/usr/include/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/bits/siginfo-consts.h" 1 3 4
# 35 "/usr/include/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/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,

  SEGV_MTEAERR,

  SEGV_MTESERR,

  SEGV_CPERR

};


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/bits/siginfo-consts-arch.h" 1 3 4
# 216 "/usr/include/bits/siginfo-consts.h" 2 3 4
# 59 "/usr/include/signal.h" 2 3 4



# 1 "/usr/include/bits/types/sigval_t.h" 1 3 4
# 16 "/usr/include/bits/types/sigval_t.h" 3 4
typedef __sigval_t sigval_t;
# 63 "/usr/include/signal.h" 2 3 4



# 1 "/usr/include/bits/types/sigevent_t.h" 1 3 4



# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 5 "/usr/include/bits/types/sigevent_t.h" 2 3 4
# 22 "/usr/include/bits/types/sigevent_t.h" 3 4
typedef struct sigevent
  {
    __sigval_t sigev_value;
    int sigev_signo;
    int sigev_notify;

    union
      {
 int _pad[((64 / sizeof (int)) - 4)];



 __pid_t _tid;

 struct
   {
     void (*_function) (__sigval_t);
     pthread_attr_t *_attribute;
   } _sigev_thread;
      } _sigev_un;
  } sigevent_t;
# 67 "/usr/include/signal.h" 2 3 4
# 1 "/usr/include/bits/sigevent-consts.h" 1 3 4
# 27 "/usr/include/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)
     noexcept (true);

extern __sighandler_t sysv_signal (int __sig, __sighandler_t __handler)
     noexcept (true);






extern __sighandler_t signal (int __sig, __sighandler_t __handler)
     noexcept (true);
# 112 "/usr/include/signal.h" 3 4
extern int kill (__pid_t __pid, int __sig) noexcept (true);






extern int killpg (__pid_t __pgrp, int __sig) noexcept (true);



extern int raise (int __sig) noexcept (true);



extern __sighandler_t ssignal (int __sig, __sighandler_t __handler)
     noexcept (true);
extern int gsignal (int __sig) noexcept (true);




extern void psignal (int __sig, const char *__s);


extern void psiginfo (const siginfo_t *__pinfo, const char *__s);
# 151 "/usr/include/signal.h" 3 4
extern int sigpause (int __sig) __asm__ ("__xpg_sigpause")
  __attribute__ ((__deprecated__ ("Use the sigsuspend function instead")));
# 173 "/usr/include/signal.h" 3 4
extern int sigblock (int __mask) noexcept (true) __attribute__ ((__deprecated__));


extern int sigsetmask (int __mask) noexcept (true) __attribute__ ((__deprecated__));


extern int siggetmask (void) noexcept (true) __attribute__ ((__deprecated__));
# 188 "/usr/include/signal.h" 3 4
typedef __sighandler_t sighandler_t;




typedef __sighandler_t sig_t;





extern int sigemptyset (sigset_t *__set) noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int sigfillset (sigset_t *__set) noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int sigaddset (sigset_t *__set, int __signo) noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int sigdelset (sigset_t *__set, int __signo) noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int sigismember (const sigset_t *__set, int __signo)
     noexcept (true) __attribute__ ((__nonnull__ (1)));



extern int sigisemptyset (const sigset_t *__set) noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int sigandset (sigset_t *__set, const sigset_t *__left,
        const sigset_t *__right) noexcept (true) __attribute__ ((__nonnull__ (1, 2, 3)));


extern int sigorset (sigset_t *__set, const sigset_t *__left,
       const sigset_t *__right) noexcept (true) __attribute__ ((__nonnull__ (1, 2, 3)));




# 1 "/usr/include/bits/sigaction.h" 1 3 4
# 27 "/usr/include/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);
  };
# 230 "/usr/include/signal.h" 2 3 4


extern int sigprocmask (int __how, const sigset_t *__restrict __set,
   sigset_t *__restrict __oset) noexcept (true);






extern int sigsuspend (const sigset_t *__set) __attribute__ ((__nonnull__ (1)));


extern int sigaction (int __sig, const struct sigaction *__restrict __act,
        struct sigaction *__restrict __oact) noexcept (true);


extern int sigpending (sigset_t *__set) noexcept (true) __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)));
# 292 "/usr/include/signal.h" 3 4
extern int sigqueue (__pid_t __pid, int __sig, const union sigval __val)
     noexcept (true);







# 1 "/usr/include/bits/sigcontext.h" 1 3 4
# 31 "/usr/include/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/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;
};
# 302 "/usr/include/signal.h" 2 3 4


extern int sigreturn (struct sigcontext *__scp) noexcept (true);






# 1 "/usr/bin/../lib/clang/18/include/stddef.h" 1 3 4
# 77 "/usr/bin/../lib/clang/18/include/stddef.h" 3 4
# 1 "/usr/bin/../lib/clang/18/include/__stddef_size_t.h" 1 3 4
# 18 "/usr/bin/../lib/clang/18/include/__stddef_size_t.h" 3 4
typedef long unsigned int size_t;
# 78 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3 4
# 312 "/usr/include/signal.h" 2 3 4
# 324 "/usr/include/signal.h" 3 4
extern int siginterrupt (int __sig, int __interrupt) noexcept (true)
  __attribute__ ((__deprecated__ ("Use sigaction with SA_RESTART instead")));

# 1 "/usr/include/bits/sigstack.h" 1 3 4
# 328 "/usr/include/signal.h" 2 3 4
# 1 "/usr/include/bits/sigstksz.h" 1 3 4
# 329 "/usr/include/signal.h" 2 3 4
# 1 "/usr/include/bits/ss_flags.h" 1 3 4
# 27 "/usr/include/bits/ss_flags.h" 3 4
enum
{
  SS_ONSTACK = 1,

  SS_DISABLE

};
# 330 "/usr/include/signal.h" 2 3 4



extern int sigaltstack (const stack_t *__restrict __ss,
   stack_t *__restrict __oss) noexcept (true);




# 1 "/usr/include/bits/types/struct_sigstack.h" 1 3 4
# 23 "/usr/include/bits/types/struct_sigstack.h" 3 4
struct sigstack
  {
    void *ss_sp;
    int ss_onstack;
  };
# 340 "/usr/include/signal.h" 2 3 4







extern int sigstack (struct sigstack *__ss, struct sigstack *__oss)
     noexcept (true) __attribute__ ((__deprecated__));






extern int sighold (int __sig) noexcept (true)
  __attribute__ ((__deprecated__ ("Use the sigprocmask function instead")));


extern int sigrelse (int __sig) noexcept (true)
  __attribute__ ((__deprecated__ ("Use the sigprocmask function instead")));


extern int sigignore (int __sig) noexcept (true)
  __attribute__ ((__deprecated__ ("Use the signal function instead")));


extern __sighandler_t sigset (int __sig, __sighandler_t __disp) noexcept (true)
  __attribute__ ((__deprecated__ ("Use the signal and sigprocmask functions instead")));







# 1 "/usr/include/bits/sigthread.h" 1 3 4
# 31 "/usr/include/bits/sigthread.h" 3 4
extern int pthread_sigmask (int __how,
       const __sigset_t *__restrict __newmask,
       __sigset_t *__restrict __oldmask)noexcept (true);


extern int pthread_kill (pthread_t __threadid, int __signo) noexcept (true);



extern int pthread_sigqueue (pthread_t __threadid, int __signo,
        const union sigval __value) noexcept (true);
# 377 "/usr/include/signal.h" 2 3 4






extern int __libc_current_sigrtmin (void) noexcept (true);

extern int __libc_current_sigrtmax (void) noexcept (true);





# 1 "/usr/include/bits/signal_ext.h" 1 3 4
# 29 "/usr/include/bits/signal_ext.h" 3 4
extern int tgkill (__pid_t __tgid, __pid_t __tid, int __signal);
# 392 "/usr/include/signal.h" 2 3 4

}
# 38 "/home/avi/scylla-maint/seastar/include/seastar/core/posix.hh" 2
# 1 "/usr/include/spawn.h" 1 3 4
# 29 "/usr/include/spawn.h" 3 4
typedef struct
{
  short int __flags;
  pid_t __pgrp;
  sigset_t __sd;
  sigset_t __ss;
  struct sched_param __sp;
  int __policy;
  int __cgroup;
  int __pad[15];
} posix_spawnattr_t;




typedef struct
{
  int __allocated;
  int __used;
  struct __spawn_action *__actions;
  int __pad[16];
} posix_spawn_file_actions_t;
# 67 "/usr/include/spawn.h" 3 4
extern "C" {






extern int posix_spawn (pid_t *__restrict __pid,
   const char *__restrict __path,
   const posix_spawn_file_actions_t *__restrict
   __file_actions,
   const posix_spawnattr_t *__restrict __attrp,
   char *const __argv[],
   char *const __envp[])
    __attribute__ ((__nonnull__ (2, 5)));





extern int posix_spawnp (pid_t *__pid, const char *__file,
    const posix_spawn_file_actions_t *__file_actions,
    const posix_spawnattr_t *__attrp,
    char *const __argv[], char *const __envp[])
    __attribute__ ((__nonnull__ (2, 5)));



extern int posix_spawnattr_init (posix_spawnattr_t *__attr)
    noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int posix_spawnattr_destroy (posix_spawnattr_t *__attr)
    noexcept (true) __attribute__ ((__nonnull__ (1)));



extern int posix_spawnattr_getsigdefault (const posix_spawnattr_t *
       __restrict __attr,
       sigset_t *__restrict __sigdefault)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern int posix_spawnattr_setsigdefault (posix_spawnattr_t *__restrict __attr,
       const sigset_t *__restrict
       __sigdefault)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern int posix_spawnattr_getsigmask (const posix_spawnattr_t *__restrict
           __attr,
           sigset_t *__restrict __sigmask)
    noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern int posix_spawnattr_setsigmask (posix_spawnattr_t *__restrict __attr,
           const sigset_t *__restrict __sigmask)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern int posix_spawnattr_getflags (const posix_spawnattr_t *__restrict
         __attr,
         short int *__restrict __flags)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern int posix_spawnattr_setflags (posix_spawnattr_t *_attr,
         short int __flags)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int posix_spawnattr_getpgroup (const posix_spawnattr_t *__restrict
          __attr, pid_t *__restrict __pgroup)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern int posix_spawnattr_setpgroup (posix_spawnattr_t *__attr,
          pid_t __pgroup)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int posix_spawnattr_getschedpolicy (const posix_spawnattr_t *
        __restrict __attr,
        int *__restrict __schedpolicy)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern int posix_spawnattr_setschedpolicy (posix_spawnattr_t *__attr,
        int __schedpolicy)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int posix_spawnattr_getschedparam (const posix_spawnattr_t *
       __restrict __attr,
       struct sched_param *__restrict
       __schedparam)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern int posix_spawnattr_setschedparam (posix_spawnattr_t *__restrict __attr,
       const struct sched_param *
       __restrict __schedparam)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern int posix_spawn_file_actions_init (posix_spawn_file_actions_t *
       __file_actions)
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int posix_spawn_file_actions_destroy (posix_spawn_file_actions_t *
          __file_actions)
     noexcept (true) __attribute__ ((__nonnull__ (1)));



extern int posix_spawn_file_actions_addopen (posix_spawn_file_actions_t *
          __restrict __file_actions,
          int __fd,
          const char *__restrict __path,
          int __oflag, mode_t __mode)
     noexcept (true) __attribute__ ((__nonnull__ (1, 3)));



extern int posix_spawn_file_actions_addclose (posix_spawn_file_actions_t *
           __file_actions, int __fd)
     noexcept (true) __attribute__ ((__nonnull__ (1)));



extern int posix_spawn_file_actions_adddup2 (posix_spawn_file_actions_t *
          __file_actions,
          int __fd, int __newfd)
     noexcept (true) __attribute__ ((__nonnull__ (1)));




extern int posix_spawn_file_actions_addchdir_np (posix_spawn_file_actions_t *
       __restrict __actions,
       const char *__restrict __path)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));




extern int posix_spawn_file_actions_addfchdir_np (posix_spawn_file_actions_t *,
        int __fd)
     noexcept (true) __attribute__ ((__nonnull__ (1)));



extern int
posix_spawn_file_actions_addclosefrom_np (posix_spawn_file_actions_t *,
       int __from)
     noexcept (true) __attribute__ ((__nonnull__ (1)));



extern int
posix_spawn_file_actions_addtcsetpgrp_np (posix_spawn_file_actions_t *,
       int __tcfd)
     noexcept (true) __attribute__ ((__nonnull__ (1)));



}

# 1 "/usr/include/bits/spawn_ext.h" 1 3 4
# 23 "/usr/include/bits/spawn_ext.h" 3 4
extern "C" {




extern int posix_spawnattr_getcgroup_np (const posix_spawnattr_t *
      __restrict __attr,
      int *__restrict __cgroup)
     noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


extern int posix_spawnattr_setcgroup_np (posix_spawnattr_t *__attr,
      int __cgroup)
     noexcept (true) __attribute__ ((__nonnull__ (1)));
# 45 "/usr/include/bits/spawn_ext.h" 3 4
extern int pidfd_spawn (int *__restrict __pidfd,
   const char *__restrict __path,
   const posix_spawn_file_actions_t *__restrict __facts,
   const posix_spawnattr_t *__restrict __attrp,
   char *const __argv[],
   char *const __envp[])
    __attribute__ ((__nonnull__ (2, 5)));





extern int pidfd_spawnp (int *__restrict __pidfd,
    const char *__restrict __file,
    const posix_spawn_file_actions_t *__restrict __facts,
    const posix_spawnattr_t *__restrict __attrp,
    char *const __argv[],
    char *const __envp[])
    __attribute__ ((__nonnull__ (1, 2, 5)));



}
# 237 "/usr/include/spawn.h" 2 3 4
# 39 "/home/avi/scylla-maint/seastar/include/seastar/core/posix.hh" 2




# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 1 3
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 3


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 43 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 2 3
# 44 "/home/avi/scylla-maint/seastar/include/seastar/core/posix.hh" 2


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/set" 1 3
# 59 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/set" 3



# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_tree.h" 1 3
# 62 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_tree.h" 3
# 75 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_tree.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 95 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_tree.h" 3
  enum _Rb_tree_color { _S_red = false, _S_black = true };

  struct _Rb_tree_node_base
  {
    typedef _Rb_tree_node_base* _Base_ptr;
    typedef const _Rb_tree_node_base* _Const_Base_ptr;

    _Rb_tree_color _M_color;
    _Base_ptr _M_parent;
    _Base_ptr _M_left;
    _Base_ptr _M_right;

    static _Base_ptr
    _S_minimum(_Base_ptr __x) noexcept
    {
      while (__x->_M_left != 0) __x = __x->_M_left;
      return __x;
    }

    static _Const_Base_ptr
    _S_minimum(_Const_Base_ptr __x) noexcept
    {
      while (__x->_M_left != 0) __x = __x->_M_left;
      return __x;
    }

    static _Base_ptr
    _S_maximum(_Base_ptr __x) noexcept
    {
      while (__x->_M_right != 0) __x = __x->_M_right;
      return __x;
    }

    static _Const_Base_ptr
    _S_maximum(_Const_Base_ptr __x) noexcept
    {
      while (__x->_M_right != 0) __x = __x->_M_right;
      return __x;
    }
  };


  template<typename _Key_compare>
    struct _Rb_tree_key_compare
    {
      _Key_compare _M_key_compare;

      _Rb_tree_key_compare()
      noexcept(is_nothrow_default_constructible<_Key_compare>::value)

      : _M_key_compare()
      { }

      _Rb_tree_key_compare(const _Key_compare& __comp)
      : _M_key_compare(__comp)
      { }



      _Rb_tree_key_compare(const _Rb_tree_key_compare&) = default;

      _Rb_tree_key_compare(_Rb_tree_key_compare&& __x)
 noexcept(is_nothrow_copy_constructible<_Key_compare>::value)
      : _M_key_compare(__x._M_key_compare)
      { }

    };


  struct _Rb_tree_header
  {
    _Rb_tree_node_base _M_header;
    size_t _M_node_count;

    _Rb_tree_header() noexcept
    {
      _M_header._M_color = _S_red;
      _M_reset();
    }


    _Rb_tree_header(_Rb_tree_header&& __x) noexcept
    {
      if (__x._M_header._M_parent != nullptr)
 _M_move_data(__x);
      else
 {
   _M_header._M_color = _S_red;
   _M_reset();
 }
    }


    void
    _M_move_data(_Rb_tree_header& __from)
    {
      _M_header._M_color = __from._M_header._M_color;
      _M_header._M_parent = __from._M_header._M_parent;
      _M_header._M_left = __from._M_header._M_left;
      _M_header._M_right = __from._M_header._M_right;
      _M_header._M_parent->_M_parent = &_M_header;
      _M_node_count = __from._M_node_count;

      __from._M_reset();
    }

    void
    _M_reset()
    {
      _M_header._M_parent = 0;
      _M_header._M_left = &_M_header;
      _M_header._M_right = &_M_header;
      _M_node_count = 0;
    }
  };

  template<typename _Val>
    struct _Rb_tree_node : public _Rb_tree_node_base
    {
      typedef _Rb_tree_node<_Val>* _Link_type;
# 227 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_tree.h" 3
      __gnu_cxx::__aligned_membuf<_Val> _M_storage;

      _Val*
      _M_valptr()
      { return _M_storage._M_ptr(); }

      const _Val*
      _M_valptr() const
      { return _M_storage._M_ptr(); }

    };

  __attribute__ ((__pure__)) _Rb_tree_node_base*
  _Rb_tree_increment(_Rb_tree_node_base* __x) throw ();

  __attribute__ ((__pure__)) const _Rb_tree_node_base*
  _Rb_tree_increment(const _Rb_tree_node_base* __x) throw ();

  __attribute__ ((__pure__)) _Rb_tree_node_base*
  _Rb_tree_decrement(_Rb_tree_node_base* __x) throw ();

  __attribute__ ((__pure__)) const _Rb_tree_node_base*
  _Rb_tree_decrement(const _Rb_tree_node_base* __x) throw ();

  template<typename _Tp>
    struct _Rb_tree_iterator
    {
      typedef _Tp value_type;
      typedef _Tp& reference;
      typedef _Tp* pointer;

      typedef bidirectional_iterator_tag iterator_category;
      typedef ptrdiff_t difference_type;

      typedef _Rb_tree_iterator<_Tp> _Self;
      typedef _Rb_tree_node_base::_Base_ptr _Base_ptr;
      typedef _Rb_tree_node<_Tp>* _Link_type;

      _Rb_tree_iterator() noexcept
      : _M_node() { }

      explicit
      _Rb_tree_iterator(_Base_ptr __x) noexcept
      : _M_node(__x) { }

      reference
      operator*() const noexcept
      { return *static_cast<_Link_type>(_M_node)->_M_valptr(); }

      pointer
      operator->() const noexcept
      { return static_cast<_Link_type> (_M_node)->_M_valptr(); }

      _Self&
      operator++() noexcept
      {
 _M_node = _Rb_tree_increment(_M_node);
 return *this;
      }

      _Self
      operator++(int) noexcept
      {
 _Self __tmp = *this;
 _M_node = _Rb_tree_increment(_M_node);
 return __tmp;
      }

      _Self&
      operator--() noexcept
      {
 _M_node = _Rb_tree_decrement(_M_node);
 return *this;
      }

      _Self
      operator--(int) noexcept
      {
 _Self __tmp = *this;
 _M_node = _Rb_tree_decrement(_M_node);
 return __tmp;
      }

      friend bool
      operator==(const _Self& __x, const _Self& __y) noexcept
      { return __x._M_node == __y._M_node; }







      _Base_ptr _M_node;
    };

  template<typename _Tp>
    struct _Rb_tree_const_iterator
    {
      typedef _Tp value_type;
      typedef const _Tp& reference;
      typedef const _Tp* pointer;

      typedef _Rb_tree_iterator<_Tp> iterator;

      typedef bidirectional_iterator_tag iterator_category;
      typedef ptrdiff_t difference_type;

      typedef _Rb_tree_const_iterator<_Tp> _Self;
      typedef _Rb_tree_node_base::_Const_Base_ptr _Base_ptr;
      typedef const _Rb_tree_node<_Tp>* _Link_type;

      _Rb_tree_const_iterator() noexcept
      : _M_node() { }

      explicit
      _Rb_tree_const_iterator(_Base_ptr __x) noexcept
      : _M_node(__x) { }

      _Rb_tree_const_iterator(const iterator& __it) noexcept
      : _M_node(__it._M_node) { }

      iterator
      _M_const_cast() const noexcept
      { return iterator(const_cast<typename iterator::_Base_ptr>(_M_node)); }

      reference
      operator*() const noexcept
      { return *static_cast<_Link_type>(_M_node)->_M_valptr(); }

      pointer
      operator->() const noexcept
      { return static_cast<_Link_type>(_M_node)->_M_valptr(); }

      _Self&
      operator++() noexcept
      {
 _M_node = _Rb_tree_increment(_M_node);
 return *this;
      }

      _Self
      operator++(int) noexcept
      {
 _Self __tmp = *this;
 _M_node = _Rb_tree_increment(_M_node);
 return __tmp;
      }

      _Self&
      operator--() noexcept
      {
 _M_node = _Rb_tree_decrement(_M_node);
 return *this;
      }

      _Self
      operator--(int) noexcept
      {
 _Self __tmp = *this;
 _M_node = _Rb_tree_decrement(_M_node);
 return __tmp;
      }

      friend bool
      operator==(const _Self& __x, const _Self& __y) noexcept
      { return __x._M_node == __y._M_node; }







      _Base_ptr _M_node;
    };

  __attribute__((__nonnull__))
  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 ();

  __attribute__((__nonnull__,__returns_nonnull__))
  _Rb_tree_node_base*
  _Rb_tree_rebalance_for_erase(_Rb_tree_node_base* const __z,
          _Rb_tree_node_base& __header) throw ();


  template<typename _Tree1, typename _Cmp2>
    struct _Rb_tree_merge_helper { };


  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc = allocator<_Val> >
    class _Rb_tree
    {
      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
 rebind<_Rb_tree_node<_Val> >::other _Node_allocator;

      typedef __gnu_cxx::__alloc_traits<_Node_allocator> _Alloc_traits;

    protected:
      typedef _Rb_tree_node_base* _Base_ptr;
      typedef const _Rb_tree_node_base* _Const_Base_ptr;
      typedef _Rb_tree_node<_Val>* _Link_type;
      typedef const _Rb_tree_node<_Val>* _Const_Link_type;

    private:


      struct _Reuse_or_alloc_node
      {
 _Reuse_or_alloc_node(_Rb_tree& __t)
 : _M_root(__t._M_root()), _M_nodes(__t._M_rightmost()), _M_t(__t)
 {
   if (_M_root)
     {
       _M_root->_M_parent = 0;

       if (_M_nodes->_M_left)
  _M_nodes = _M_nodes->_M_left;
     }
   else
     _M_nodes = 0;
 }


 _Reuse_or_alloc_node(const _Reuse_or_alloc_node&) = delete;


 ~_Reuse_or_alloc_node()
 { _M_t._M_erase(static_cast<_Link_type>(_M_root)); }

 template<typename _Arg>
   _Link_type
   operator()(_Arg&& __arg)
   {
     _Link_type __node = static_cast<_Link_type>(_M_extract());
     if (__node)
       {
  _M_t._M_destroy_node(__node);
  _M_t._M_construct_node(__node, std::forward<_Arg>(__arg));
  return __node;
       }

     return _M_t._M_create_node(std::forward<_Arg>(__arg));
   }

      private:
 _Base_ptr
 _M_extract()
 {
   if (!_M_nodes)
     return _M_nodes;

   _Base_ptr __node = _M_nodes;
   _M_nodes = _M_nodes->_M_parent;
   if (_M_nodes)
     {
       if (_M_nodes->_M_right == __node)
  {
    _M_nodes->_M_right = 0;

    if (_M_nodes->_M_left)
      {
        _M_nodes = _M_nodes->_M_left;

        while (_M_nodes->_M_right)
   _M_nodes = _M_nodes->_M_right;

        if (_M_nodes->_M_left)
   _M_nodes = _M_nodes->_M_left;
      }
  }
       else
  _M_nodes->_M_left = 0;
     }
   else
     _M_root = 0;

   return __node;
 }

 _Base_ptr _M_root;
 _Base_ptr _M_nodes;
 _Rb_tree& _M_t;
      };



      struct _Alloc_node
      {
 _Alloc_node(_Rb_tree& __t)
 : _M_t(__t) { }

 template<typename _Arg>
   _Link_type
   operator()(_Arg&& __arg) const
   { return _M_t._M_create_node(std::forward<_Arg>(__arg)); }

      private:
 _Rb_tree& _M_t;
      };

    public:
      typedef _Key key_type;
      typedef _Val value_type;
      typedef value_type* pointer;
      typedef const value_type* const_pointer;
      typedef value_type& reference;
      typedef const value_type& const_reference;
      typedef size_t size_type;
      typedef ptrdiff_t difference_type;
      typedef _Alloc allocator_type;

      _Node_allocator&
      _M_get_Node_allocator() noexcept
      { return this->_M_impl; }

      const _Node_allocator&
      _M_get_Node_allocator() const noexcept
      { return this->_M_impl; }

      allocator_type
      get_allocator() const noexcept
      { return allocator_type(_M_get_Node_allocator()); }

    protected:
      _Link_type
      _M_get_node()
      { return _Alloc_traits::allocate(_M_get_Node_allocator(), 1); }

      void
      _M_put_node(_Link_type __p) noexcept
      { _Alloc_traits::deallocate(_M_get_Node_allocator(), __p, 1); }
# 586 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_tree.h" 3
      template<typename... _Args>
 void
 _M_construct_node(_Link_type __node, _Args&&... __args)
 {
   try
     {
       ::new(__node) _Rb_tree_node<_Val>;
       _Alloc_traits::construct(_M_get_Node_allocator(),
           __node->_M_valptr(),
           std::forward<_Args>(__args)...);
     }
   catch(...)
     {
       __node->~_Rb_tree_node<_Val>();
       _M_put_node(__node);
       throw;
     }
 }

      template<typename... _Args>
 _Link_type
 _M_create_node(_Args&&... __args)
 {
   _Link_type __tmp = _M_get_node();
   _M_construct_node(__tmp, std::forward<_Args>(__args)...);
   return __tmp;
 }


      void
      _M_destroy_node(_Link_type __p) noexcept
      {



 _Alloc_traits::destroy(_M_get_Node_allocator(), __p->_M_valptr());
 __p->~_Rb_tree_node<_Val>();

      }

      void
      _M_drop_node(_Link_type __p) noexcept
      {
 _M_destroy_node(__p);
 _M_put_node(__p);
      }

      template<bool _MoveValue, typename _NodeGen>
 _Link_type
 _M_clone_node(_Link_type __x, _NodeGen& __node_gen)
 {

   using _Vp = __conditional_t<_MoveValue,
          value_type&&,
          const value_type&>;

   _Link_type __tmp
     = __node_gen(std::forward<_Vp>(*__x->_M_valptr()));
   __tmp->_M_color = __x->_M_color;
   __tmp->_M_left = 0;
   __tmp->_M_right = 0;
   return __tmp;
 }

    protected:




      template<typename _Key_compare,
        bool = __is_pod(_Key_compare)>

 struct _Rb_tree_impl
 : public _Node_allocator
 , public _Rb_tree_key_compare<_Key_compare>
 , public _Rb_tree_header
 {
   typedef _Rb_tree_key_compare<_Key_compare> _Base_key_compare;

   _Rb_tree_impl()
     noexcept(is_nothrow_default_constructible<_Node_allocator>::value && is_nothrow_default_constructible<_Base_key_compare>::value)


   : _Node_allocator()
   { }

   _Rb_tree_impl(const _Rb_tree_impl& __x)
   : _Node_allocator(_Alloc_traits::_S_select_on_copy(__x))
   , _Base_key_compare(__x._M_key_compare)
   , _Rb_tree_header()
   { }






   _Rb_tree_impl(_Rb_tree_impl&&)
     noexcept( is_nothrow_move_constructible<_Base_key_compare>::value )
   = 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_mbegin() const noexcept
      { return static_cast<_Link_type>(this->_M_impl._M_header._M_parent); }

      _Link_type
      _M_begin() noexcept
      { return _M_mbegin(); }

      _Const_Link_type
      _M_begin() const noexcept
      {
 return static_cast<_Const_Link_type>
   (this->_M_impl._M_header._M_parent);
      }

      _Base_ptr
      _M_end() noexcept
      { return &this->_M_impl._M_header; }

      _Const_Base_ptr
      _M_end() const noexcept
      { return &this->_M_impl._M_header; }

      static const _Key&
      _S_key(_Const_Link_type __x)
      {



 static_assert(__is_invocable<_Compare&, const _Key&, const _Key&>{},
        "comparison object must be invocable "
        "with two arguments of key type");



 if constexpr (__is_invocable<_Compare&, const _Key&, const _Key&>{})
   static_assert(
       is_invocable_v<const _Compare&, const _Key&, const _Key&>,
       "comparison object must be invocable as const");



 return _KeyOfValue()(*__x->_M_valptr());
      }

      static _Link_type
      _S_left(_Base_ptr __x) noexcept
      { return static_cast<_Link_type>(__x->_M_left); }

      static _Const_Link_type
      _S_left(_Const_Base_ptr __x) noexcept
      { return static_cast<_Const_Link_type>(__x->_M_left); }

      static _Link_type
      _S_right(_Base_ptr __x) noexcept
      { return static_cast<_Link_type>(__x->_M_right); }

      static _Const_Link_type
      _S_right(_Const_Base_ptr __x) noexcept
      { return static_cast<_Const_Link_type>(__x->_M_right); }

      static const _Key&
      _S_key(_Const_Base_ptr __x)
      { return _S_key(static_cast<_Const_Link_type>(__x)); }

      static _Base_ptr
      _S_minimum(_Base_ptr __x) noexcept
      { return _Rb_tree_node_base::_S_minimum(__x); }

      static _Const_Base_ptr
      _S_minimum(_Const_Base_ptr __x) noexcept
      { return _Rb_tree_node_base::_S_minimum(__x); }

      static _Base_ptr
      _S_maximum(_Base_ptr __x) noexcept
      { return _Rb_tree_node_base::_S_maximum(__x); }

      static _Const_Base_ptr
      _S_maximum(_Const_Base_ptr __x) noexcept
      { return _Rb_tree_node_base::_S_maximum(__x); }

    public:
      typedef _Rb_tree_iterator<value_type> iterator;
      typedef _Rb_tree_const_iterator<value_type> const_iterator;

      typedef std::reverse_iterator<iterator> reverse_iterator;
      typedef std::reverse_iterator<const_iterator> const_reverse_iterator;


      using node_type = _Node_handle<_Key, _Val, _Node_allocator>;
      using insert_return_type = _Node_insert_return<
 __conditional_t<is_same_v<_Key, _Val>, const_iterator, iterator>,
 node_type>;


      pair<_Base_ptr, _Base_ptr>
      _M_get_insert_unique_pos(const key_type& __k);

      pair<_Base_ptr, _Base_ptr>
      _M_get_insert_equal_pos(const key_type& __k);

      pair<_Base_ptr, _Base_ptr>
      _M_get_insert_hint_unique_pos(const_iterator __pos,
        const key_type& __k);

      pair<_Base_ptr, _Base_ptr>
      _M_get_insert_hint_equal_pos(const_iterator __pos,
       const key_type& __k);

    private:

      template<typename _Arg, typename _NodeGen>
 iterator
 _M_insert_(_Base_ptr __x, _Base_ptr __y, _Arg&& __v, _NodeGen&);

      iterator
      _M_insert_node(_Base_ptr __x, _Base_ptr __y, _Link_type __z);

      template<typename _Arg>
 iterator
 _M_insert_lower(_Base_ptr __y, _Arg&& __v);

      template<typename _Arg>
 iterator
 _M_insert_equal_lower(_Arg&& __x);

      iterator
      _M_insert_lower_node(_Base_ptr __p, _Link_type __z);

      iterator
      _M_insert_equal_lower_node(_Link_type __z);
# 877 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_tree.h" 3
      enum { __as_lvalue, __as_rvalue };

      template<bool _MoveValues, typename _NodeGen>
 _Link_type
 _M_copy(_Link_type, _Base_ptr, _NodeGen&);

      template<bool _MoveValues, typename _NodeGen>
 _Link_type
 _M_copy(const _Rb_tree& __x, _NodeGen& __gen)
 {
   _Link_type __root =
     _M_copy<_MoveValues>(__x._M_mbegin(), _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<__as_lvalue>(__x, __an);
      }

      void
      _M_erase(_Link_type __x);

      iterator
      _M_lower_bound(_Link_type __x, _Base_ptr __y,
       const _Key& __k);

      const_iterator
      _M_lower_bound(_Const_Link_type __x, _Const_Base_ptr __y,
       const _Key& __k) const;

      iterator
      _M_upper_bound(_Link_type __x, _Base_ptr __y,
       const _Key& __k);

      const_iterator
      _M_upper_bound(_Const_Link_type __x, _Const_Base_ptr __y,
       const _Key& __k) const;

    public:




      _Rb_tree() = default;


      _Rb_tree(const _Compare& __comp,
        const allocator_type& __a = allocator_type())
      : _M_impl(__comp, _Node_allocator(__a)) { }

      _Rb_tree(const _Rb_tree& __x)
      : _M_impl(__x._M_impl)
      {
 if (__x._M_root() != 0)
   _M_root() = _M_copy(__x);
      }


      _Rb_tree(const allocator_type& __a)
      : _M_impl(_Node_allocator(__a))
      { }

      _Rb_tree(const _Rb_tree& __x, const allocator_type& __a)
      : _M_impl(__x._M_impl._M_key_compare, _Node_allocator(__a))
      {
 if (__x._M_root() != nullptr)
   _M_root() = _M_copy(__x);
      }

      _Rb_tree(_Rb_tree&&) = default;

      _Rb_tree(_Rb_tree&& __x, const allocator_type& __a)
      : _Rb_tree(std::move(__x), _Node_allocator(__a))
      { }

    private:
      _Rb_tree(_Rb_tree&& __x, _Node_allocator&& __a, true_type)
      noexcept(is_nothrow_default_constructible<_Compare>::value)
      : _M_impl(std::move(__x._M_impl), std::move(__a))
      { }

      _Rb_tree(_Rb_tree&& __x, _Node_allocator&& __a, false_type)
      : _M_impl(__x._M_impl._M_key_compare, std::move(__a))
      {
 if (__x._M_root() != nullptr)
   _M_move_data(__x, false_type{});
      }

    public:
      _Rb_tree(_Rb_tree&& __x, _Node_allocator&& __a)
      noexcept( noexcept(
 _Rb_tree(std::declval<_Rb_tree&&>(), std::declval<_Node_allocator&&>(),
   std::declval<typename _Alloc_traits::is_always_equal>())) )
      : _Rb_tree(std::move(__x), std::move(__a),
   typename _Alloc_traits::is_always_equal{})
      { }


      ~_Rb_tree() noexcept
      { _M_erase(_M_begin()); }

      _Rb_tree&
      operator=(const _Rb_tree& __x);


      _Compare
      key_comp() const
      { return _M_impl._M_key_compare; }

      iterator
      begin() noexcept
      { return iterator(this->_M_impl._M_header._M_left); }

      const_iterator
      begin() const noexcept
      { return const_iterator(this->_M_impl._M_header._M_left); }

      iterator
      end() noexcept
      { return iterator(&this->_M_impl._M_header); }

      const_iterator
      end() const noexcept
      { return const_iterator(&this->_M_impl._M_header); }

      reverse_iterator
      rbegin() noexcept
      { return reverse_iterator(end()); }

      const_reverse_iterator
      rbegin() const noexcept
      { return const_reverse_iterator(end()); }

      reverse_iterator
      rend() noexcept
      { return reverse_iterator(begin()); }

      const_reverse_iterator
      rend() const noexcept
      { return const_reverse_iterator(begin()); }

      [[__nodiscard__]] bool
      empty() const noexcept
      { return _M_impl._M_node_count == 0; }

      size_type
      size() const noexcept
      { return _M_impl._M_node_count; }

      size_type
      max_size() const noexcept
      { return _Alloc_traits::max_size(_M_get_Node_allocator()); }

      void
      swap(_Rb_tree& __t)
      noexcept(__is_nothrow_swappable<_Compare>::value);



      template<typename _Arg>
 pair<iterator, bool>
 _M_insert_unique(_Arg&& __x);

      template<typename _Arg>
 iterator
 _M_insert_equal(_Arg&& __x);

      template<typename _Arg, typename _NodeGen>
 iterator
 _M_insert_unique_(const_iterator __pos, _Arg&& __x, _NodeGen&);

      template<typename _Arg>
 iterator
 _M_insert_unique_(const_iterator __pos, _Arg&& __x)
 {
   _Alloc_node __an(*this);
   return _M_insert_unique_(__pos, std::forward<_Arg>(__x), __an);
 }

      template<typename _Arg, typename _NodeGen>
 iterator
 _M_insert_equal_(const_iterator __pos, _Arg&& __x, _NodeGen&);

      template<typename _Arg>
 iterator
 _M_insert_equal_(const_iterator __pos, _Arg&& __x)
 {
   _Alloc_node __an(*this);
   return _M_insert_equal_(__pos, std::forward<_Arg>(__x), __an);
 }

      template<typename... _Args>
 pair<iterator, bool>
 _M_emplace_unique(_Args&&... __args);

      template<typename... _Args>
 iterator
 _M_emplace_equal(_Args&&... __args);

      template<typename... _Args>
 iterator
 _M_emplace_hint_unique(const_iterator __pos, _Args&&... __args);

      template<typename... _Args>
 iterator
 _M_emplace_hint_equal(const_iterator __pos, _Args&&... __args);

      template<typename _Iter>
 using __same_value_type
   = is_same<value_type, typename iterator_traits<_Iter>::value_type>;

      template<typename _InputIterator>
 __enable_if_t<__same_value_type<_InputIterator>::value>
 _M_insert_range_unique(_InputIterator __first, _InputIterator __last)
 {
   _Alloc_node __an(*this);
   for (; __first != __last; ++__first)
     _M_insert_unique_(end(), *__first, __an);
 }

      template<typename _InputIterator>
 __enable_if_t<!__same_value_type<_InputIterator>::value>
 _M_insert_range_unique(_InputIterator __first, _InputIterator __last)
 {
   for (; __first != __last; ++__first)
     _M_emplace_unique(*__first);
 }

      template<typename _InputIterator>
 __enable_if_t<__same_value_type<_InputIterator>::value>
 _M_insert_range_equal(_InputIterator __first, _InputIterator __last)
 {
   _Alloc_node __an(*this);
   for (; __first != __last; ++__first)
     _M_insert_equal_(end(), *__first, __an);
 }

      template<typename _InputIterator>
 __enable_if_t<!__same_value_type<_InputIterator>::value>
 _M_insert_range_equal(_InputIterator __first, _InputIterator __last)
 {
   for (; __first != __last; ++__first)
     _M_emplace_equal(*__first);
 }
# 1176 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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)
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__position != end()), false)) std::__glibcxx_assert_fail(); } while (false);
 const_iterator __result = __position;
 ++__result;
 _M_erase_aux(__position);
 return __result._M_const_cast();
      }


      __attribute ((__abi_tag__ ("cxx11")))
      iterator
      erase(iterator __position)
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__position != end()), false)) std::__glibcxx_assert_fail(); } while (false);
 iterator __result = __position;
 ++__result;
 _M_erase_aux(__position);
 return __result;
      }
# 1225 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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();
      }
# 1248 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_tree.h" 3
      void
      clear() noexcept
      {
 _M_erase(_M_begin());
 _M_impl._M_reset();
      }


      iterator
      find(const key_type& __k);

      const_iterator
      find(const key_type& __k) const;

      size_type
      count(const key_type& __k) const;

      iterator
      lower_bound(const key_type& __k)
      { return _M_lower_bound(_M_begin(), _M_end(), __k); }

      const_iterator
      lower_bound(const key_type& __k) const
      { return _M_lower_bound(_M_begin(), _M_end(), __k); }

      iterator
      upper_bound(const key_type& __k)
      { return _M_upper_bound(_M_begin(), _M_end(), __k); }

      const_iterator
      upper_bound(const key_type& __k) const
      { return _M_upper_bound(_M_begin(), _M_end(), __k); }

      pair<iterator, iterator>
      equal_range(const key_type& __k);

      pair<const_iterator, const_iterator>
      equal_range(const key_type& __k) const;


      template<typename _Kt,
        typename _Req = __has_is_transparent_t<_Compare, _Kt>>
 iterator
 _M_find_tr(const _Kt& __k)
 {
   const _Rb_tree* __const_this = this;
   return __const_this->_M_find_tr(__k)._M_const_cast();
 }

      template<typename _Kt,
        typename _Req = __has_is_transparent_t<_Compare, _Kt>>
 const_iterator
 _M_find_tr(const _Kt& __k) const
 {
   auto __j = _M_lower_bound_tr(__k);
   if (__j != end() && _M_impl._M_key_compare(__k, _S_key(__j._M_node)))
     __j = end();
   return __j;
 }

      template<typename _Kt,
        typename _Req = __has_is_transparent_t<_Compare, _Kt>>
 size_type
 _M_count_tr(const _Kt& __k) const
 {
   auto __p = _M_equal_range_tr(__k);
   return std::distance(__p.first, __p.second);
 }

      template<typename _Kt,
        typename _Req = __has_is_transparent_t<_Compare, _Kt>>
 iterator
 _M_lower_bound_tr(const _Kt& __k)
 {
   const _Rb_tree* __const_this = this;
   return __const_this->_M_lower_bound_tr(__k)._M_const_cast();
 }

      template<typename _Kt,
        typename _Req = __has_is_transparent_t<_Compare, _Kt>>
 const_iterator
 _M_lower_bound_tr(const _Kt& __k) const
 {
   auto __x = _M_begin();
   auto __y = _M_end();
   while (__x != 0)
     if (!_M_impl._M_key_compare(_S_key(__x), __k))
       {
  __y = __x;
  __x = _S_left(__x);
       }
     else
       __x = _S_right(__x);
   return const_iterator(__y);
 }

      template<typename _Kt,
        typename _Req = __has_is_transparent_t<_Compare, _Kt>>
 iterator
 _M_upper_bound_tr(const _Kt& __k)
 {
   const _Rb_tree* __const_this = this;
   return __const_this->_M_upper_bound_tr(__k)._M_const_cast();
 }

      template<typename _Kt,
        typename _Req = __has_is_transparent_t<_Compare, _Kt>>
 const_iterator
 _M_upper_bound_tr(const _Kt& __k) const
 {
   auto __x = _M_begin();
   auto __y = _M_end();
   while (__x != 0)
     if (_M_impl._M_key_compare(__k, _S_key(__x)))
       {
  __y = __x;
  __x = _S_left(__x);
       }
     else
       __x = _S_right(__x);
   return const_iterator(__y);
 }

      template<typename _Kt,
        typename _Req = __has_is_transparent_t<_Compare, _Kt>>
 pair<iterator, iterator>
 _M_equal_range_tr(const _Kt& __k)
 {
   const _Rb_tree* __const_this = this;
   auto __ret = __const_this->_M_equal_range_tr(__k);
   return { __ret.first._M_const_cast(), __ret.second._M_const_cast() };
 }

      template<typename _Kt,
        typename _Req = __has_is_transparent_t<_Compare, _Kt>>
 pair<const_iterator, const_iterator>
 _M_equal_range_tr(const _Kt& __k) const
 {
   auto __low = _M_lower_bound_tr(__k);
   auto __high = __low;
   auto& __cmp = _M_impl._M_key_compare;
   while (__high != end() && !__cmp(__k, _S_key(__high._M_node)))
     ++__high;
   return { __low, __high };
 }



      bool
      __rb_verify() const;


      _Rb_tree&
      operator=(_Rb_tree&&)
      noexcept(_Alloc_traits::_S_nothrow_move()
        && is_nothrow_move_assignable<_Compare>::value);

      template<typename _Iterator>
 void
 _M_assign_unique(_Iterator, _Iterator);

      template<typename _Iterator>
 void
 _M_assign_equal(_Iterator, _Iterator);

    private:

      void
      _M_move_data(_Rb_tree& __x, true_type)
      { _M_impl._M_move_data(__x._M_impl); }



      void
      _M_move_data(_Rb_tree&, false_type);


      void
      _M_move_assign(_Rb_tree&, true_type);



      void
      _M_move_assign(_Rb_tree&, false_type);



    public:

      insert_return_type
      _M_reinsert_node_unique(node_type&& __nh)
      {
 insert_return_type __ret;
 if (__nh.empty())
   __ret.position = end();
 else
   {
     do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(_M_get_Node_allocator() == *__nh._M_alloc), false)) std::__glibcxx_assert_fail(); } while (false);

     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.release();
  __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
   {
     do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(_M_get_Node_allocator() == *__nh._M_alloc), false)) std::__glibcxx_assert_fail(); } while (false);
     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.release();
   }
 return __ret;
      }


      iterator
      _M_reinsert_node_hint_unique(const_iterator __hint, node_type&& __nh)
      {
 iterator __ret;
 if (__nh.empty())
   __ret = end();
 else
   {
     do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(_M_get_Node_allocator() == *__nh._M_alloc), false)) std::__glibcxx_assert_fail(); } while (false);
     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.release();
       }
     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
   {
     do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(_M_get_Node_allocator() == *__nh._M_alloc), false)) std::__glibcxx_assert_fail(); } while (false);
     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.release();
   }
 return __ret;
      }


      node_type
      extract(const_iterator __pos)
      {
 auto __ptr = _Rb_tree_rebalance_for_erase(
     __pos._M_const_cast()._M_node, _M_impl._M_header);
 --_M_impl._M_node_count;
 return { static_cast<_Link_type>(__ptr), _M_get_Node_allocator() };
      }


      node_type
      extract(const key_type& __k)
      {
 node_type __nh;
 auto __pos = find(__k);
 if (__pos != end())
   __nh = extract(const_iterator(__pos));
 return __nh;
      }

      template<typename _Compare2>
 using _Compatible_tree
   = _Rb_tree<_Key, _Val, _KeyOfValue, _Compare2, _Alloc>;

      template<typename, typename>
 friend struct _Rb_tree_merge_helper;


      template<typename _Compare2>
 void
 _M_merge_unique(_Compatible_tree<_Compare2>& __src) noexcept
 {
   using _Merge_helper = _Rb_tree_merge_helper<_Rb_tree, _Compare2>;
   for (auto __i = __src.begin(), __end = __src.end(); __i != __end;)
     {
       auto __pos = __i++;
       auto __res = _M_get_insert_unique_pos(_KeyOfValue()(*__pos));
       if (__res.second)
  {
    auto& __src_impl = _Merge_helper::_S_get_impl(__src);
    auto __ptr = _Rb_tree_rebalance_for_erase(
        __pos._M_node, __src_impl._M_header);
    --__src_impl._M_node_count;
    _M_insert_node(__res.first, __res.second,
     static_cast<_Link_type>(__ptr));
  }
     }
 }


      template<typename _Compare2>
 void
 _M_merge_equal(_Compatible_tree<_Compare2>& __src) noexcept
 {
   using _Merge_helper = _Rb_tree_merge_helper<_Rb_tree, _Compare2>;
   for (auto __i = __src.begin(), __end = __src.end(); __i != __end;)
     {
       auto __pos = __i++;
       auto __res = _M_get_insert_equal_pos(_KeyOfValue()(*__pos));
       if (__res.second)
  {
    auto& __src_impl = _Merge_helper::_S_get_impl(__src);
    auto __ptr = _Rb_tree_rebalance_for_erase(
        __pos._M_node, __src_impl._M_header);
    --__src_impl._M_node_count;
    _M_insert_node(__res.first, __res.second,
     static_cast<_Link_type>(__ptr));
  }
     }
 }


      friend bool
      operator==(const _Rb_tree& __x, const _Rb_tree& __y)
      {
 return __x.size() == __y.size()
   && std::equal(__x.begin(), __x.end(), __y.begin());
      }


      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);
      }
# 1625 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_tree.h" 3
    private:


      struct _Auto_node
      {
 template<typename... _Args>
   _Auto_node(_Rb_tree& __t, _Args&&... __args)
   : _M_t(__t),
     _M_node(__t._M_create_node(std::forward<_Args>(__args)...))
   { }

 ~_Auto_node()
 {
   if (_M_node)
     _M_t._M_drop_node(_M_node);
 }

 _Auto_node(_Auto_node&& __n)
 : _M_t(__n._M_t), _M_node(__n._M_node)
 { __n._M_node = nullptr; }

 const _Key&
 _M_key() const
 { return _S_key(_M_node); }

 iterator
 _M_insert(pair<_Base_ptr, _Base_ptr> __p)
 {
   auto __it = _M_t._M_insert_node(__p.first, __p.second, _M_node);
   _M_node = nullptr;
   return __it;
 }

 iterator
 _M_insert_equal_lower()
 {
   auto __it = _M_t._M_insert_equal_lower_node(_M_node);
   _M_node = nullptr;
   return __it;
 }

 _Rb_tree& _M_t;
 _Link_type _M_node;
      };

    };

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    inline void
    swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x,
  _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y)
    { __x.swap(__y); }


  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    void
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_move_data(_Rb_tree& __x, false_type)
    {
      if (_M_get_Node_allocator() == __x._M_get_Node_allocator())
 _M_move_data(__x, true_type());
      else
 {
   constexpr bool __move = !__move_if_noexcept_cond<value_type>::value;
   _Alloc_node __an(*this);
   _M_root() = _M_copy<__move>(__x, __an);
   if constexpr (__move)
     __x.clear();
 }
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    inline void
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_move_assign(_Rb_tree& __x, true_type)
    {
      clear();
      if (__x._M_root() != nullptr)
 _M_move_data(__x, true_type());
      std::__alloc_on_move(_M_get_Node_allocator(),
      __x._M_get_Node_allocator());
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    void
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_move_assign(_Rb_tree& __x, false_type)
    {
      if (_M_get_Node_allocator() == __x._M_get_Node_allocator())
 return _M_move_assign(__x, true_type{});



      _Reuse_or_alloc_node __roan(*this);
      _M_impl._M_reset();
      if (__x._M_root() != nullptr)
 {
   _M_root() = _M_copy<__as_rvalue>(__x, __roan);
   __x.clear();
 }
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    inline _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>&
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    operator=(_Rb_tree&& __x)
    noexcept(_Alloc_traits::_S_nothrow_move()
      && is_nothrow_move_assignable<_Compare>::value)
    {
      _M_impl._M_key_compare = std::move(__x._M_impl._M_key_compare);
      _M_move_assign(__x, __bool_constant<_Alloc_traits::_S_nothrow_move()>());
      return *this;
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    template<typename _Iterator>
      void
      _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
      _M_assign_unique(_Iterator __first, _Iterator __last)
      {
 _Reuse_or_alloc_node __roan(*this);
 _M_impl._M_reset();
 for (; __first != __last; ++__first)
   _M_insert_unique_(end(), *__first, __roan);
      }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    template<typename _Iterator>
      void
      _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
      _M_assign_equal(_Iterator __first, _Iterator __last)
      {
 _Reuse_or_alloc_node __roan(*this);
 _M_impl._M_reset();
 for (; __first != __last; ++__first)
   _M_insert_equal_(end(), *__first, __roan);
      }


  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>&
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    operator=(const _Rb_tree& __x)
    {
      if (this != std::__addressof(__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<__as_lvalue>(__x, __roan);
 }

      return *this;
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>

    template<typename _Arg, typename _NodeGen>



      typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
      _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
      _M_insert_(_Base_ptr __x, _Base_ptr __p,

   _Arg&& __v,



   _NodeGen& __node_gen)
      {
 bool __insert_left = (__x != 0 || __p == _M_end()
         || _M_impl._M_key_compare(_KeyOfValue()(__v),
       _S_key(__p)));

 _Link_type __z = __node_gen(std::forward<_Arg>(__v));

 _Rb_tree_insert_and_rebalance(__insert_left, __z, __p,
          this->_M_impl._M_header);
 ++_M_impl._M_node_count;
 return iterator(__z);
      }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>

    template<typename _Arg>

    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::

    _M_insert_lower(_Base_ptr __p, _Arg&& __v)



    {
      bool __insert_left = (__p == _M_end()
       || !_M_impl._M_key_compare(_S_key(__p),
             _KeyOfValue()(__v)));

      _Link_type __z = _M_create_node(std::forward<_Arg>(__v));

      _Rb_tree_insert_and_rebalance(__insert_left, __z, __p,
        this->_M_impl._M_header);
      ++_M_impl._M_node_count;
      return iterator(__z);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>

    template<typename _Arg>

    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::

    _M_insert_equal_lower(_Arg&& __v)



    {
      _Link_type __x = _M_begin();
      _Base_ptr __y = _M_end();
      while (__x != 0)
 {
   __y = __x;
   __x = !_M_impl._M_key_compare(_S_key(__x), _KeyOfValue()(__v)) ?
  _S_left(__x) : _S_right(__x);
 }
      return _M_insert_lower(__y, std::forward<_Arg>(__v));
    }

  template<typename _Key, typename _Val, typename _KoV,
    typename _Compare, typename _Alloc>
    template<bool _MoveValues, typename _NodeGen>
      typename _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::_Link_type
      _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::
      _M_copy(_Link_type __x, _Base_ptr __p, _NodeGen& __node_gen)
      {

 _Link_type __top = _M_clone_node<_MoveValues>(__x, __node_gen);
 __top->_M_parent = __p;

 try
   {
     if (__x->_M_right)
       __top->_M_right =
  _M_copy<_MoveValues>(_S_right(__x), __top, __node_gen);
     __p = __top;
     __x = _S_left(__x);

     while (__x != 0)
       {
  _Link_type __y = _M_clone_node<_MoveValues>(__x, __node_gen);
  __p->_M_left = __y;
  __y->_M_parent = __p;
  if (__x->_M_right)
    __y->_M_right = _M_copy<_MoveValues>(_S_right(__x),
             __y, __node_gen);
  __p = __y;
  __x = _S_left(__x);
       }
   }
 catch(...)
   {
     _M_erase(__top);
     throw;
   }
 return __top;
      }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    void
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_erase(_Link_type __x)
    {

      while (__x != 0)
 {
   _M_erase(_S_right(__x));
   _Link_type __y = _S_left(__x);
   _M_drop_node(__x);
   __x = __y;
 }
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key, _Val, _KeyOfValue,
        _Compare, _Alloc>::iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_lower_bound(_Link_type __x, _Base_ptr __y,
     const _Key& __k)
    {
      while (__x != 0)
 if (!_M_impl._M_key_compare(_S_key(__x), __k))
   __y = __x, __x = _S_left(__x);
 else
   __x = _S_right(__x);
      return iterator(__y);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key, _Val, _KeyOfValue,
        _Compare, _Alloc>::const_iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_lower_bound(_Const_Link_type __x, _Const_Base_ptr __y,
     const _Key& __k) const
    {
      while (__x != 0)
 if (!_M_impl._M_key_compare(_S_key(__x), __k))
   __y = __x, __x = _S_left(__x);
 else
   __x = _S_right(__x);
      return const_iterator(__y);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key, _Val, _KeyOfValue,
        _Compare, _Alloc>::iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_upper_bound(_Link_type __x, _Base_ptr __y,
     const _Key& __k)
    {
      while (__x != 0)
 if (_M_impl._M_key_compare(__k, _S_key(__x)))
   __y = __x, __x = _S_left(__x);
 else
   __x = _S_right(__x);
      return iterator(__y);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key, _Val, _KeyOfValue,
        _Compare, _Alloc>::const_iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_upper_bound(_Const_Link_type __x, _Const_Base_ptr __y,
     const _Key& __k) const
    {
      while (__x != 0)
 if (_M_impl._M_key_compare(__k, _S_key(__x)))
   __y = __x, __x = _S_left(__x);
 else
   __x = _S_right(__x);
      return const_iterator(__y);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
      _Compare, _Alloc>::iterator,
  typename _Rb_tree<_Key, _Val, _KeyOfValue,
      _Compare, _Alloc>::iterator>
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    equal_range(const _Key& __k)
    {
      _Link_type __x = _M_begin();
      _Base_ptr __y = _M_end();
      while (__x != 0)
 {
   if (_M_impl._M_key_compare(_S_key(__x), __k))
     __x = _S_right(__x);
   else if (_M_impl._M_key_compare(__k, _S_key(__x)))
     __y = __x, __x = _S_left(__x);
   else
     {
       _Link_type __xu(__x);
       _Base_ptr __yu(__y);
       __y = __x, __x = _S_left(__x);
       __xu = _S_right(__xu);
       return pair<iterator,
     iterator>(_M_lower_bound(__x, __y, __k),
        _M_upper_bound(__xu, __yu, __k));
     }
 }
      return pair<iterator, iterator>(iterator(__y),
          iterator(__y));
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
      _Compare, _Alloc>::const_iterator,
  typename _Rb_tree<_Key, _Val, _KeyOfValue,
      _Compare, _Alloc>::const_iterator>
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    equal_range(const _Key& __k) const
    {
      _Const_Link_type __x = _M_begin();
      _Const_Base_ptr __y = _M_end();
      while (__x != 0)
 {
   if (_M_impl._M_key_compare(_S_key(__x), __k))
     __x = _S_right(__x);
   else if (_M_impl._M_key_compare(__k, _S_key(__x)))
     __y = __x, __x = _S_left(__x);
   else
     {
       _Const_Link_type __xu(__x);
       _Const_Base_ptr __yu(__y);
       __y = __x, __x = _S_left(__x);
       __xu = _S_right(__xu);
       return pair<const_iterator,
     const_iterator>(_M_lower_bound(__x, __y, __k),
       _M_upper_bound(__xu, __yu, __k));
     }
 }
      return pair<const_iterator, const_iterator>(const_iterator(__y),
        const_iterator(__y));
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    void
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    swap(_Rb_tree& __t)
    noexcept(__is_nothrow_swappable<_Compare>::value)
    {
      if (_M_root() == 0)
 {
   if (__t._M_root() != 0)
     _M_impl._M_move_data(__t._M_impl);
 }
      else if (__t._M_root() == 0)
 __t._M_impl._M_move_data(_M_impl);
      else
 {
   std::swap(_M_root(),__t._M_root());
   std::swap(_M_leftmost(),__t._M_leftmost());
   std::swap(_M_rightmost(),__t._M_rightmost());

   _M_root()->_M_parent = _M_end();
   __t._M_root()->_M_parent = __t._M_end();
   std::swap(this->_M_impl._M_node_count, __t._M_impl._M_node_count);
 }

      std::swap(this->_M_impl._M_key_compare, __t._M_impl._M_key_compare);

      _Alloc_traits::_S_on_swap(_M_get_Node_allocator(),
    __t._M_get_Node_allocator());
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
      _Compare, _Alloc>::_Base_ptr,
  typename _Rb_tree<_Key, _Val, _KeyOfValue,
      _Compare, _Alloc>::_Base_ptr>
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_get_insert_unique_pos(const key_type& __k)
    {
      typedef pair<_Base_ptr, _Base_ptr> _Res;
      _Link_type __x = _M_begin();
      _Base_ptr __y = _M_end();
      bool __comp = true;
      while (__x != 0)
 {
   __y = __x;
   __comp = _M_impl._M_key_compare(__k, _S_key(__x));
   __x = __comp ? _S_left(__x) : _S_right(__x);
 }
      iterator __j = iterator(__y);
      if (__comp)
 {
   if (__j == begin())
     return _Res(__x, __y);
   else
     --__j;
 }
      if (_M_impl._M_key_compare(_S_key(__j._M_node), __k))
 return _Res(__x, __y);
      return _Res(__j._M_node, 0);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
      _Compare, _Alloc>::_Base_ptr,
  typename _Rb_tree<_Key, _Val, _KeyOfValue,
      _Compare, _Alloc>::_Base_ptr>
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_get_insert_equal_pos(const key_type& __k)
    {
      typedef pair<_Base_ptr, _Base_ptr> _Res;
      _Link_type __x = _M_begin();
      _Base_ptr __y = _M_end();
      while (__x != 0)
 {
   __y = __x;
   __x = _M_impl._M_key_compare(__k, _S_key(__x)) ?
  _S_left(__x) : _S_right(__x);
 }
      return _Res(__x, __y);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>

    template<typename _Arg>

    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
      _Compare, _Alloc>::iterator, bool>
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::

    _M_insert_unique(_Arg&& __v)



    {
      typedef pair<iterator, bool> _Res;
      pair<_Base_ptr, _Base_ptr> __res
 = _M_get_insert_unique_pos(_KeyOfValue()(__v));

      if (__res.second)
 {
   _Alloc_node __an(*this);
   return _Res(_M_insert_(__res.first, __res.second,
     std::forward<_Arg>(__v), __an),
        true);
 }

      return _Res(iterator(__res.first), false);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>

    template<typename _Arg>

    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::

    _M_insert_equal(_Arg&& __v)



    {
      pair<_Base_ptr, _Base_ptr> __res
 = _M_get_insert_equal_pos(_KeyOfValue()(__v));
      _Alloc_node __an(*this);
      return _M_insert_(__res.first, __res.second,
   std::forward<_Arg>(__v), __an);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
      _Compare, _Alloc>::_Base_ptr,
  typename _Rb_tree<_Key, _Val, _KeyOfValue,
      _Compare, _Alloc>::_Base_ptr>
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_get_insert_hint_unique_pos(const_iterator __position,
      const key_type& __k)
    {
      iterator __pos = __position._M_const_cast();
      typedef pair<_Base_ptr, _Base_ptr> _Res;


      if (__pos._M_node == _M_end())
 {
   if (size() > 0
       && _M_impl._M_key_compare(_S_key(_M_rightmost()), __k))
     return _Res(0, _M_rightmost());
   else
     return _M_get_insert_unique_pos(__k);
 }
      else if (_M_impl._M_key_compare(__k, _S_key(__pos._M_node)))
 {

   iterator __before = __pos;
   if (__pos._M_node == _M_leftmost())
     return _Res(_M_leftmost(), _M_leftmost());
   else if (_M_impl._M_key_compare(_S_key((--__before)._M_node), __k))
     {
       if (_S_right(__before._M_node) == 0)
  return _Res(0, __before._M_node);
       else
  return _Res(__pos._M_node, __pos._M_node);
     }
   else
     return _M_get_insert_unique_pos(__k);
 }
      else if (_M_impl._M_key_compare(_S_key(__pos._M_node), __k))
 {

   iterator __after = __pos;
   if (__pos._M_node == _M_rightmost())
     return _Res(0, _M_rightmost());
   else if (_M_impl._M_key_compare(__k, _S_key((++__after)._M_node)))
     {
       if (_S_right(__pos._M_node) == 0)
  return _Res(0, __pos._M_node);
       else
  return _Res(__after._M_node, __after._M_node);
     }
   else
     return _M_get_insert_unique_pos(__k);
 }
      else

 return _Res(__pos._M_node, 0);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>

    template<typename _Arg, typename _NodeGen>



      typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
      _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
      _M_insert_unique_(const_iterator __position,

   _Arg&& __v,



   _NodeGen& __node_gen)
    {
      pair<_Base_ptr, _Base_ptr> __res
 = _M_get_insert_hint_unique_pos(__position, _KeyOfValue()(__v));

      if (__res.second)
 return _M_insert_(__res.first, __res.second,
     std::forward<_Arg>(__v),
     __node_gen);
      return iterator(__res.first);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
      _Compare, _Alloc>::_Base_ptr,
  typename _Rb_tree<_Key, _Val, _KeyOfValue,
      _Compare, _Alloc>::_Base_ptr>
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_get_insert_hint_equal_pos(const_iterator __position, const key_type& __k)
    {
      iterator __pos = __position._M_const_cast();
      typedef pair<_Base_ptr, _Base_ptr> _Res;


      if (__pos._M_node == _M_end())
 {
   if (size() > 0
       && !_M_impl._M_key_compare(__k, _S_key(_M_rightmost())))
     return _Res(0, _M_rightmost());
   else
     return _M_get_insert_equal_pos(__k);
 }
      else if (!_M_impl._M_key_compare(_S_key(__pos._M_node), __k))
 {

   iterator __before = __pos;
   if (__pos._M_node == _M_leftmost())
     return _Res(_M_leftmost(), _M_leftmost());
   else if (!_M_impl._M_key_compare(__k, _S_key((--__before)._M_node)))
     {
       if (_S_right(__before._M_node) == 0)
  return _Res(0, __before._M_node);
       else
  return _Res(__pos._M_node, __pos._M_node);
     }
   else
     return _M_get_insert_equal_pos(__k);
 }
      else
 {

   iterator __after = __pos;
   if (__pos._M_node == _M_rightmost())
     return _Res(0, _M_rightmost());
   else if (!_M_impl._M_key_compare(_S_key((++__after)._M_node), __k))
     {
       if (_S_right(__pos._M_node) == 0)
  return _Res(0, __pos._M_node);
       else
  return _Res(__after._M_node, __after._M_node);
     }
   else
     return _Res(0, 0);
 }
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>

    template<typename _Arg, typename _NodeGen>



      typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
      _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
      _M_insert_equal_(const_iterator __position,

         _Arg&& __v,



         _NodeGen& __node_gen)
      {
 pair<_Base_ptr, _Base_ptr> __res
   = _M_get_insert_hint_equal_pos(__position, _KeyOfValue()(__v));

 if (__res.second)
   return _M_insert_(__res.first, __res.second,
       std::forward<_Arg>(__v),
       __node_gen);

 return _M_insert_equal_lower(std::forward<_Arg>(__v));
      }


  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    auto
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_insert_node(_Base_ptr __x, _Base_ptr __p, _Link_type __z)
    -> iterator
    {
      bool __insert_left = (__x != 0 || __p == _M_end()
       || _M_impl._M_key_compare(_S_key(__z),
            _S_key(__p)));

      _Rb_tree_insert_and_rebalance(__insert_left, __z, __p,
        this->_M_impl._M_header);
      ++_M_impl._M_node_count;
      return iterator(__z);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    auto
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_insert_lower_node(_Base_ptr __p, _Link_type __z)
    -> iterator
    {
      bool __insert_left = (__p == _M_end()
       || !_M_impl._M_key_compare(_S_key(__p),
             _S_key(__z)));

      _Rb_tree_insert_and_rebalance(__insert_left, __z, __p,
        this->_M_impl._M_header);
      ++_M_impl._M_node_count;
      return iterator(__z);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    auto
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_insert_equal_lower_node(_Link_type __z)
    -> iterator
    {
      _Link_type __x = _M_begin();
      _Base_ptr __y = _M_end();
      while (__x != 0)
 {
   __y = __x;
   __x = !_M_impl._M_key_compare(_S_key(__x), _S_key(__z)) ?
  _S_left(__x) : _S_right(__x);
 }
      return _M_insert_lower_node(__y, __z);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    template<typename... _Args>
      auto
      _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
      _M_emplace_unique(_Args&&... __args)
      -> pair<iterator, bool>
      {
 _Auto_node __z(*this, std::forward<_Args>(__args)...);
 auto __res = _M_get_insert_unique_pos(__z._M_key());
 if (__res.second)
   return {__z._M_insert(__res), true};
 return {iterator(__res.first), false};
      }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    template<typename... _Args>
      auto
      _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
      _M_emplace_equal(_Args&&... __args)
      -> iterator
      {
 _Auto_node __z(*this, std::forward<_Args>(__args)...);
 auto __res = _M_get_insert_equal_pos(__z._M_key());
 return __z._M_insert(__res);
      }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    template<typename... _Args>
      auto
      _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
      _M_emplace_hint_unique(const_iterator __pos, _Args&&... __args)
      -> iterator
      {
 _Auto_node __z(*this, std::forward<_Args>(__args)...);
 auto __res = _M_get_insert_hint_unique_pos(__pos, __z._M_key());
 if (__res.second)
   return __z._M_insert(__res);
 return iterator(__res.first);
      }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    template<typename... _Args>
      auto
      _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
      _M_emplace_hint_equal(const_iterator __pos, _Args&&... __args)
      -> iterator
      {
 _Auto_node __z(*this, std::forward<_Args>(__args)...);
 auto __res = _M_get_insert_hint_equal_pos(__pos, __z._M_key());
 if (__res.second)
   return __z._M_insert(__res);
 return __z._M_insert_equal_lower();
      }



  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    void
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_erase_aux(const_iterator __position)
    {
      _Link_type __y =
 static_cast<_Link_type>(_Rb_tree_rebalance_for_erase
    (const_cast<_Base_ptr>(__position._M_node),
     this->_M_impl._M_header));
      _M_drop_node(__y);
      --_M_impl._M_node_count;
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    void
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    _M_erase_aux(const_iterator __first, const_iterator __last)
    {
      if (__first == begin() && __last == end())
 clear();
      else
 while (__first != __last)
   _M_erase_aux(__first++);
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::size_type
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    erase(const _Key& __x)
    {
      pair<iterator, iterator> __p = equal_range(__x);
      const size_type __old_size = size();
      _M_erase_aux(__p.first, __p.second);
      return __old_size - size();
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key, _Val, _KeyOfValue,
        _Compare, _Alloc>::iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    find(const _Key& __k)
    {
      iterator __j = _M_lower_bound(_M_begin(), _M_end(), __k);
      return (__j == end()
       || _M_impl._M_key_compare(__k,
     _S_key(__j._M_node))) ? end() : __j;
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key, _Val, _KeyOfValue,
        _Compare, _Alloc>::const_iterator
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    find(const _Key& __k) const
    {
      const_iterator __j = _M_lower_bound(_M_begin(), _M_end(), __k);
      return (__j == end()
       || _M_impl._M_key_compare(__k,
     _S_key(__j._M_node))) ? end() : __j;
    }

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::size_type
    _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
    count(const _Key& __k) const
    {
      pair<const_iterator, const_iterator> __p = equal_range(__k);
      const size_type __n = std::distance(__p.first, __p.second);
      return __n;
    }

  __attribute__ ((__pure__)) unsigned int
  _Rb_tree_black_count(const _Rb_tree_node_base* __node,
         const _Rb_tree_node_base* __root) throw ();

  template<typename _Key, typename _Val, typename _KeyOfValue,
    typename _Compare, typename _Alloc>
    bool
    _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::__rb_verify() const
    {
      if (_M_impl._M_node_count == 0 || begin() == end())
 return _M_impl._M_node_count == 0 && begin() == end()
        && this->_M_impl._M_header._M_left == _M_end()
        && this->_M_impl._M_header._M_right == _M_end();

      unsigned int __len = _Rb_tree_black_count(_M_leftmost(), _M_root());
      for (const_iterator __it = begin(); __it != end(); ++__it)
 {
   _Const_Link_type __x = static_cast<_Const_Link_type>(__it._M_node);
   _Const_Link_type __L = _S_left(__x);
   _Const_Link_type __R = _S_right(__x);

   if (__x->_M_color == _S_red)
     if ((__L && __L->_M_color == _S_red)
  || (__R && __R->_M_color == _S_red))
       return false;

   if (__L && _M_impl._M_key_compare(_S_key(__x), _S_key(__L)))
     return false;
   if (__R && _M_impl._M_key_compare(_S_key(__R), _S_key(__x)))
     return false;

   if (!__L && !__R && _Rb_tree_black_count(__x, _M_root()) != __len)
     return false;
 }

      if (_M_leftmost() != _Rb_tree_node_base::_S_minimum(_M_root()))
 return false;
      if (_M_rightmost() != _Rb_tree_node_base::_S_maximum(_M_root()))
 return false;
      return true;
    }



  template<typename _Key, typename _Val, typename _Sel, typename _Cmp1,
    typename _Alloc, typename _Cmp2>
    struct _Rb_tree_merge_helper<_Rb_tree<_Key, _Val, _Sel, _Cmp1, _Alloc>,
     _Cmp2>
    {
    private:
      friend class _Rb_tree<_Key, _Val, _Sel, _Cmp1, _Alloc>;

      static auto&
      _S_get_impl(_Rb_tree<_Key, _Val, _Sel, _Cmp2, _Alloc>& __tree)
      { return __tree._M_impl; }
    };



}
# 63 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/set" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_set.h" 1 3
# 64 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_set.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{



  template<typename _Key, typename _Compare, typename _Alloc>
    class multiset;
# 94 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_set.h" 3
  template<typename _Key, typename _Compare = std::less<_Key>,
    typename _Alloc = std::allocator<_Key> >
    class set
    {
# 110 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_set.h" 3
      static_assert(is_same<typename remove_cv<_Key>::type, _Key>::value,
   "std::set must have a non-const, non-volatile value_type");

      static_assert(is_same<typename _Alloc::value_type, _Key>::value,
   "std::set must have the same value_type as its allocator");



    public:



      typedef _Key key_type;
      typedef _Key value_type;
      typedef _Compare key_compare;
      typedef _Compare value_compare;
      typedef _Alloc allocator_type;


    private:
      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
 rebind<_Key>::other _Key_alloc_type;

      typedef _Rb_tree<key_type, value_type, _Identity<value_type>,
         key_compare, _Key_alloc_type> _Rep_type;
      _Rep_type _M_t;

      typedef __gnu_cxx::__alloc_traits<_Key_alloc_type> _Alloc_traits;

    public:


      typedef typename _Alloc_traits::pointer pointer;
      typedef typename _Alloc_traits::const_pointer const_pointer;
      typedef typename _Alloc_traits::reference reference;
      typedef typename _Alloc_traits::const_reference const_reference;



      typedef typename _Rep_type::const_iterator iterator;
      typedef typename _Rep_type::const_iterator const_iterator;
      typedef typename _Rep_type::const_reverse_iterator reverse_iterator;
      typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
      typedef typename _Rep_type::size_type size_type;
      typedef typename _Rep_type::difference_type difference_type;



      using node_type = typename _Rep_type::node_type;
      using insert_return_type = typename _Rep_type::insert_return_type;
# 169 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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)) { }
# 192 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_set.h" 3
      template<typename _InputIterator>
 set(_InputIterator __first, _InputIterator __last)
 : _M_t()
 { _M_t._M_insert_range_unique(__first, __last); }
# 209 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_set.h" 3
      template<typename _InputIterator>
 set(_InputIterator __first, _InputIterator __last,
     const _Compare& __comp,
     const allocator_type& __a = allocator_type())
 : _M_t(__comp, _Key_alloc_type(__a))
 { _M_t._M_insert_range_unique(__first, __last); }
# 225 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_set.h" 3
      set(const set&) = default;







      set(set&&) = default;
# 245 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_set.h" 3
      set(initializer_list<value_type> __l,
   const _Compare& __comp = _Compare(),
   const allocator_type& __a = allocator_type())
      : _M_t(__comp, _Key_alloc_type(__a))
      { _M_t._M_insert_range_unique(__l.begin(), __l.end()); }


      explicit
      set(const allocator_type& __a)
      : _M_t(_Key_alloc_type(__a)) { }


      set(const set& __x, const __type_identity_t<allocator_type>& __a)
      : _M_t(__x._M_t, _Key_alloc_type(__a)) { }


      set(set&& __x, const __type_identity_t<allocator_type>& __a)
      noexcept(is_nothrow_copy_constructible<_Compare>::value
        && _Alloc_traits::_S_always_equal())
      : _M_t(std::move(__x._M_t), _Key_alloc_type(__a)) { }


      set(initializer_list<value_type> __l, const allocator_type& __a)
      : _M_t(_Key_alloc_type(__a))
      { _M_t._M_insert_range_unique(__l.begin(), __l.end()); }


      template<typename _InputIterator>
 set(_InputIterator __first, _InputIterator __last,
     const allocator_type& __a)
 : _M_t(_Key_alloc_type(__a))
 { _M_t._M_insert_range_unique(__first, __last); }






      ~set() = default;
# 299 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_set.h" 3
      set&
      operator=(const set&) = default;


      set&
      operator=(set&&) = default;
# 317 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_set.h" 3
      set&
      operator=(initializer_list<value_type> __l)
      {
 _M_t._M_assign_unique(__l.begin(), __l.end());
 return *this;
      }





      key_compare
      key_comp() const
      { return _M_t.key_comp(); }

      value_compare
      value_comp() const
      { return _M_t.key_comp(); }

      allocator_type
      get_allocator() const noexcept
      { return allocator_type(_M_t.get_allocator()); }






      iterator
      begin() const noexcept
      { return _M_t.begin(); }






      iterator
      end() const noexcept
      { return _M_t.end(); }






      reverse_iterator
      rbegin() const noexcept
      { return _M_t.rbegin(); }






      reverse_iterator
      rend() const noexcept
      { return _M_t.rend(); }







      iterator
      cbegin() const noexcept
      { return _M_t.begin(); }






      iterator
      cend() const noexcept
      { return _M_t.end(); }






      reverse_iterator
      crbegin() const noexcept
      { return _M_t.rbegin(); }






      reverse_iterator
      crend() const noexcept
      { return _M_t.rend(); }



      [[__nodiscard__]] bool
      empty() const noexcept
      { return _M_t.empty(); }


      size_type
      size() const noexcept
      { return _M_t.size(); }


      size_type
      max_size() const noexcept
      { return _M_t.max_size(); }
# 442 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_set.h" 3
      void
      swap(set& __x)
      noexcept(__is_nothrow_swappable<_Compare>::value)
      { _M_t.swap(__x._M_t); }
# 462 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_set.h" 3
      template<typename... _Args>
 std::pair<iterator, bool>
 emplace(_Args&&... __args)
 { return _M_t._M_emplace_unique(std::forward<_Args>(__args)...); }
# 488 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_set.h" 3
      template<typename... _Args>
 iterator
 emplace_hint(const_iterator __pos, _Args&&... __args)
 {
   return _M_t._M_emplace_hint_unique(__pos,
          std::forward<_Args>(__args)...);
 }
# 510 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_set.h" 3
      std::pair<iterator, bool>
      insert(const value_type& __x)
      {
 std::pair<typename _Rep_type::iterator, bool> __p =
   _M_t._M_insert_unique(__x);
 return std::pair<iterator, bool>(__p.first, __p.second);
      }


      std::pair<iterator, bool>
      insert(value_type&& __x)
      {
 std::pair<typename _Rep_type::iterator, bool> __p =
   _M_t._M_insert_unique(std::move(__x));
 return std::pair<iterator, bool>(__p.first, __p.second);
      }
# 547 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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)); }
# 566 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_set.h" 3
      template<typename _InputIterator>
 void
 insert(_InputIterator __first, _InputIterator __last)
 { _M_t._M_insert_range_unique(__first, __last); }
# 579 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_set.h" 3
      void
      insert(initializer_list<value_type> __l)
      { this->insert(__l.begin(), __l.end()); }




      node_type
      extract(const_iterator __pos)
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__pos != end()), false)) std::__glibcxx_assert_fail(); } while (false);
 return _M_t.extract(__pos);
      }


      node_type
      extract(const key_type& __x)
      { return _M_t.extract(__x); }


      insert_return_type
      insert(node_type&& __nh)
      { return _M_t._M_reinsert_node_unique(std::move(__nh)); }


      iterator
      insert(const_iterator __hint, node_type&& __nh)
      { return _M_t._M_reinsert_node_hint_unique(__hint, std::move(__nh)); }

      template<typename, typename>
 friend struct std::_Rb_tree_merge_helper;

      template<typename _Compare1>
 void
 merge(set<_Key, _Compare1, _Alloc>& __source)
 {
   using _Merge_helper = _Rb_tree_merge_helper<set, _Compare1>;
   _M_t._M_merge_unique(_Merge_helper::_S_get_tree(__source));
 }

      template<typename _Compare1>
 void
 merge(set<_Key, _Compare1, _Alloc>&& __source)
 { merge(__source); }

      template<typename _Compare1>
 void
 merge(multiset<_Key, _Compare1, _Alloc>& __source)
 {
   using _Merge_helper = _Rb_tree_merge_helper<set, _Compare1>;
   _M_t._M_merge_unique(_Merge_helper::_S_get_tree(__source));
 }

      template<typename _Compare1>
 void
 merge(multiset<_Key, _Compare1, _Alloc>&& __source)
 { merge(__source); }
# 654 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_set.h" 3
      __attribute ((__abi_tag__ ("cxx11")))
      iterator
      erase(const_iterator __position)
      { return _M_t.erase(__position); }
# 685 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_set.h" 3
      size_type
      erase(const key_type& __x)
      { return _M_t.erase(__x); }
# 706 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_set.h" 3
      __attribute ((__abi_tag__ ("cxx11")))
      iterator
      erase(const_iterator __first, const_iterator __last)
      { return _M_t.erase(__first, __last); }
# 734 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_set.h" 3
      void
      clear() noexcept
      { _M_t.clear(); }
# 749 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_set.h" 3
      size_type
      count(const key_type& __x) const
      { return _M_t.find(__x) == _M_t.end() ? 0 : 1; }


      template<typename _Kt>
 auto
 count(const _Kt& __x) const
 -> decltype(_M_t._M_count_tr(__x))
 { return _M_t._M_count_tr(__x); }
# 769 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_set.h" 3
      bool
      contains(const key_type& __x) const
      { return _M_t.find(__x) != _M_t.end(); }

      template<typename _Kt>
 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(); }
# 795 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_set.h" 3
      iterator
      find(const key_type& __x)
      { return _M_t.find(__x); }

      const_iterator
      find(const key_type& __x) const
      { return _M_t.find(__x); }


      template<typename _Kt>
 auto
 find(const _Kt& __x)
 -> decltype(iterator{_M_t._M_find_tr(__x)})
 { return iterator{_M_t._M_find_tr(__x)}; }

      template<typename _Kt>
 auto
 find(const _Kt& __x) const
 -> decltype(const_iterator{_M_t._M_find_tr(__x)})
 { return const_iterator{_M_t._M_find_tr(__x)}; }
# 830 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_set.h" 3
      iterator
      lower_bound(const key_type& __x)
      { return _M_t.lower_bound(__x); }

      const_iterator
      lower_bound(const key_type& __x) const
      { return _M_t.lower_bound(__x); }


      template<typename _Kt>
 auto
 lower_bound(const _Kt& __x)
 -> decltype(iterator(_M_t._M_lower_bound_tr(__x)))
 { return iterator(_M_t._M_lower_bound_tr(__x)); }

      template<typename _Kt>
 auto
 lower_bound(const _Kt& __x) const
 -> decltype(const_iterator(_M_t._M_lower_bound_tr(__x)))
 { return const_iterator(_M_t._M_lower_bound_tr(__x)); }
# 860 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_set.h" 3
      iterator
      upper_bound(const key_type& __x)
      { return _M_t.upper_bound(__x); }

      const_iterator
      upper_bound(const key_type& __x) const
      { return _M_t.upper_bound(__x); }


      template<typename _Kt>
 auto
 upper_bound(const _Kt& __x)
 -> decltype(iterator(_M_t._M_upper_bound_tr(__x)))
 { return iterator(_M_t._M_upper_bound_tr(__x)); }

      template<typename _Kt>
 auto
 upper_bound(const _Kt& __x) const
 -> decltype(iterator(_M_t._M_upper_bound_tr(__x)))
 { return const_iterator(_M_t._M_upper_bound_tr(__x)); }
# 899 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_set.h" 3
      std::pair<iterator, iterator>
      equal_range(const key_type& __x)
      { return _M_t.equal_range(__x); }

      std::pair<const_iterator, const_iterator>
      equal_range(const key_type& __x) const
      { return _M_t.equal_range(__x); }


      template<typename _Kt>
 auto
 equal_range(const _Kt& __x)
 -> decltype(pair<iterator, iterator>(_M_t._M_equal_range_tr(__x)))
 { return pair<iterator, iterator>(_M_t._M_equal_range_tr(__x)); }

      template<typename _Kt>
 auto
 equal_range(const _Kt& __x) const
 -> decltype(pair<iterator, iterator>(_M_t._M_equal_range_tr(__x)))
 { return pair<iterator, iterator>(_M_t._M_equal_range_tr(__x)); }



      template<typename _K1, typename _C1, typename _A1>
 friend bool
 operator==(const set<_K1, _C1, _A1>&, const set<_K1, _C1, _A1>&);


      template<typename _K1, typename _C1, typename _A1>
 friend __detail::__synth3way_t<_K1>
 operator<=>(const set<_K1, _C1, _A1>&, const set<_K1, _C1, _A1>&);





    };



  template<typename _InputIterator,
    typename _Compare =
      less<typename iterator_traits<_InputIterator>::value_type>,
    typename _Allocator =
      allocator<typename iterator_traits<_InputIterator>::value_type>,
    typename = _RequireInputIter<_InputIterator>,
    typename = _RequireNotAllocator<_Compare>,
    typename = _RequireAllocator<_Allocator>>
    set(_InputIterator, _InputIterator,
 _Compare = _Compare(), _Allocator = _Allocator())
    -> set<typename iterator_traits<_InputIterator>::value_type,
   _Compare, _Allocator>;

  template<typename _Key, typename _Compare = less<_Key>,
    typename _Allocator = allocator<_Key>,
    typename = _RequireNotAllocator<_Compare>,
    typename = _RequireAllocator<_Allocator>>
    set(initializer_list<_Key>,
 _Compare = _Compare(), _Allocator = _Allocator())
    -> set<_Key, _Compare, _Allocator>;

  template<typename _InputIterator, typename _Allocator,
    typename = _RequireInputIter<_InputIterator>,
    typename = _RequireAllocator<_Allocator>>
    set(_InputIterator, _InputIterator, _Allocator)
    -> set<typename iterator_traits<_InputIterator>::value_type,
    less<typename iterator_traits<_InputIterator>::value_type>,
    _Allocator>;

  template<typename _Key, typename _Allocator,
    typename = _RequireAllocator<_Allocator>>
    set(initializer_list<_Key>, _Allocator)
    -> set<_Key, less<_Key>, _Allocator>;
# 985 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_set.h" 3
  template<typename _Key, typename _Compare, typename _Alloc>
    inline bool
    operator==(const set<_Key, _Compare, _Alloc>& __x,
        const set<_Key, _Compare, _Alloc>& __y)
    { return __x._M_t == __y._M_t; }
# 1006 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_set.h" 3
  template<typename _Key, typename _Compare, typename _Alloc>
    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; }
# 1059 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_set.h" 3
  template<typename _Key, typename _Compare, typename _Alloc>
    inline void
    swap(set<_Key, _Compare, _Alloc>& __x, set<_Key, _Compare, _Alloc>& __y)
    noexcept(noexcept(__x.swap(__y)))
    { __x.swap(__y); }





  template<typename _Val, typename _Cmp1, typename _Alloc, typename _Cmp2>
    struct
    _Rb_tree_merge_helper<std::set<_Val, _Cmp1, _Alloc>, _Cmp2>
    {
    private:
      friend class std::set<_Val, _Cmp1, _Alloc>;

      static auto&
      _S_get_tree(std::set<_Val, _Cmp2, _Alloc>& __set)
      { return __set._M_t; }

      static auto&
      _S_get_tree(std::multiset<_Val, _Cmp2, _Alloc>& __set)
      { return __set._M_t; }
    };



}
# 64 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/set" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multiset.h" 1 3
# 64 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multiset.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{



  template<typename _Key, typename _Compare, typename _Alloc>
    class set;
# 95 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multiset.h" 3
  template <typename _Key, typename _Compare = std::less<_Key>,
     typename _Alloc = std::allocator<_Key> >
    class multiset
    {
# 111 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multiset.h" 3
      static_assert(is_same<typename remove_cv<_Key>::type, _Key>::value,
   "std::multiset must have a non-const, non-volatile value_type");

      static_assert(is_same<typename _Alloc::value_type, _Key>::value,
   "std::multiset must have the same value_type as its allocator");



    public:

      typedef _Key key_type;
      typedef _Key value_type;
      typedef _Compare key_compare;
      typedef _Compare value_compare;
      typedef _Alloc allocator_type;

    private:

      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
 rebind<_Key>::other _Key_alloc_type;

      typedef _Rb_tree<key_type, value_type, _Identity<value_type>,
         key_compare, _Key_alloc_type> _Rep_type;

      _Rep_type _M_t;

      typedef __gnu_cxx::__alloc_traits<_Key_alloc_type> _Alloc_traits;

    public:
      typedef typename _Alloc_traits::pointer pointer;
      typedef typename _Alloc_traits::const_pointer const_pointer;
      typedef typename _Alloc_traits::reference reference;
      typedef typename _Alloc_traits::const_reference const_reference;



      typedef typename _Rep_type::const_iterator iterator;
      typedef typename _Rep_type::const_iterator const_iterator;
      typedef typename _Rep_type::const_reverse_iterator reverse_iterator;
      typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;
      typedef typename _Rep_type::size_type size_type;
      typedef typename _Rep_type::difference_type difference_type;


      using node_type = typename _Rep_type::node_type;
# 165 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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)) { }
# 187 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multiset.h" 3
      template<typename _InputIterator>
 multiset(_InputIterator __first, _InputIterator __last)
 : _M_t()
 { _M_t._M_insert_range_equal(__first, __last); }
# 203 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multiset.h" 3
      template<typename _InputIterator>
 multiset(_InputIterator __first, _InputIterator __last,
   const _Compare& __comp,
   const allocator_type& __a = allocator_type())
 : _M_t(__comp, _Key_alloc_type(__a))
 { _M_t._M_insert_range_equal(__first, __last); }
# 219 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multiset.h" 3
      multiset(const multiset&) = default;
# 228 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multiset.h" 3
      multiset(multiset&&) = default;
# 240 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multiset.h" 3
      multiset(initializer_list<value_type> __l,
        const _Compare& __comp = _Compare(),
        const allocator_type& __a = allocator_type())
      : _M_t(__comp, _Key_alloc_type(__a))
      { _M_t._M_insert_range_equal(__l.begin(), __l.end()); }


      explicit
      multiset(const allocator_type& __a)
      : _M_t(_Key_alloc_type(__a)) { }


      multiset(const multiset& __m,
        const __type_identity_t<allocator_type>& __a)
      : _M_t(__m._M_t, _Key_alloc_type(__a)) { }


      multiset(multiset&& __m, const __type_identity_t<allocator_type>& __a)
      noexcept(is_nothrow_copy_constructible<_Compare>::value
        && _Alloc_traits::_S_always_equal())
      : _M_t(std::move(__m._M_t), _Key_alloc_type(__a)) { }


      multiset(initializer_list<value_type> __l, const allocator_type& __a)
      : _M_t(_Key_alloc_type(__a))
      { _M_t._M_insert_range_equal(__l.begin(), __l.end()); }


      template<typename _InputIterator>
 multiset(_InputIterator __first, _InputIterator __last,
   const allocator_type& __a)
 : _M_t(_Key_alloc_type(__a))
 { _M_t._M_insert_range_equal(__first, __last); }






      ~multiset() = default;
# 295 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multiset.h" 3
      multiset&
      operator=(const multiset&) = default;


      multiset&
      operator=(multiset&&) = default;
# 313 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multiset.h" 3
      multiset&
      operator=(initializer_list<value_type> __l)
      {
 _M_t._M_assign_equal(__l.begin(), __l.end());
 return *this;
      }





      key_compare
      key_comp() const
      { return _M_t.key_comp(); }

      value_compare
      value_comp() const
      { return _M_t.key_comp(); }

      allocator_type
      get_allocator() const noexcept
      { return allocator_type(_M_t.get_allocator()); }






      iterator
      begin() const noexcept
      { return _M_t.begin(); }






      iterator
      end() const noexcept
      { return _M_t.end(); }






      reverse_iterator
      rbegin() const noexcept
      { return _M_t.rbegin(); }






      reverse_iterator
      rend() const noexcept
      { return _M_t.rend(); }







      iterator
      cbegin() const noexcept
      { return _M_t.begin(); }






      iterator
      cend() const noexcept
      { return _M_t.end(); }






      reverse_iterator
      crbegin() const noexcept
      { return _M_t.rbegin(); }






      reverse_iterator
      crend() const noexcept
      { return _M_t.rend(); }



      [[__nodiscard__]] bool
      empty() const noexcept
      { return _M_t.empty(); }


      size_type
      size() const noexcept
      { return _M_t.size(); }


      size_type
      max_size() const noexcept
      { return _M_t.max_size(); }
# 438 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multiset.h" 3
      void
      swap(multiset& __x)
      noexcept(__is_nothrow_swappable<_Compare>::value)
      { _M_t.swap(__x._M_t); }
# 457 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multiset.h" 3
      template<typename... _Args>
 iterator
 emplace(_Args&&... __args)
 { return _M_t._M_emplace_equal(std::forward<_Args>(__args)...); }
# 483 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multiset.h" 3
      template<typename... _Args>
 iterator
 emplace_hint(const_iterator __pos, _Args&&... __args)
 {
   return _M_t._M_emplace_hint_equal(__pos,
         std::forward<_Args>(__args)...);
 }
# 503 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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)); }
# 533 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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)); }
# 551 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multiset.h" 3
      template<typename _InputIterator>
 void
 insert(_InputIterator __first, _InputIterator __last)
 { _M_t._M_insert_range_equal(__first, __last); }
# 564 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multiset.h" 3
      void
      insert(initializer_list<value_type> __l)
      { this->insert(__l.begin(), __l.end()); }




      node_type
      extract(const_iterator __pos)
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__pos != end()), false)) std::__glibcxx_assert_fail(); } while (false);
 return _M_t.extract(__pos);
      }


      node_type
      extract(const key_type& __x)
      { return _M_t.extract(__x); }


      iterator
      insert(node_type&& __nh)
      { return _M_t._M_reinsert_node_equal(std::move(__nh)); }


      iterator
      insert(const_iterator __hint, node_type&& __nh)
      { return _M_t._M_reinsert_node_hint_equal(__hint, std::move(__nh)); }

      template<typename, typename>
 friend struct std::_Rb_tree_merge_helper;

      template<typename _Compare1>
 void
 merge(multiset<_Key, _Compare1, _Alloc>& __source)
 {
   using _Merge_helper = _Rb_tree_merge_helper<multiset, _Compare1>;
   _M_t._M_merge_equal(_Merge_helper::_S_get_tree(__source));
 }

      template<typename _Compare1>
 void
 merge(multiset<_Key, _Compare1, _Alloc>&& __source)
 { merge(__source); }

      template<typename _Compare1>
 void
 merge(set<_Key, _Compare1, _Alloc>& __source)
 {
   using _Merge_helper = _Rb_tree_merge_helper<multiset, _Compare1>;
   _M_t._M_merge_equal(_Merge_helper::_S_get_tree(__source));
 }

      template<typename _Compare1>
 void
 merge(set<_Key, _Compare1, _Alloc>&& __source)
 { merge(__source); }
# 639 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multiset.h" 3
      __attribute ((__abi_tag__ ("cxx11")))
      iterator
      erase(const_iterator __position)
      { return _M_t.erase(__position); }
# 670 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multiset.h" 3
      size_type
      erase(const key_type& __x)
      { return _M_t.erase(__x); }
# 691 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multiset.h" 3
      __attribute ((__abi_tag__ ("cxx11")))
      iterator
      erase(const_iterator __first, const_iterator __last)
      { return _M_t.erase(__first, __last); }
# 719 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multiset.h" 3
      void
      clear() noexcept
      { _M_t.clear(); }
# 731 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multiset.h" 3
      size_type
      count(const key_type& __x) const
      { return _M_t.count(__x); }


      template<typename _Kt>
 auto
 count(const _Kt& __x) const -> decltype(_M_t._M_count_tr(__x))
 { return _M_t._M_count_tr(__x); }
# 750 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multiset.h" 3
      bool
      contains(const key_type& __x) const
      { return _M_t.find(__x) != _M_t.end(); }

      template<typename _Kt>
 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(); }
# 776 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multiset.h" 3
      iterator
      find(const key_type& __x)
      { return _M_t.find(__x); }

      const_iterator
      find(const key_type& __x) const
      { return _M_t.find(__x); }


      template<typename _Kt>
 auto
 find(const _Kt& __x)
 -> decltype(iterator{_M_t._M_find_tr(__x)})
 { return iterator{_M_t._M_find_tr(__x)}; }

      template<typename _Kt>
 auto
 find(const _Kt& __x) const
 -> decltype(const_iterator{_M_t._M_find_tr(__x)})
 { return const_iterator{_M_t._M_find_tr(__x)}; }
# 811 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multiset.h" 3
      iterator
      lower_bound(const key_type& __x)
      { return _M_t.lower_bound(__x); }

      const_iterator
      lower_bound(const key_type& __x) const
      { return _M_t.lower_bound(__x); }


      template<typename _Kt>
 auto
 lower_bound(const _Kt& __x)
 -> decltype(iterator(_M_t._M_lower_bound_tr(__x)))
 { return iterator(_M_t._M_lower_bound_tr(__x)); }

      template<typename _Kt>
 auto
 lower_bound(const _Kt& __x) const
 -> decltype(iterator(_M_t._M_lower_bound_tr(__x)))
 { return iterator(_M_t._M_lower_bound_tr(__x)); }
# 841 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multiset.h" 3
      iterator
      upper_bound(const key_type& __x)
      { return _M_t.upper_bound(__x); }

      const_iterator
      upper_bound(const key_type& __x) const
      { return _M_t.upper_bound(__x); }


      template<typename _Kt>
 auto
 upper_bound(const _Kt& __x)
 -> decltype(iterator(_M_t._M_upper_bound_tr(__x)))
 { return iterator(_M_t._M_upper_bound_tr(__x)); }

      template<typename _Kt>
 auto
 upper_bound(const _Kt& __x) const
 -> decltype(iterator(_M_t._M_upper_bound_tr(__x)))
 { return iterator(_M_t._M_upper_bound_tr(__x)); }
# 880 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multiset.h" 3
      std::pair<iterator, iterator>
      equal_range(const key_type& __x)
      { return _M_t.equal_range(__x); }

      std::pair<const_iterator, const_iterator>
      equal_range(const key_type& __x) const
      { return _M_t.equal_range(__x); }


      template<typename _Kt>
 auto
 equal_range(const _Kt& __x)
 -> decltype(pair<iterator, iterator>(_M_t._M_equal_range_tr(__x)))
 { return pair<iterator, iterator>(_M_t._M_equal_range_tr(__x)); }

      template<typename _Kt>
 auto
 equal_range(const _Kt& __x) const
 -> decltype(pair<iterator, iterator>(_M_t._M_equal_range_tr(__x)))
 { return pair<iterator, iterator>(_M_t._M_equal_range_tr(__x)); }



      template<typename _K1, typename _C1, typename _A1>
 friend bool
 operator==(const multiset<_K1, _C1, _A1>&,
     const multiset<_K1, _C1, _A1>&);


      template<typename _K1, typename _C1, typename _A1>
 friend __detail::__synth3way_t<_K1>
 operator<=>(const multiset<_K1, _C1, _A1>&,
      const multiset<_K1, _C1, _A1>&);






    };



  template<typename _InputIterator,
    typename _Compare =
      less<typename iterator_traits<_InputIterator>::value_type>,
    typename _Allocator =
      allocator<typename iterator_traits<_InputIterator>::value_type>,
    typename = _RequireInputIter<_InputIterator>,
    typename = _RequireNotAllocator<_Compare>,
    typename = _RequireAllocator<_Allocator>>
    multiset(_InputIterator, _InputIterator,
      _Compare = _Compare(), _Allocator = _Allocator())
    -> multiset<typename iterator_traits<_InputIterator>::value_type,
  _Compare, _Allocator>;

  template<typename _Key,
    typename _Compare = less<_Key>,
    typename _Allocator = allocator<_Key>,
    typename = _RequireNotAllocator<_Compare>,
    typename = _RequireAllocator<_Allocator>>
    multiset(initializer_list<_Key>,
      _Compare = _Compare(), _Allocator = _Allocator())
    -> multiset<_Key, _Compare, _Allocator>;

  template<typename _InputIterator, typename _Allocator,
    typename = _RequireInputIter<_InputIterator>,
    typename = _RequireAllocator<_Allocator>>
    multiset(_InputIterator, _InputIterator, _Allocator)
    -> multiset<typename iterator_traits<_InputIterator>::value_type,
         less<typename iterator_traits<_InputIterator>::value_type>,
         _Allocator>;

  template<typename _Key, typename _Allocator,
    typename = _RequireAllocator<_Allocator>>
    multiset(initializer_list<_Key>, _Allocator)
    -> multiset<_Key, less<_Key>, _Allocator>;
# 971 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multiset.h" 3
  template<typename _Key, typename _Compare, typename _Alloc>
    inline bool
    operator==(const multiset<_Key, _Compare, _Alloc>& __x,
        const multiset<_Key, _Compare, _Alloc>& __y)
    { return __x._M_t == __y._M_t; }
# 992 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multiset.h" 3
  template<typename _Key, typename _Compare, typename _Alloc>
    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; }
# 1045 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multiset.h" 3
  template<typename _Key, typename _Compare, typename _Alloc>
    inline void
    swap(multiset<_Key, _Compare, _Alloc>& __x,
  multiset<_Key, _Compare, _Alloc>& __y)
    noexcept(noexcept(__x.swap(__y)))
    { __x.swap(__y); }





  template<typename _Val, typename _Cmp1, typename _Alloc, typename _Cmp2>
    struct
    _Rb_tree_merge_helper<std::multiset<_Val, _Cmp1, _Alloc>,
     _Cmp2>
    {
    private:
      friend class std::multiset<_Val, _Cmp1, _Alloc>;

      static auto&
      _S_get_tree(std::set<_Val, _Cmp2, _Alloc>& __set)
      { return __set._M_t; }

      static auto&
      _S_get_tree(std::multiset<_Val, _Cmp2, _Alloc>& __set)
      { return __set._M_t; }
    };



}
# 65 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/set" 2 3
# 76 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/set" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 77 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/set" 2 3



namespace std __attribute__ ((__visibility__ ("default")))
{

  namespace pmr
  {
    template<typename _Key, typename _Cmp = std::less<_Key>>
      using set = std::set<_Key, _Cmp, polymorphic_allocator<_Key>>;
    template<typename _Key, typename _Cmp = std::less<_Key>>
      using multiset = std::multiset<_Key, _Cmp, polymorphic_allocator<_Key>>;
  }

}



namespace std __attribute__ ((__visibility__ ("default")))
{

  template<typename _Key, typename _Compare, typename _Alloc,
    typename _Predicate>
    inline typename set<_Key, _Compare, _Alloc>::size_type
    erase_if(set<_Key, _Compare, _Alloc>& __cont, _Predicate __pred)
    {
      std::set<_Key, _Compare, _Alloc>& __ucont = __cont;
      return __detail::__erase_nodes_if(__cont, __ucont, __pred);
    }

  template<typename _Key, typename _Compare, typename _Alloc,
    typename _Predicate>
    inline typename multiset<_Key, _Compare, _Alloc>::size_type
    erase_if(multiset<_Key, _Compare, _Alloc>& __cont, _Predicate __pred)
    {
      std::multiset<_Key, _Compare, _Alloc>& __ucont = __cont;
      return __detail::__erase_nodes_if(__cont, __ucont, __pred);
    }

}
# 47 "/home/avi/scylla-maint/seastar/include/seastar/core/posix.hh" 2


# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/abort_on_ebadf.hh" 1
# 26 "/home/avi/scylla-maint/seastar/include/seastar/core/abort_on_ebadf.hh"
namespace seastar {







void set_abort_on_ebadf(bool do_abort);



bool is_abort_on_ebadf_enabled();



}
# 50 "/home/avi/scylla-maint/seastar/include/seastar/core/posix.hh" 2

# 1 "/home/avi/scylla-maint/seastar/include/seastar/net/socket_defs.hh" 1
# 25 "/home/avi/scylla-maint/seastar/include/seastar/net/socket_defs.hh"
# 1 "/usr/include/sys/un.h" 1 3 4
# 26 "/usr/include/sys/un.h" 3 4
extern "C" {


struct __attribute__ ((__may_alias__)) sockaddr_un
  {
    sa_family_t sun_family;
    char sun_path[108];
  };



# 1 "/usr/bin/../lib/clang/18/include/stddef.h" 1 3 4
# 72 "/usr/bin/../lib/clang/18/include/stddef.h" 3 4
# 1 "/usr/bin/../lib/clang/18/include/__stddef_ptrdiff_t.h" 1 3 4
# 18 "/usr/bin/../lib/clang/18/include/__stddef_ptrdiff_t.h" 3 4
typedef long int ptrdiff_t;
# 73 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3 4




# 1 "/usr/bin/../lib/clang/18/include/__stddef_size_t.h" 1 3 4
# 18 "/usr/bin/../lib/clang/18/include/__stddef_size_t.h" 3 4
typedef long unsigned int size_t;
# 78 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3 4
# 87 "/usr/bin/../lib/clang/18/include/stddef.h" 3 4
# 1 "/usr/bin/../lib/clang/18/include/__stddef_wchar_t.h" 1 3 4
# 88 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3 4




# 1 "/usr/bin/../lib/clang/18/include/__stddef_null.h" 1 3 4
# 93 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3 4




# 1 "/usr/bin/../lib/clang/18/include/__stddef_nullptr_t.h" 1 3 4
# 98 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3 4
# 112 "/usr/bin/../lib/clang/18/include/stddef.h" 3 4
# 1 "/usr/bin/../lib/clang/18/include/__stddef_offsetof.h" 1 3 4
# 113 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3 4
# 38 "/usr/include/sys/un.h" 2 3 4







}
# 26 "/home/avi/scylla-maint/seastar/include/seastar/net/socket_defs.hh" 2
# 1 "/usr/include/netinet/ip.h" 1 3 4
# 24 "/usr/include/netinet/ip.h" 3 4
# 1 "/usr/include/netinet/in.h" 1 3 4
# 27 "/usr/include/netinet/in.h" 3 4
extern "C" {


typedef uint32_t in_addr_t;
struct in_addr
  {
    in_addr_t s_addr;
  };


# 1 "/usr/include/bits/in.h" 1 3 4
# 145 "/usr/include/bits/in.h" 3 4
struct ip_opts
  {
    struct in_addr ip_dst;
    char ip_opts[40];
  };


struct in_pktinfo
  {
    int ipi_ifindex;
    struct in_addr ipi_spec_dst;
    struct in_addr ipi_addr;
  };
# 38 "/usr/include/netinet/in.h" 2 3 4


enum
  {
    IPPROTO_IP = 0,

    IPPROTO_ICMP = 1,

    IPPROTO_IGMP = 2,

    IPPROTO_IPIP = 4,

    IPPROTO_TCP = 6,

    IPPROTO_EGP = 8,

    IPPROTO_PUP = 12,

    IPPROTO_UDP = 17,

    IPPROTO_IDP = 22,

    IPPROTO_TP = 29,

    IPPROTO_DCCP = 33,

    IPPROTO_IPV6 = 41,

    IPPROTO_RSVP = 46,

    IPPROTO_GRE = 47,

    IPPROTO_ESP = 50,

    IPPROTO_AH = 51,

    IPPROTO_MTP = 92,

    IPPROTO_BEETPH = 94,

    IPPROTO_ENCAP = 98,

    IPPROTO_PIM = 103,

    IPPROTO_COMP = 108,

    IPPROTO_L2TP = 115,

    IPPROTO_SCTP = 132,

    IPPROTO_UDPLITE = 136,

    IPPROTO_MPLS = 137,

    IPPROTO_ETHERNET = 143,

    IPPROTO_RAW = 255,

    IPPROTO_MPTCP = 262,

    IPPROTO_MAX
  };





enum
  {
    IPPROTO_HOPOPTS = 0,

    IPPROTO_ROUTING = 43,

    IPPROTO_FRAGMENT = 44,

    IPPROTO_ICMPV6 = 58,

    IPPROTO_NONE = 59,

    IPPROTO_DSTOPTS = 60,

    IPPROTO_MH = 135

  };



typedef uint16_t in_port_t;


enum
  {
    IPPORT_ECHO = 7,
    IPPORT_DISCARD = 9,
    IPPORT_SYSTAT = 11,
    IPPORT_DAYTIME = 13,
    IPPORT_NETSTAT = 15,
    IPPORT_FTP = 21,
    IPPORT_TELNET = 23,
    IPPORT_SMTP = 25,
    IPPORT_TIMESERVER = 37,
    IPPORT_NAMESERVER = 42,
    IPPORT_WHOIS = 43,
    IPPORT_MTP = 57,

    IPPORT_TFTP = 69,
    IPPORT_RJE = 77,
    IPPORT_FINGER = 79,
    IPPORT_TTYLINK = 87,
    IPPORT_SUPDUP = 95,


    IPPORT_EXECSERVER = 512,
    IPPORT_LOGINSERVER = 513,
    IPPORT_CMDSERVER = 514,
    IPPORT_EFSSERVER = 520,


    IPPORT_BIFFUDP = 512,
    IPPORT_WHOSERVER = 513,
    IPPORT_ROUTESERVER = 520,


    IPPORT_RESERVED = 1024,


    IPPORT_USERRESERVED = 5000
  };
# 221 "/usr/include/netinet/in.h" 3 4
struct in6_addr
  {
    union
      {
 uint8_t __u6_addr8[16];
 uint16_t __u6_addr16[8];
 uint32_t __u6_addr32[4];
      } __in6_u;





  };


extern const struct in6_addr in6addr_any;
extern const struct in6_addr in6addr_loopback;
# 247 "/usr/include/netinet/in.h" 3 4
struct __attribute__ ((__may_alias__)) sockaddr_in
  {
    sa_family_t sin_family;
    in_port_t sin_port;
    struct in_addr sin_addr;


    unsigned char sin_zero[sizeof (struct sockaddr)
      - (sizeof (unsigned short int))
      - sizeof (in_port_t)
      - sizeof (struct in_addr)];
  };





struct __attribute__ ((__may_alias__)) sockaddr_in6
  {
    sa_family_t sin6_family;
    in_port_t sin6_port;
    uint32_t sin6_flowinfo;
    struct in6_addr sin6_addr;
    uint32_t sin6_scope_id;
  };




struct ip_mreq
  {

    struct in_addr imr_multiaddr;


    struct in_addr imr_interface;
  };


struct ip_mreqn
  {

    struct in_addr imr_multiaddr;


    struct in_addr imr_address;


    int imr_ifindex;
  };

struct ip_mreq_source
  {

    struct in_addr imr_multiaddr;


    struct in_addr imr_interface;


    struct in_addr imr_sourceaddr;
  };




struct ipv6_mreq
  {

    struct in6_addr ipv6mr_multiaddr;


    unsigned int ipv6mr_interface;
  };




struct group_req
  {

    uint32_t gr_interface;


    struct sockaddr_storage gr_group;
  };

struct group_source_req
  {

    uint32_t gsr_interface;


    struct sockaddr_storage gsr_group;


    struct sockaddr_storage gsr_source;
  };



struct ip_msfilter
  {

    struct in_addr imsf_multiaddr;


    struct in_addr imsf_interface;


    uint32_t imsf_fmode;


    uint32_t imsf_numsrc;

    struct in_addr imsf_slist[1];
  };





struct group_filter
  {

    uint32_t gf_interface;


    struct sockaddr_storage gf_group;


    uint32_t gf_fmode;


    uint32_t gf_numsrc;

    struct sockaddr_storage gf_slist[1];
};
# 399 "/usr/include/netinet/in.h" 3 4
extern uint32_t ntohl (uint32_t __netlong) noexcept (true) __attribute__ ((__const__));
extern uint16_t ntohs (uint16_t __netshort)
     noexcept (true) __attribute__ ((__const__));
extern uint32_t htonl (uint32_t __hostlong)
     noexcept (true) __attribute__ ((__const__));
extern uint16_t htons (uint16_t __hostshort)
     noexcept (true) __attribute__ ((__const__));




# 1 "/usr/include/bits/byteswap.h" 1 3 4
# 411 "/usr/include/netinet/in.h" 2 3 4
# 1 "/usr/include/bits/uintn-identity.h" 1 3 4
# 412 "/usr/include/netinet/in.h" 2 3 4
# 527 "/usr/include/netinet/in.h" 3 4
extern int bindresvport (int __sockfd, struct sockaddr_in *__sock_in) noexcept (true);


extern int bindresvport6 (int __sockfd, struct sockaddr_in6 *__sock_in)
     noexcept (true);
# 557 "/usr/include/netinet/in.h" 3 4
struct cmsghdr;



struct in6_pktinfo
  {
    struct in6_addr ipi6_addr;
    unsigned int ipi6_ifindex;
  };


struct ip6_mtuinfo
  {
    struct sockaddr_in6 ip6m_addr;
    uint32_t ip6m_mtu;
  };



extern int inet6_option_space (int __nbytes)
     noexcept (true) __attribute__ ((__deprecated__));
extern int inet6_option_init (void *__bp, struct cmsghdr **__cmsgp,
         int __type) noexcept (true) __attribute__ ((__deprecated__));
extern int inet6_option_append (struct cmsghdr *__cmsg,
    const uint8_t *__typep, int __multx,
    int __plusy) noexcept (true) __attribute__ ((__deprecated__));
extern uint8_t *inet6_option_alloc (struct cmsghdr *__cmsg, int __datalen,
        int __multx, int __plusy)
     noexcept (true) __attribute__ ((__deprecated__));
extern int inet6_option_next (const struct cmsghdr *__cmsg,
         uint8_t **__tptrp)
     noexcept (true) __attribute__ ((__deprecated__));
extern int inet6_option_find (const struct cmsghdr *__cmsg,
         uint8_t **__tptrp, int __type)
     noexcept (true) __attribute__ ((__deprecated__));



extern int inet6_opt_init (void *__extbuf, socklen_t __extlen) noexcept (true);
extern int inet6_opt_append (void *__extbuf, socklen_t __extlen, int __offset,
        uint8_t __type, socklen_t __len, uint8_t __align,
        void **__databufp) noexcept (true);
extern int inet6_opt_finish (void *__extbuf, socklen_t __extlen, int __offset)
     noexcept (true);
extern int inet6_opt_set_val (void *__databuf, int __offset, void *__val,
         socklen_t __vallen) noexcept (true);
extern int inet6_opt_next (void *__extbuf, socklen_t __extlen, int __offset,
      uint8_t *__typep, socklen_t *__lenp,
      void **__databufp) noexcept (true);
extern int inet6_opt_find (void *__extbuf, socklen_t __extlen, int __offset,
      uint8_t __type, socklen_t *__lenp,
      void **__databufp) noexcept (true);
extern int inet6_opt_get_val (void *__databuf, int __offset, void *__val,
         socklen_t __vallen) noexcept (true);



extern socklen_t inet6_rth_space (int __type, int __segments) noexcept (true);
extern void *inet6_rth_init (void *__bp, socklen_t __bp_len, int __type,
        int __segments) noexcept (true);
extern int inet6_rth_add (void *__bp, const struct in6_addr *__addr) noexcept (true);
extern int inet6_rth_reverse (const void *__in, void *__out) noexcept (true);
extern int inet6_rth_segments (const void *__bp) noexcept (true);
extern struct in6_addr *inet6_rth_getaddr (const void *__bp, int __index)
     noexcept (true);





extern int getipv4sourcefilter (int __s, struct in_addr __interface_addr,
    struct in_addr __group, uint32_t *__fmode,
    uint32_t *__numsrc, struct in_addr *__slist)
     noexcept (true);


extern int setipv4sourcefilter (int __s, struct in_addr __interface_addr,
    struct in_addr __group, uint32_t __fmode,
    uint32_t __numsrc,
    const struct in_addr *__slist)
     noexcept (true);



extern int getsourcefilter (int __s, uint32_t __interface_addr,
       const struct sockaddr *__group,
       socklen_t __grouplen, uint32_t *__fmode,
       uint32_t *__numsrc,
       struct sockaddr_storage *__slist) noexcept (true);


extern int setsourcefilter (int __s, uint32_t __interface_addr,
       const struct sockaddr *__group,
       socklen_t __grouplen, uint32_t __fmode,
       uint32_t __numsrc,
       const struct sockaddr_storage *__slist) noexcept (true);


}
# 25 "/usr/include/netinet/ip.h" 2 3 4

extern "C" {

struct timestamp
  {
    uint8_t len;
    uint8_t ptr;

    unsigned int flags:4;
    unsigned int overflow:4;






    uint32_t data[9];
  };

struct iphdr
  {

    unsigned int ihl:4;
    unsigned int version:4;






    uint8_t tos;
    uint16_t tot_len;
    uint16_t id;
    uint16_t frag_off;
    uint8_t ttl;
    uint8_t protocol;
    uint16_t check;
    uint32_t saddr;
    uint32_t daddr;

  };
# 107 "/usr/include/netinet/ip.h" 3 4
struct ip
  {

    unsigned int ip_hl:4;
    unsigned int ip_v:4;





    uint8_t ip_tos;
    unsigned short ip_len;
    unsigned short ip_id;
    unsigned short ip_off;




    uint8_t ip_ttl;
    uint8_t ip_p;
    unsigned short ip_sum;
    struct in_addr ip_src, ip_dst;
  };




struct ip_timestamp
  {
    uint8_t ipt_code;
    uint8_t ipt_len;
    uint8_t ipt_ptr;

    unsigned int ipt_flg:4;
    unsigned int ipt_oflw:4;





    uint32_t data[9];
  };
# 310 "/usr/include/netinet/ip.h" 3 4
}
# 27 "/home/avi/scylla-maint/seastar/include/seastar/net/socket_defs.hh" 2

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 1 3
# 42 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 3


# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 45 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 2 3
# 29 "/home/avi/scylla-maint/seastar/include/seastar/net/socket_defs.hh" 2




# 1 "/home/avi/scylla-maint/seastar/include/seastar/net/byteorder.hh" 1
# 25 "/home/avi/scylla-maint/seastar/include/seastar/net/byteorder.hh"
# 1 "/usr/include/arpa/inet.h" 1 3 4
# 30 "/usr/include/arpa/inet.h" 3 4
extern "C" {



extern in_addr_t inet_addr (const char *__cp) noexcept (true);


extern in_addr_t inet_lnaof (struct in_addr __in) noexcept (true);



extern struct in_addr inet_makeaddr (in_addr_t __net, in_addr_t __host)
     noexcept (true);


extern in_addr_t inet_netof (struct in_addr __in) noexcept (true);



extern in_addr_t inet_network (const char *__cp) noexcept (true);



extern char *inet_ntoa (struct in_addr __in) noexcept (true);




extern int inet_pton (int __af, const char *__restrict __cp,
        void *__restrict __buf) noexcept (true);




extern const char *inet_ntop (int __af, const void *__restrict __cp,
         char *__restrict __buf, socklen_t __len)
     noexcept (true);






extern int inet_aton (const char *__cp, struct in_addr *__inp) noexcept (true);



extern char *inet_neta (in_addr_t __net, char *__buf, size_t __len) noexcept (true)
  __attribute__ ((__deprecated__ ("Use inet_ntop instead")));




extern char *inet_net_ntop (int __af, const void *__cp, int __bits,
       char *__buf, size_t __len) noexcept (true);




extern int inet_net_pton (int __af, const char *__cp,
     void *__buf, size_t __len) noexcept (true);




extern unsigned int inet_nsap_addr (const char *__cp,
        unsigned char *__buf, int __len) noexcept (true);



extern char *inet_nsap_ntoa (int __len, const unsigned char *__cp,
        char *__buf) noexcept (true);


}
# 26 "/home/avi/scylla-maint/seastar/include/seastar/net/byteorder.hh" 2




# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/unaligned.hh" 1
# 54 "/home/avi/scylla-maint/seastar/include/seastar/core/unaligned.hh"
namespace seastar {


template <typename T>
struct unaligned {


    static_assert(std::is_trivially_copy_constructible_v<T>);
    T raw;
    unaligned() noexcept = default;
    unaligned(T x) noexcept : raw(x) {}
    unaligned& operator=(const T& x) noexcept { raw = x; return *this; }
    operator T() const noexcept { return raw; }
} __attribute__((packed));


template <typename T, typename F>
[[deprecated("violates strict aliasing rules. See issue #165.")]]
inline auto unaligned_cast(F* p) noexcept {
    return reinterpret_cast<unaligned<std::remove_pointer_t<T>>*>(p);
}

template <typename T, typename F>
[[deprecated("violates strict aliasing rules. See issue #165.")]]
inline auto unaligned_cast(const F* p) noexcept {
    return reinterpret_cast<const unaligned<std::remove_pointer_t<T>>*>(p);
}

}
# 31 "/home/avi/scylla-maint/seastar/include/seastar/net/byteorder.hh" 2


namespace seastar {

inline uint64_t ntohq(uint64_t v) {





    return __builtin_bswap64(v);

}
inline uint64_t htonq(uint64_t v) {

    return ntohq(v);
}

namespace net {

inline void ntoh() {}
inline void hton() {}

inline uint8_t ntoh(uint8_t x) { return x; }
inline uint8_t hton(uint8_t x) { return x; }
inline uint16_t ntoh(uint16_t x) { return __bswap_16 (x); }
inline uint16_t hton(uint16_t x) { return __bswap_16 (x); }
inline uint32_t ntoh(uint32_t x) { return __bswap_32 (x); }
inline uint32_t hton(uint32_t x) { return __bswap_32 (x); }
inline uint64_t ntoh(uint64_t x) { return ntohq(x); }
inline uint64_t hton(uint64_t x) { return htonq(x); }

inline int8_t ntoh(int8_t x) { return x; }
inline int8_t hton(int8_t x) { return x; }
inline int16_t ntoh(int16_t x) { return __bswap_16 (x); }
inline int16_t hton(int16_t x) { return __bswap_16 (x); }
inline int32_t ntoh(int32_t x) { return __bswap_32 (x); }
inline int32_t hton(int32_t x) { return __bswap_32 (x); }
inline int64_t ntoh(int64_t x) { return ntohq(x); }
inline int64_t hton(int64_t x) { return htonq(x); }



template <typename T> using packed = unaligned<T>;

template <typename T>
inline T ntoh(const packed<T>& x) {
    T v = x;
    return ntoh(v);
}

template <typename T>
inline T hton(const packed<T>& x) {
    T v = x;
    return hton(v);
}

template <typename T>
inline std::ostream& operator<<(std::ostream& os, const packed<T>& v) {
    auto x = v.raw;
    return os << x;
}

inline
void ntoh_inplace() {}
inline
void hton_inplace() {};

template <typename First, typename... Rest>
inline
void ntoh_inplace(First& first, Rest&... rest) {
    first = ntoh(first);
    ntoh_inplace(std::forward<Rest&>(rest)...);
}

template <typename First, typename... Rest>
inline
void hton_inplace(First& first, Rest&... rest) {
    first = hton(first);
    hton_inplace(std::forward<Rest&>(rest)...);
}

template <class T>
inline
T ntoh(const T& x) {
    T tmp = x;
    tmp.adjust_endianness([] (auto&&... what) { ntoh_inplace(std::forward<decltype(what)&>(what)...); });
    return tmp;
}

template <class T>
inline
T hton(const T& x) {
    T tmp = x;
    tmp.adjust_endianness([] (auto&&... what) { hton_inplace(std::forward<decltype(what)&>(what)...); });
    return tmp;
}

}

}
# 34 "/home/avi/scylla-maint/seastar/include/seastar/net/socket_defs.hh" 2
# 1 "/home/avi/scylla-maint/seastar/include/seastar/net/unix_address.hh" 1
# 31 "/home/avi/scylla-maint/seastar/include/seastar/net/unix_address.hh"
namespace seastar {
# 43 "/home/avi/scylla-maint/seastar/include/seastar/net/unix_address.hh"
struct unix_domain_addr {
    const std::string name;
    const int path_count;

    explicit unix_domain_addr(const std::string& fn) : name{fn}, path_count{path_length_aux()} {}

    explicit unix_domain_addr(const char* fn) : name{fn}, path_count{path_length_aux()} {}

    int path_length() const { return path_count; }





    int path_length_aux() const {
        auto pl = (int)name.length();
        if (!pl || (name[0] == '\0')) {

            return pl;
        }
        return 1 + pl;
    }

    const char* path_bytes() const { return name.c_str(); }

    bool operator==(const unix_domain_addr& a) const {
        return name == a.name;
    }
    bool operator!=(const unix_domain_addr& a) const {
        return !(*this == a);
    }
};

std::ostream& operator<<(std::ostream&, const unix_domain_addr&);

}
# 35 "/home/avi/scylla-maint/seastar/include/seastar/net/socket_defs.hh" 2

namespace seastar {



namespace net {
class inet_address;
}

struct ipv4_addr;
struct ipv6_addr;

class socket_address {
public:
    socklen_t addr_length;
    union {
        ::sockaddr_storage sas;
        ::sockaddr sa;
        ::sockaddr_in in;
        ::sockaddr_in6 in6;
        ::sockaddr_un un;
    } u;
    socket_address(const sockaddr_in& sa) noexcept : addr_length{sizeof(::sockaddr_in)} {
        u.in = sa;
    }
    socket_address(const sockaddr_in6& sa) noexcept : addr_length{sizeof(::sockaddr_in6)} {
        u.in6 = sa;
    }
    socket_address(uint16_t) noexcept;
    socket_address(ipv4_addr) noexcept;
    socket_address(const ipv6_addr&) noexcept;
    socket_address(const ipv6_addr&, uint32_t scope) noexcept;
    socket_address(const net::inet_address&, uint16_t p = 0) noexcept;
    explicit socket_address(const unix_domain_addr&) noexcept;




    socket_address() noexcept;

    ::sockaddr& as_posix_sockaddr() noexcept { return u.sa; }
    ::sockaddr_in& as_posix_sockaddr_in() noexcept { return u.in; }
    ::sockaddr_in6& as_posix_sockaddr_in6() noexcept { return u.in6; }
    const ::sockaddr& as_posix_sockaddr() const noexcept { return u.sa; }
    const ::sockaddr_in& as_posix_sockaddr_in() const noexcept { return u.in; }
    const ::sockaddr_in6& as_posix_sockaddr_in6() const noexcept { return u.in6; }

    socket_address(uint32_t, uint16_t p = 0) noexcept;

    socklen_t length() const noexcept { return addr_length; };

    bool is_af_unix() const noexcept {
        return u.sa.sa_family == 1;
    }

    bool is_unspecified() const noexcept;

    sa_family_t family() const noexcept {
        return u.sa.sa_family;
    }

    net::inet_address addr() const noexcept;
    ::in_port_t port() const noexcept;
    bool is_wildcard() const noexcept;

    bool operator==(const socket_address&) const noexcept;
    bool operator!=(const socket_address& a) const noexcept {
        return !(*this == a);
    }
};

std::ostream& operator<<(std::ostream&, const socket_address&);

enum class transport {
    TCP = IPPROTO_TCP,
    SCTP = IPPROTO_SCTP
};

struct ipv4_addr {
    uint32_t ip;
    uint16_t port;

    ipv4_addr() noexcept : ip(0), port(0) {}
    ipv4_addr(uint32_t ip, uint16_t port) noexcept : ip(ip), port(port) {}
    ipv4_addr(uint16_t port) noexcept : ip(0), port(port) {}

    ipv4_addr(const std::string &addr);
    ipv4_addr(const std::string &addr, uint16_t port);

    ipv4_addr(const net::inet_address&, uint16_t);
    ipv4_addr(const socket_address &) noexcept;
    ipv4_addr(const ::in_addr&, uint16_t = 0) noexcept;

    bool is_ip_unspecified() const noexcept {
        return ip == 0;
    }
    bool is_port_unspecified() const noexcept {
        return port == 0;
    }
};

struct ipv6_addr {
    using ipv6_bytes = std::array<uint8_t, 16>;

    ipv6_bytes ip;
    uint16_t port;

    ipv6_addr(const ipv6_bytes&, uint16_t port = 0) noexcept;
    ipv6_addr(uint16_t port = 0) noexcept;

    ipv6_addr(const std::string&);
    ipv6_addr(const std::string&, uint16_t port);
    ipv6_addr(const net::inet_address&, uint16_t = 0) noexcept;
    ipv6_addr(const ::in6_addr&, uint16_t = 0) noexcept;
    ipv6_addr(const ::sockaddr_in6&) noexcept;
    ipv6_addr(const socket_address&) noexcept;

    bool is_ip_unspecified() const noexcept;
    bool is_port_unspecified() const noexcept {
        return port == 0;
    }
};

std::ostream& operator<<(std::ostream&, const ipv4_addr&);
std::ostream& operator<<(std::ostream&, const ipv6_addr&);

inline bool operator==(const ipv4_addr &lhs, const ipv4_addr& rhs) noexcept {
    return lhs.ip == rhs.ip && lhs.port == rhs.port;
}

}

namespace std {
template<>
struct hash<seastar::socket_address> {
    size_t operator()(const seastar::socket_address&) const;
};
template<>
struct hash<seastar::ipv4_addr> {
    size_t operator()(const seastar::ipv4_addr&) const;
};
template<>
struct hash<seastar::unix_domain_addr> {
    size_t operator()(const seastar::unix_domain_addr&) const;
};
template<>
struct hash<::sockaddr_un> {
    size_t operator()(const ::sockaddr_un&) const;
};

template <>
struct hash<seastar::transport> {
    size_t operator()(seastar::transport tr) const {
        return static_cast<size_t>(tr);
    }
};

}


template <> struct fmt::formatter<seastar::socket_address> : fmt::ostream_formatter {};
template <> struct fmt::formatter<seastar::ipv4_addr> : fmt::ostream_formatter {};
template <> struct fmt::formatter<seastar::ipv6_addr> : fmt::ostream_formatter {};
# 52 "/home/avi/scylla-maint/seastar/include/seastar/core/posix.hh" 2



namespace seastar {
# 68 "/home/avi/scylla-maint/seastar/include/seastar/core/posix.hh"
inline void throw_system_error_on(bool condition, const char* what_arg = "");

template <typename T>
inline void throw_kernel_error(T r);

template <typename T>
inline void throw_pthread_error(T r);

struct mmap_deleter {
    size_t _size;
    void operator()(void* ptr) const;
};

using mmap_area = std::unique_ptr<char[], mmap_deleter>;

mmap_area mmap_anonymous(void* addr, size_t length, int prot, int flags);

class file_desc {
    int _fd;
public:
    file_desc() = delete;
    file_desc(const file_desc&) = delete;
    file_desc(file_desc&& x) noexcept : _fd(x._fd) { x._fd = -1; }
    ~file_desc() { if (_fd != -1) { ::close(_fd); } }
    void operator=(const file_desc&) = delete;
    file_desc& operator=(file_desc&& x) {
        if (this != &x) {
            std::swap(_fd, x._fd);
            if (x._fd != -1) {
                x.close();
            }
        }
        return *this;
    }
    void close() {
        (static_cast <bool> (_fd != -1) ? void (0) : __assert_fail ("_fd != -1", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        auto r = ::close(_fd);
        throw_system_error_on(r == -1, "close");
        _fd = -1;
    }
    int get() const { return _fd; }

    sstring fdinfo() const noexcept;

    static file_desc from_fd(int fd) {
        return file_desc(fd);
    }

    static file_desc open(sstring name, int flags, mode_t mode = 0) {
        int fd = ::open(name.c_str(), flags, mode);
        throw_system_error_on(fd == -1, "open");
        return file_desc(fd);
    }
    static file_desc socket(int family, int type, int protocol = 0) {
        int fd = ::socket(family, type, protocol);
        throw_system_error_on(fd == -1, "socket");
        return file_desc(fd);
    }
    static file_desc eventfd(unsigned initval, int flags) {
        int fd = ::eventfd(initval, flags);
        throw_system_error_on(fd == -1, "eventfd");
        return file_desc(fd);
    }
    static file_desc epoll_create(int flags = 0) {
        int fd = ::epoll_create1(flags);
        throw_system_error_on(fd == -1, "epoll_create1");
        return file_desc(fd);
    }
    static file_desc timerfd_create(int clockid, int flags) {
        int fd = ::timerfd_create(clockid, flags);
        throw_system_error_on(fd == -1, "timerfd_create");
        return file_desc(fd);
    }
    static file_desc temporary(sstring directory);
    file_desc dup() const {
        int fd = ::dup(get());
        throw_system_error_on(fd == -1, "dup");
        return file_desc(fd);
    }
    file_desc accept(socket_address& sa, int flags = 0) {
        auto ret = ::accept4(_fd, &sa.as_posix_sockaddr(), &sa.addr_length, flags);
        throw_system_error_on(ret == -1, "accept4");
        return file_desc(ret);
    }
    static file_desc inotify_init(int flags);

    std::optional<file_desc> try_accept(socket_address& sa, int flags = 0) {
        auto ret = ::accept4(_fd, &sa.as_posix_sockaddr(), &sa.addr_length, flags);
        if (ret == -1 && (*__errno_location ()) == 11) {
            return {};
        }
        throw_system_error_on(ret == -1, "accept4");
        return file_desc(ret);
    }
    void shutdown(int how) {
        auto ret = ::shutdown(_fd, how);
        if (ret == -1 && (*__errno_location ()) != 107) {
            throw_system_error_on(ret == -1, "shutdown");
        }
    }
    void truncate(size_t size) {
        auto ret = ::ftruncate(_fd, size);
        throw_system_error_on(ret, "ftruncate");
    }
    int ioctl(int request) {
        return ioctl(request, 0);
    }
    int ioctl(int request, int value) {
        int r = ::ioctl(_fd, request, value);
        throw_system_error_on(r == -1, "ioctl");
        return r;
    }
    int ioctl(int request, unsigned int value) {
        int r = ::ioctl(_fd, request, value);
        throw_system_error_on(r == -1, "ioctl");
        return r;
    }
    template <class X>
    int ioctl(int request, X& data) {
        int r = ::ioctl(_fd, request, &data);
        throw_system_error_on(r == -1, "ioctl");
        return r;
    }
    template <class X>
    int ioctl(int request, X&& data) {
        int r = ::ioctl(_fd, request, &data);
        throw_system_error_on(r == -1, "ioctl");
        return r;
    }
    template <class X>
    int setsockopt(int level, int optname, X&& data) {
        int r = ::setsockopt(_fd, level, optname, &data, sizeof(data));
        throw_system_error_on(r == -1, "setsockopt");
        return r;
    }
    int setsockopt(int level, int optname, const char* data) {
        int r = ::setsockopt(_fd, level, optname, data, strlen(data) + 1);
        throw_system_error_on(r == -1, "setsockopt");
        return r;
    }
    int setsockopt(int level, int optname, const void* data, socklen_t len) {
        int r = ::setsockopt(_fd, level, optname, data, len);
        throw_system_error_on(r == -1, "setsockopt");
        return r;
    }
    template <typename Data>
    Data getsockopt(int level, int optname) {
        Data data;
        socklen_t len = sizeof(data);
        memset(&data, 0, len);
        int r = ::getsockopt(_fd, level, optname, &data, &len);
        throw_system_error_on(r == -1, "getsockopt");
        return data;
    }
    int getsockopt(int level, int optname, char* data, socklen_t len) {
        int r = ::getsockopt(_fd, level, optname, data, &len);
        throw_system_error_on(r == -1, "getsockopt");
        return r;
    }
    size_t size() {
        struct stat buf;
        auto r = ::fstat(_fd, &buf);
        throw_system_error_on(r == -1, "fstat");
        return buf.st_size;
    }
    std::optional<size_t> read(void* buffer, size_t len) {
        auto r = ::read(_fd, buffer, len);
        if (r == -1 && (*__errno_location ()) == 11) {
            return {};
        }
        throw_system_error_on(r == -1, "read");
        return { size_t(r) };
    }
    std::optional<ssize_t> recv(void* buffer, size_t len, int flags) {
        auto r = ::recv(_fd, buffer, len, flags);
        if (r == -1 && (*__errno_location ()) == 11) {
            return {};
        }
        throw_system_error_on(r == -1, "recv");
        return { ssize_t(r) };
    }
    std::optional<size_t> recvmsg(msghdr* mh, int flags) {
        auto r = ::recvmsg(_fd, mh, flags);
        if (r == -1 && (*__errno_location ()) == 11) {
            return {};
        }
        throw_system_error_on(r == -1, "recvmsg");
        return { size_t(r) };
    }
    std::optional<size_t> send(const void* buffer, size_t len, int flags) {
        auto r = ::send(_fd, buffer, len, flags);
        if (r == -1 && (*__errno_location ()) == 11) {
            return {};
        }
        throw_system_error_on(r == -1, "send");
        return { size_t(r) };
    }
    std::optional<size_t> sendto(socket_address& addr, const void* buf, size_t len, int flags) {
        auto r = ::sendto(_fd, buf, len, flags, &addr.u.sa, addr.length());
        if (r == -1 && (*__errno_location ()) == 11) {
            return {};
        }
        throw_system_error_on(r == -1, "sendto");
        return { size_t(r) };
    }
    std::optional<size_t> sendmsg(const msghdr* msg, int flags) {
        auto r = ::sendmsg(_fd, msg, flags);
        if (r == -1 && (*__errno_location ()) == 11) {
            return {};
        }
        throw_system_error_on(r == -1, "sendmsg");
        return { size_t(r) };
    }
    void bind(sockaddr& sa, socklen_t sl) {
        auto r = ::bind(_fd, &sa, sl);
        throw_system_error_on(r == -1, "bind");
    }
    void connect(sockaddr& sa, socklen_t sl) {
        auto r = ::connect(_fd, &sa, sl);
        if (r == -1 && (*__errno_location ()) == 115) {
            return;
        }
        throw_system_error_on(r == -1, "connect");
    }
    socket_address get_address() {
        socket_address addr;
        auto r = ::getsockname(_fd, &addr.u.sa, &addr.addr_length);
        throw_system_error_on(r == -1, "getsockname");
        return addr;
    }
    socket_address get_remote_address() {
        socket_address addr;
        auto r = ::getpeername(_fd, &addr.u.sa, &addr.addr_length);
        throw_system_error_on(r == -1, "getpeername");
        return addr;
    }
    void listen(int backlog) {
        auto fd = ::listen(_fd, backlog);
        throw_system_error_on(fd == -1, "listen");
    }
    std::optional<size_t> write(const void* buf, size_t len) {
        auto r = ::write(_fd, buf, len);
        if (r == -1 && (*__errno_location ()) == 11) {
            return {};
        }
        throw_system_error_on(r == -1, "write");
        return { size_t(r) };
    }
    std::optional<size_t> writev(const iovec *iov, int iovcnt) {
        auto r = ::writev(_fd, iov, iovcnt);
        if (r == -1 && (*__errno_location ()) == 11) {
            return {};
        }
        throw_system_error_on(r == -1, "writev");
        return { size_t(r) };
    }
    size_t pread(void* buf, size_t len, off_t off) {
        auto r = ::pread(_fd, buf, len, off);
        throw_system_error_on(r == -1, "pread");
        return size_t(r);
    }
    void timerfd_settime(int flags, const itimerspec& its) {
        auto r = ::timerfd_settime(_fd, flags, &its, __null);
        throw_system_error_on(r == -1, "timerfd_settime");
    }

    mmap_area map(size_t size, unsigned prot, unsigned flags, size_t offset,
            void* addr = nullptr) {
        void *x = mmap(addr, size, prot, flags, _fd, offset);
        throw_system_error_on(x == ((void *) -1), "mmap");
        return mmap_area(static_cast<char*>(x), mmap_deleter{size});
    }

    mmap_area map_shared_rw(size_t size, size_t offset) {
        return map(size, 0x1 | 0x2, 0x01, offset);
    }

    mmap_area map_shared_ro(size_t size, size_t offset) {
        return map(size, 0x1, 0x01, offset);
    }

    mmap_area map_private_rw(size_t size, size_t offset) {
        return map(size, 0x1 | 0x2, 0x02, offset);
    }

    mmap_area map_private_ro(size_t size, size_t offset) {
        return map(size, 0x1, 0x02, offset);
    }

    void spawn_actions_add_close(posix_spawn_file_actions_t* actions) {
        auto r = ::posix_spawn_file_actions_addclose(actions, _fd);
        throw_pthread_error(r);
    }

    void spawn_actions_add_dup2(posix_spawn_file_actions_t* actions, int newfd) {
        auto r = ::posix_spawn_file_actions_adddup2(actions, _fd, newfd);
        throw_pthread_error(r);
    }
private:
    file_desc(int fd) : _fd(fd) {}
 };


namespace posix {

constexpr unsigned rcv_shutdown = 0x1;
constexpr unsigned snd_shutdown = 0x2;
inline constexpr unsigned shutdown_mask(int how) { return how + 1; }





template <typename Rep, typename Period>
struct timespec
to_timespec(std::chrono::duration<Rep, Period> d) {
    auto ns = std::chrono::duration_cast<std::chrono::nanoseconds>(d).count();
    struct timespec ts {};
    ts.tv_sec = ns / 1000000000;
    ts.tv_nsec = ns % 1000000000;
    return ts;
}






template <typename Rep1, typename Period1, typename Rep2, typename Period2>
struct itimerspec
to_relative_itimerspec(std::chrono::duration<Rep1, Period1> base, std::chrono::duration<Rep2, Period2> interval) {
    struct itimerspec its {};
    its.it_interval = to_timespec(interval);
    its.it_value = to_timespec(base);
    return its;
}







template <typename Clock, class Duration, class Rep, class Period>
struct itimerspec
to_absolute_itimerspec(std::chrono::time_point<Clock, Duration> base, std::chrono::duration<Rep, Period> interval) {
    return to_relative_itimerspec(base.time_since_epoch(), interval);
}

}

class posix_thread {
public:
    class attr;
private:

    std::unique_ptr<std::function<void ()>> _func;
    pthread_t _pthread;
    bool _valid = true;
    mmap_area _stack;
private:
    static void* start_routine(void* arg) noexcept;
public:
    posix_thread(std::function<void ()> func);
    posix_thread(attr a, std::function<void ()> func);
    posix_thread(posix_thread&& x);
    ~posix_thread();
    void join();
public:
    class attr {
    public:
        struct stack_size { size_t size = 0; };
        attr() = default;
        template <typename... A>
        attr(A... a) {
            set(std::forward<A>(a)...);
        }
        void set() {}
        template <typename A, typename... Rest>
        void set(A a, Rest... rest) {
            set(std::forward<A>(a));
            set(std::forward<Rest>(rest)...);
        }
        void set(stack_size ss) { _stack_size = ss; }
        void set(cpu_set_t affinity) { _affinity = affinity; }
    private:
        stack_size _stack_size;
        std::optional<cpu_set_t> _affinity;
        friend class posix_thread;
    };
};


inline
void throw_system_error_on(bool condition, const char* what_arg) {
    if (condition) {
        if (((*__errno_location ()) == 9 || (*__errno_location ()) == 88) && is_abort_on_ebadf_enabled()) {
            abort();
        }
        throw std::system_error((*__errno_location ()), std::system_category(), what_arg);
    }
}

template <typename T>
inline
void throw_kernel_error(T r) {
    static_assert(std::is_signed_v<T>, "kernel error variables must be signed");
    if (r < 0) {
        auto ec = -r;
        if ((ec == 9 || ec == 88) && is_abort_on_ebadf_enabled()) {
            abort();
        }
        throw std::system_error(-r, std::system_category());
    }
}

template <typename T>
inline
void throw_pthread_error(T r) {
    if (r != 0) {
        throw std::system_error(r, std::system_category());
    }
}

inline
sigset_t make_sigset_mask(int signo) {
    sigset_t set;
    sigemptyset(&set);
    sigaddset(&set, signo);
    return set;
}

inline
sigset_t make_full_sigset_mask() {
    sigset_t set;
    sigfillset(&set);
    return set;
}

inline
sigset_t make_empty_sigset_mask() {
    sigset_t set;
    sigemptyset(&set);
    return set;
}

inline
void pin_this_thread(unsigned cpu_id) {
    cpu_set_t cs;
    do __builtin_memset (&cs, '\0', sizeof (cpu_set_t)); while (0);
    (__extension__ ({ size_t __cpu = (cpu_id); __cpu / 8 < (sizeof (cpu_set_t)) ? (((__cpu_mask *) ((&cs)->__bits))[((__cpu) / (8 * sizeof (__cpu_mask)))] |= ((__cpu_mask) 1 << ((__cpu) % (8 * sizeof (__cpu_mask))))) : 0; }));
    auto r = pthread_setaffinity_np(pthread_self(), sizeof(cs), &cs);
    (static_cast <bool> (r == 0) ? void (0) : __assert_fail ("r == 0", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
    (void)r;
}

std::set<unsigned> get_current_cpuset();




}
# 54 "/home/avi/scylla-maint/seastar/include/seastar/core/seastar.hh" 2
# 1 "/home/avi/scylla-maint/seastar/include/seastar/util/bool_class.hh" 1
# 27 "/home/avi/scylla-maint/seastar/include/seastar/util/bool_class.hh"
namespace seastar {
# 57 "/home/avi/scylla-maint/seastar/include/seastar/util/bool_class.hh"
template<typename Tag>
class bool_class {
    bool _value;
public:
    static const bool_class yes;
    static const bool_class no;


    constexpr bool_class() noexcept : _value(false) { }


    constexpr explicit bool_class(bool v) noexcept : _value(v) { }


    explicit operator bool() const noexcept { return _value; }


    friend bool_class operator||(bool_class x, bool_class y) noexcept {
        return bool_class(x._value || y._value);
    }


    friend bool_class operator&&(bool_class x, bool_class y) noexcept {
        return bool_class(x._value && y._value);
    }


    friend bool_class operator!(bool_class x) noexcept {
        return bool_class(!x._value);
    }


    friend bool operator==(bool_class x, bool_class y) noexcept = default;


    friend std::ostream& operator<<(std::ostream& os, bool_class v) {
        return os << (v._value ? "true" : "false");
    }
};

template<typename Tag>
const bool_class<Tag> bool_class<Tag>::yes { true };
template<typename Tag>
const bool_class<Tag> bool_class<Tag>::no { false };



}

template<typename Tag>
struct fmt::formatter<seastar::bool_class<Tag>> {
    constexpr auto parse(format_parse_context& ctx) { return ctx.begin(); }
    template <typename FormatContext>
    auto format(seastar::bool_class<Tag> v, FormatContext& ctx) const{
        return fmt::format_to(ctx.out(), "{}", bool(v));
    }
};
# 55 "/home/avi/scylla-maint/seastar/include/seastar/core/seastar.hh" 2


# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/./internal/api-level.hh" 1
# 43 "/home/avi/scylla-maint/seastar/include/seastar/core/./internal/api-level.hh"
namespace seastar {
                           namespace api_v6 {
        inline namespace and_newer {
        }
    }
    inline namespace api_v7 {
        inline namespace and_newer {
            using namespace api_v6::and_newer;
        }
    }
}
# 58 "/home/avi/scylla-maint/seastar/include/seastar/core/seastar.hh" 2


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/filesystem" 1 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/filesystem" 3




# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 39 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/filesystem" 2 3
# 51 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/filesystem" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/fs_fwd.h" 1 3
# 39 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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
  };



  [[nodiscard]]
  constexpr copy_options
  operator&(copy_options __x, copy_options __y) noexcept
  {
    using __utype = typename std::underlying_type<copy_options>::type;
    return static_cast<copy_options>(
 static_cast<__utype>(__x) & static_cast<__utype>(__y));
  }

  [[nodiscard]]
  constexpr copy_options
  operator|(copy_options __x, copy_options __y) noexcept
  {
    using __utype = typename std::underlying_type<copy_options>::type;
    return static_cast<copy_options>(
 static_cast<__utype>(__x) | static_cast<__utype>(__y));
  }

  [[nodiscard]]
  constexpr copy_options
  operator^(copy_options __x, copy_options __y) noexcept
  {
    using __utype = typename std::underlying_type<copy_options>::type;
    return static_cast<copy_options>(
 static_cast<__utype>(__x) ^ static_cast<__utype>(__y));
  }

  [[nodiscard]]
  constexpr copy_options
  operator~(copy_options __x) noexcept
  {
    using __utype = typename std::underlying_type<copy_options>::type;
    return static_cast<copy_options>(~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,
  };



  [[nodiscard]]
  constexpr perms
  operator&(perms __x, perms __y) noexcept
  {
    using __utype = typename std::underlying_type<perms>::type;
    return static_cast<perms>(
 static_cast<__utype>(__x) & static_cast<__utype>(__y));
  }

  [[nodiscard]]
  constexpr perms
  operator|(perms __x, perms __y) noexcept
  {
    using __utype = typename std::underlying_type<perms>::type;
    return static_cast<perms>(
 static_cast<__utype>(__x) | static_cast<__utype>(__y));
  }

  [[nodiscard]]
  constexpr perms
  operator^(perms __x, perms __y) noexcept
  {
    using __utype = typename std::underlying_type<perms>::type;
    return static_cast<perms>(
 static_cast<__utype>(__x) ^ static_cast<__utype>(__y));
  }

  [[nodiscard]]
  constexpr perms
  operator~(perms __x) noexcept
  {
    using __utype = typename std::underlying_type<perms>::type;
    return static_cast<perms>(~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
  };



  [[nodiscard]]
  constexpr perm_options
  operator&(perm_options __x, perm_options __y) noexcept
  {
    using __utype = typename std::underlying_type<perm_options>::type;
    return static_cast<perm_options>(
 static_cast<__utype>(__x) & static_cast<__utype>(__y));
  }

  [[nodiscard]]
  constexpr perm_options
  operator|(perm_options __x, perm_options __y) noexcept
  {
    using __utype = typename std::underlying_type<perm_options>::type;
    return static_cast<perm_options>(
 static_cast<__utype>(__x) | static_cast<__utype>(__y));
  }

  [[nodiscard]]
  constexpr perm_options
  operator^(perm_options __x, perm_options __y) noexcept
  {
    using __utype = typename std::underlying_type<perm_options>::type;
    return static_cast<perm_options>(
 static_cast<__utype>(__x) ^ static_cast<__utype>(__y));
  }

  [[nodiscard]]
  constexpr perm_options
  operator~(perm_options __x) noexcept
  {
    using __utype = typename std::underlying_type<perm_options>::type;
    return static_cast<perm_options>(~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
  };



  [[nodiscard]]
  constexpr directory_options
  operator&(directory_options __x, directory_options __y) noexcept
  {
    using __utype = typename std::underlying_type<directory_options>::type;
    return static_cast<directory_options>(
 static_cast<__utype>(__x) & static_cast<__utype>(__y));
  }

  [[nodiscard]]
  constexpr directory_options
  operator|(directory_options __x, directory_options __y) noexcept
  {
    using __utype = typename std::underlying_type<directory_options>::type;
    return static_cast<directory_options>(
 static_cast<__utype>(__x) | static_cast<__utype>(__y));
  }

  [[nodiscard]]
  constexpr directory_options
  operator^(directory_options __x, directory_options __y) noexcept
  {
    using __utype = typename std::underlying_type<directory_options>::type;
    return static_cast<directory_options>(
 static_cast<__utype>(__x) ^ static_cast<__utype>(__y));
  }

  [[nodiscard]]
  constexpr directory_options
  operator~(directory_options __x) noexcept
  {
    using __utype = typename std::underlying_type<directory_options>::type;
    return static_cast<directory_options>(~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;

  bool remove(const path&, error_code&) noexcept;
  uintmax_t remove_all(const path&);
  uintmax_t remove_all(const path&, error_code&);


}

}
# 52 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/filesystem" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/fs_path.h" 1 3
# 39 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/fs_path.h" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/codecvt" 1 3
# 35 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/codecvt" 3








namespace std __attribute__ ((__visibility__ ("default")))
{


  enum codecvt_mode
  {
    consume_header = 4,
    generate_header = 2,
    little_endian = 1
  };

  template<typename _Elem, unsigned long _Maxcode = 0x10ffff,
    codecvt_mode _Mode = (codecvt_mode)0>
    class codecvt_utf8 : public codecvt<_Elem, char, mbstate_t>
    {
    public:
      explicit
      codecvt_utf8(size_t __refs = 0);

      ~codecvt_utf8();
    };

  template<typename _Elem, unsigned long _Maxcode = 0x10ffff,
    codecvt_mode _Mode = (codecvt_mode)0>
    class codecvt_utf16 : public codecvt<_Elem, char, mbstate_t>
    {
    public:
      explicit
      codecvt_utf16(size_t __refs = 0);

      ~codecvt_utf16();
    };

  template<typename _Elem, unsigned long _Maxcode = 0x10ffff,
    codecvt_mode _Mode = (codecvt_mode)0>
    class codecvt_utf8_utf16 : public codecvt<_Elem, char, mbstate_t>
    {
    public:
      explicit
      codecvt_utf8_utf16(size_t __refs = 0);

      ~codecvt_utf8_utf16();
    };
# 154 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/codecvt" 3
  template<typename _Elem> class __codecvt_utf8_base;
  template<typename _Elem> class __codecvt_utf16_base;
  template<typename _Elem> class __codecvt_utf8_utf16_base;

  template<> class __codecvt_utf8_base<char16_t> : public codecvt<char16_t, char, mbstate_t> { 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<unsigned long _Maxcode, codecvt_mode _Mode> class codecvt_utf8<char16_t, _Maxcode, _Mode> : public __codecvt_utf8_base<char16_t> { public: explicit codecvt_utf8(size_t __refs = 0) : __codecvt_utf8_base<char16_t>(std::min(_Maxcode, 0x10fffful), _Mode, __refs) { } };
  template<> class __codecvt_utf16_base<char16_t> : public codecvt<char16_t, char, mbstate_t> { 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<unsigned long _Maxcode, codecvt_mode _Mode> class codecvt_utf16<char16_t, _Maxcode, _Mode> : public __codecvt_utf16_base<char16_t> { public: explicit codecvt_utf16(size_t __refs = 0) : __codecvt_utf16_base<char16_t>(std::min(_Maxcode, 0x10fffful), _Mode, __refs) { } };
  template<> class __codecvt_utf8_utf16_base<char16_t> : public codecvt<char16_t, char, mbstate_t> { 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<unsigned long _Maxcode, codecvt_mode _Mode> class codecvt_utf8_utf16<char16_t, _Maxcode, _Mode> : public __codecvt_utf8_utf16_base<char16_t> { public: explicit codecvt_utf8_utf16(size_t __refs = 0) : __codecvt_utf8_utf16_base<char16_t>(std::min(_Maxcode, 0x10fffful), _Mode, __refs) { } };

  template<> class __codecvt_utf8_base<char32_t> : public codecvt<char32_t, char, mbstate_t> { 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<unsigned long _Maxcode, codecvt_mode _Mode> class codecvt_utf8<char32_t, _Maxcode, _Mode> : public __codecvt_utf8_base<char32_t> { public: explicit codecvt_utf8(size_t __refs = 0) : __codecvt_utf8_base<char32_t>(std::min(_Maxcode, 0x10fffful), _Mode, __refs) { } };
  template<> class __codecvt_utf16_base<char32_t> : public codecvt<char32_t, char, mbstate_t> { 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<unsigned long _Maxcode, codecvt_mode _Mode> class codecvt_utf16<char32_t, _Maxcode, _Mode> : public __codecvt_utf16_base<char32_t> { public: explicit codecvt_utf16(size_t __refs = 0) : __codecvt_utf16_base<char32_t>(std::min(_Maxcode, 0x10fffful), _Mode, __refs) { } };
  template<> class __codecvt_utf8_utf16_base<char32_t> : public codecvt<char32_t, char, mbstate_t> { 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<unsigned long _Maxcode, codecvt_mode _Mode> class codecvt_utf8_utf16<char32_t, _Maxcode, _Mode> : public __codecvt_utf8_utf16_base<char32_t> { public: explicit codecvt_utf8_utf16(size_t __refs = 0) : __codecvt_utf8_utf16_base<char32_t>(std::min(_Maxcode, 0x10fffful), _Mode, __refs) { } };


  template<> class __codecvt_utf8_base<wchar_t> : public codecvt<wchar_t, char, mbstate_t> { 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<unsigned long _Maxcode, codecvt_mode _Mode> class codecvt_utf8<wchar_t, _Maxcode, _Mode> : public __codecvt_utf8_base<wchar_t> { public: explicit codecvt_utf8(size_t __refs = 0) : __codecvt_utf8_base<wchar_t>(std::min(_Maxcode, 0x10fffful), _Mode, __refs) { } };
  template<> class __codecvt_utf16_base<wchar_t> : public codecvt<wchar_t, char, mbstate_t> { 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<unsigned long _Maxcode, codecvt_mode _Mode> class codecvt_utf16<wchar_t, _Maxcode, _Mode> : public __codecvt_utf16_base<wchar_t> { public: explicit codecvt_utf16(size_t __refs = 0) : __codecvt_utf16_base<wchar_t>(std::min(_Maxcode, 0x10fffful), _Mode, __refs) { } };
  template<> class __codecvt_utf8_utf16_base<wchar_t> : public codecvt<wchar_t, char, mbstate_t> { 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<unsigned long _Maxcode, codecvt_mode _Mode> class codecvt_utf8_utf16<wchar_t, _Maxcode, _Mode> : public __codecvt_utf8_utf16_base<wchar_t> { public: explicit codecvt_utf8_utf16(size_t __refs = 0) : __codecvt_utf8_utf16_base<wchar_t>(std::min(_Maxcode, 0x10fffful), _Mode, __refs) { } };



}
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/fs_path.h" 2 3
# 57 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/fs_path.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{


namespace filesystem
{
namespace __cxx11 {

  class path;


namespace __detail
{


  template<typename _CharT>
    inline constexpr bool __is_encoded_char = false;
  template<>
    inline constexpr bool __is_encoded_char<char> = true;

  template<>
    inline constexpr bool __is_encoded_char<char8_t> = true;


  template<>
    inline constexpr bool __is_encoded_char<wchar_t> = true;

  template<>
    inline constexpr bool __is_encoded_char<char16_t> = true;
  template<>
    inline constexpr bool __is_encoded_char<char32_t> = true;


  template<typename _Iter>
    using __safe_iterator_traits = std::iterator_traits<_Iter>;
# 104 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/fs_path.h" 3
  template<typename _Iter_traits, typename = void>
    inline constexpr bool __is_path_iter_src = false;

  template<typename _Iter_traits>
    inline constexpr bool
    __is_path_iter_src<_Iter_traits, void_t<typename _Iter_traits::value_type>>
      = __is_encoded_char<typename _Iter_traits::value_type>;

  template<typename _Source>
    inline constexpr bool __is_path_src
      = __is_path_iter_src<iterator_traits<decay_t<_Source>>>;

  template<>
    inline constexpr bool __is_path_src<path> = false;

  template<>
    inline constexpr bool __is_path_src<volatile path> = false;

  template<>
    inline constexpr bool __is_path_src<void*> = false;

  template<>
    inline constexpr bool __is_path_src<const void*> = false;

  template<>
    inline constexpr bool __is_path_src<volatile void*> = false;

  template<>
    inline constexpr bool __is_path_src<const volatile void*> = false;

  template<typename _CharT, typename _Traits, typename _Alloc>
    inline constexpr bool
      __is_path_src<basic_string<_CharT, _Traits, _Alloc>>
 = __is_encoded_char<_CharT>;

  template<typename _CharT, typename _Traits>
    inline constexpr bool
      __is_path_src<basic_string_view<_CharT, _Traits>>
 = __is_encoded_char<_CharT>;


  template<typename _Tp>
    using _Path = enable_if_t<__is_path_src<_Tp>, path>;


  template<typename _Iter, typename _Tr = __safe_iterator_traits<_Iter>>
    using _Path2 = enable_if_t<__is_path_iter_src<_Tr>, path>;


  template<typename _Iter>
    constexpr bool __is_contiguous = std::contiguous_iterator<_Iter>;





  template<typename _Tp>
    constexpr bool __is_contiguous<_Tp*> = true;

  template<typename _Tp, typename _Seq>
    constexpr bool
    __is_contiguous<__gnu_cxx::__normal_iterator<_Tp*, _Seq>> = true;



  template<typename _EcharT>
    using __unified_u8_t
      = __conditional_t<is_same_v<_EcharT, char8_t>, char, _EcharT>;
# 181 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/fs_path.h" 3
  template<typename _CharT, typename _Traits, typename _Alloc>
    inline basic_string_view<_CharT>
    __effective_range(const basic_string<_CharT, _Traits, _Alloc>& __source)
    noexcept
    { return __source; }

  template<typename _CharT, typename _Traits>
    inline basic_string_view<_CharT>
    __effective_range(const basic_string_view<_CharT, _Traits>& __source)
    noexcept
    { return __source; }


  template<typename _Source>
    auto
    __effective_range(const _Source& __source)
    {

      using _Iter = decltype(std::__niter_base(__source));
      using value_type = typename iterator_traits<_Iter>::value_type;

      if constexpr (__is_contiguous<_Iter>)
 return basic_string_view<value_type>{&*__source};
      else
 {


   basic_string<__unified_u8_t<value_type>> __str;
   _Source __it = __source;
   for (value_type __ch = *__it; __ch != value_type(); __ch = *++__it)
     __str.push_back(__ch);
   return __str;
 }
    }


  template<typename _Source>
    struct __source_value_type_impl
    {
      using type
 = typename __safe_iterator_traits<decay_t<_Source>>::value_type;
    };

  template<typename _CharT, typename _Traits, typename _Alloc>
    struct __source_value_type_impl<basic_string<_CharT, _Traits, _Alloc>>
    {
      using type = _CharT;
    };

  template<typename _CharT, typename _Traits>
    struct __source_value_type_impl<basic_string_view<_CharT, _Traits>>
    {
      using type = _CharT;
    };


  template<typename _Source>
    using __source_value_t = typename __source_value_type_impl<_Source>::type;




  template<typename _Tp, typename _Val = __source_value_t<_Tp>>
    using __value_type_is_char
      = std::enable_if_t<std::is_same_v<_Val, char>, _Val>;



  template<typename _Tp, typename _Val = __source_value_t<_Tp>>
    using __value_type_is_char_or_char8_t
      = std::enable_if_t<std::is_same_v<_Val, char>

    || std::is_same_v<_Val, char8_t>

    , _Val>;


  template<typename _InputIterator>
    inline auto
    __string_from_range(_InputIterator __first, _InputIterator __last)
    {
      using _EcharT
 = typename std::iterator_traits<_InputIterator>::value_type;
      static_assert(__is_encoded_char<_EcharT>);

      if constexpr (__is_contiguous<_InputIterator>)
 {

   if (auto __len = __last - __first) [[__likely__]]
     return basic_string_view<_EcharT>(&*__first, __len);
   return basic_string_view<_EcharT>();
 }
      else
 {

   return basic_string<__unified_u8_t<_EcharT>>(__first, __last);
 }
    }


}
# 293 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/fs_path.h" 3
  class path
  {
  public:
# 304 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/fs_path.h" 3
    using value_type = char;

    static constexpr value_type preferred_separator = '/';

    using string_type = std::basic_string<value_type>;


    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<typename _Source,
      typename _Require = __detail::_Path<_Source>>
      path(_Source const& __source, format = auto_format)
      : _M_pathname(_S_convert(__detail::__effective_range(__source)))
      { _M_split_cmpts(); }

    template<typename _InputIterator,
      typename _Require = __detail::_Path2<_InputIterator>>
      path(_InputIterator __first, _InputIterator __last, format = auto_format)
      : _M_pathname(_S_convert(__detail::__string_from_range(__first, __last)))
      { _M_split_cmpts(); }

    template<typename _Source,
      typename _Require = __detail::_Path<_Source>,
      typename _Require2 = __detail::__value_type_is_char<_Source>>
      path(_Source const& __src, const locale& __loc, format = auto_format)
      : _M_pathname(_S_convert_loc(__detail::__effective_range(__src), __loc))
      { _M_split_cmpts(); }

    template<typename _InputIterator,
      typename _Require = __detail::_Path2<_InputIterator>,
      typename _Req2 = __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<typename _Source>
      __detail::_Path<_Source>&
      operator=(_Source const& __source)
      { return *this = path(__source); }

    template<typename _Source>
      __detail::_Path<_Source>&
      assign(_Source const& __source)
      { return *this = path(__source); }

    template<typename _InputIterator>
      __detail::_Path2<_InputIterator>&
      assign(_InputIterator __first, _InputIterator __last)
      { return *this = path(__first, __last); }



    path& operator/=(const path& __p);

    template<typename _Source>
      __detail::_Path<_Source>&
      operator/=(_Source const& __source)
      {
 _M_append(_S_convert(__detail::__effective_range(__source)));
 return *this;
      }

    template<typename _Source>
      __detail::_Path<_Source>&
      append(_Source const& __source)
      {
 _M_append(_S_convert(__detail::__effective_range(__source)));
 return *this;
      }

    template<typename _InputIterator>
      __detail::_Path2<_InputIterator>&
      append(_InputIterator __first, _InputIterator __last)
      {
 _M_append(_S_convert(__detail::__string_from_range(__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<value_type> __x);

    template<typename _Source>
      __detail::_Path<_Source>&
      operator+=(_Source const& __x) { return concat(__x); }

    template<typename _CharT>
      __detail::_Path2<_CharT*>&
      operator+=(_CharT __x);

    template<typename _Source>
      __detail::_Path<_Source>&
      concat(_Source const& __x)
      {
 _M_concat(_S_convert(__detail::__effective_range(__x)));
 return *this;
      }

    template<typename _InputIterator>
      __detail::_Path2<_InputIterator>&
      concat(_InputIterator __first, _InputIterator __last)
      {
 _M_concat(_S_convert(__detail::__string_from_range(__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 _CharT, typename _Traits = std::char_traits<_CharT>,
      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 _CharT, typename _Traits = std::char_traits<_CharT>,
      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<value_type> __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 noexcept;
    iterator end() const noexcept;


    template<typename _CharT, typename _Traits>
      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<typename _CharT, typename _Traits>
      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 path::_S_compare(__lhs, __rhs) == 0; }



    friend strong_ordering
    operator<=>(const path& __lhs, const path& __rhs) noexcept
    { return path::_S_compare(__lhs, __rhs) <=> 0; }
# 591 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/fs_path.h" 3
    friend path operator/(const path& __lhs, const path& __rhs)
    {
      path __result(__lhs);
      __result /= __rhs;
      return __result;
    }

  private:
    enum class _Type : unsigned char {
      _Multi = 0, _Root_name, _Root_dir, _Filename
    };

    path(basic_string_view<value_type> __str, _Type __type);

    enum class _Split { _Stem, _Extension };

    void _M_append(basic_string_view<value_type>);
    void _M_concat(basic_string_view<value_type>);

    pair<const string_type*, size_t> _M_find_extension() const noexcept;





    template<typename _Tp>
      static auto
      _S_convert(_Tp __str)
      noexcept(is_same_v<typename _Tp::value_type, value_type>)
      {
 if constexpr (is_same_v<typename _Tp::value_type, value_type>)
   return __str;

 else if constexpr (is_same_v<_Tp, std::u8string>)



   return string_type(_S_convert(__str.data(),
     __str.data() + __str.size()));

 else
   return _S_convert(__str.data(), __str.data() + __str.size());
      }

    template<typename _EcharT>
      static auto
      _S_convert(const _EcharT* __first, const _EcharT* __last);




    static string_type
    _S_convert_loc(const char* __first, const char* __last,
     const std::locale& __loc);

    template<typename _Iter>
      static string_type
      _S_convert_loc(_Iter __first, _Iter __last, const std::locale& __loc)
      {
 const auto __s = __detail::__string_from_range(__first, __last);
 return _S_convert_loc(__s.data(), __s.data() + __s.size(), __loc);
      }

    template<typename _Tp>
      static string_type
      _S_convert_loc(const _Tp& __s, const std::locale& __loc)
      {
 return _S_convert_loc(__s.data(), __s.data() + __s.size(), __loc);
      }

    template<typename _CharT, typename _Traits, typename _Allocator>
      static basic_string<_CharT, _Traits, _Allocator>
      _S_str_convert(basic_string_view<value_type>, const _Allocator&);


    __attribute__((__always_inline__))
    static int
    _S_compare(const path& __lhs, const path& __rhs) noexcept;

    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<uintptr_t>(_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;

    template<typename _EcharT> struct _Codecvt;
  };




  inline void swap(path& __lhs, path& __rhs) noexcept { __lhs.swap(__rhs); }

  size_t hash_value(const path& __p) noexcept;
# 747 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/fs_path.h" 3
  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<const _Impl> _M_impl;
  };


namespace __detail
{
  [[noreturn]] inline void
  __throw_conversion_error()
  {
    (throw (filesystem_error( "Cannot convert character sequence", std::make_error_code(errc::illegal_byte_sequence))));


  }
# 802 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/fs_path.h" 3
}
# 812 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/fs_path.h" 3
  template<typename _InputIterator,
    typename _Require = __detail::_Path2<_InputIterator>,
    typename _CharT
      = __detail::__value_type_is_char_or_char8_t<_InputIterator>>
    __attribute__ ((__deprecated__ ("use '" "path(u8string(first, last))" "' instead")))
    inline path
    u8path(_InputIterator __first, _InputIterator __last)
    {
# 828 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/fs_path.h" 3
      return path{ __first, __last };

    }







  template<typename _Source,
    typename _Require = __detail::_Path<_Source>,
    typename _CharT = __detail::__value_type_is_char_or_char8_t<_Source>>
    __attribute__ ((__deprecated__ ("use '" "path((const char8_t*)&*source)" "' instead")))
    inline path
    u8path(const _Source& __source)
    {
# 853 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/fs_path.h" 3
      return path{ __source };

    }



  struct path::_Cmpt : path
  {
    _Cmpt(basic_string_view<value_type> __s, _Type __t, size_t __pos);

    _Cmpt() : _M_pos(-1) { }

    size_t _M_pos;
  };







  template<typename _EcharT>
    struct path::_Codecvt

    : std::codecvt<_EcharT, char, mbstate_t>
    { };
# 887 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/fs_path.h" 3
  template<>
    struct path::_Codecvt<wchar_t>
    : __conditional_t<sizeof(wchar_t) == sizeof(char32_t),
        std::codecvt_utf8<wchar_t>,
        std::codecvt_utf8_utf16<wchar_t>>
    { };

  template<typename _EcharT>
    auto
    path::_S_convert(const _EcharT* __f, const _EcharT* __l)
    {
      static_assert(__detail::__is_encoded_char<_EcharT>);







      if constexpr (is_same_v<_EcharT, value_type>)
 return basic_string_view<value_type>(__f, __l - __f);

      else if constexpr (is_same_v<_EcharT, char8_t>)
 {
   string_view __str(reinterpret_cast<const char*>(__f), __l - __f);
   return __str;
 }
# 924 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/fs_path.h" 3
      else
 {
   path::_Codecvt<_EcharT> __cvt;
   std::string __str;
   if (__str_codecvt_out_all(__f, __l, __str, __cvt))
     return __str;
 }
      __detail::__throw_conversion_error();
    }
# 942 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/fs_path.h" 3
  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() noexcept : _M_path(nullptr), _M_cur(), _M_at_end() { }

    iterator(const iterator&) = default;
    iterator& operator=(const iterator&) = default;

    reference operator*() const noexcept;
    pointer operator->() const noexcept { return std::__addressof(**this); }

    iterator& operator++() noexcept;

    iterator operator++(int) noexcept
    { auto __tmp = *this; ++*this; return __tmp; }

    iterator& operator--() noexcept;

    iterator operator--(int) noexcept
    { auto __tmp = *this; --*this; return __tmp; }

    friend bool
    operator==(const iterator& __lhs, const iterator& __rhs) noexcept
    { return __lhs._M_equals(__rhs); }

    friend bool
    operator!=(const iterator& __lhs, const iterator& __rhs) noexcept
    { return !__lhs._M_equals(__rhs); }

  private:
    friend class path;

    bool
    _M_is_multi() const noexcept
    { return _M_path->_M_type() == _Type::_Multi; }

    friend difference_type
    __path_iter_distance(const iterator& __first, const iterator& __last)
    noexcept
    {
      do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__first._M_path != nullptr), false)) std::__glibcxx_assert_fail(); } while (false);
      do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__first._M_path == __last._M_path), false)) std::__glibcxx_assert_fail(); } while (false);
      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) noexcept
    {
      if (__n == 1)
 ++__i;
      else if (__n == -1)
 --__i;
      else if (__n != 0)
 {
   do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__i._M_path != nullptr), false)) std::__glibcxx_assert_fail(); } while (false);
   do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__i._M_is_multi()), false)) std::__glibcxx_assert_fail(); } while (false);

   __i._M_cur += __n;
 }
    }

    iterator(const path* __path, path::_List::const_iterator __iter) noexcept
    : _M_path(__path), _M_cur(__iter), _M_at_end()
    { }

    iterator(const path* __path, bool __at_end) noexcept
    : _M_path(__path), _M_cur(), _M_at_end(__at_end)
    { }

    bool _M_equals(iterator) const noexcept;

    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<value_type>(&__x, 1));
    return *this;
  }

  inline path&
  path::operator+=(basic_string_view<value_type> __x)
  {
    _M_concat(__x);
    return *this;
  }

  template<typename _CharT>
    inline __detail::_Path2<_CharT*>&
    path::operator+=(const _CharT __x)
    {
      _M_concat(_S_convert(&__x, &__x + 1));
      return *this;
    }

  inline path&
  path::make_preferred()
  {
# 1097 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/fs_path.h" 3
    return *this;
  }

  inline void path::swap(path& __rhs) noexcept
  {
    _M_pathname.swap(__rhs._M_pathname);
    _M_cmpts.swap(__rhs._M_cmpts);
  }


  template<typename _CharT, typename _Traits, typename _Allocator>
    std::basic_string<_CharT, _Traits, _Allocator>
    path::_S_str_convert(basic_string_view<value_type> __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);


      string_view __u8str = __str;
# 1137 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/fs_path.h" 3
 {
   const char* __first = __u8str.data();
   const char* __last = __first + __u8str.size();



   if constexpr (is_same_v<_CharT, char8_t>)
     return _WString(__first, __last, __a);
   else

     {

       _WString __wstr(__a);
       path::_Codecvt<_CharT> __cvt;
       if (__str_codecvt_in_all(__first, __last, __wstr, __cvt))
  return __wstr;
     }
 }
      __detail::__throw_conversion_error();
    }


  template<typename _CharT, typename _Traits, typename _Allocator>
    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<char>(); }


  inline std::wstring
  path::wstring() const { return string<wchar_t>(); }



  inline std::u8string
  path::u8string() const { return string<char8_t>(); }
# 1199 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/fs_path.h" 3
  inline std::u16string
  path::u16string() const { return string<char16_t>(); }

  inline std::u32string
  path::u32string() const { return string<char32_t>(); }

  template<typename _CharT, typename _Traits, typename _Allocator>
    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<value_type>;
      basic_string<value_type, char_traits<value_type>, _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<value_type>(__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<char>(); }


  inline std::wstring
  path::generic_wstring() const
  { return generic_string<wchar_t>(); }



  inline std::u8string
  path::generic_u8string() const
  { return generic_string<char8_t>(); }






  inline std::u16string
  path::generic_u16string() const
  { return generic_string<char16_t>(); }

  inline std::u32string
  path::generic_u32string() const
  { return generic_string<char32_t>(); }

  inline int
  path::compare(const string_type& __s) const noexcept
  { return compare(basic_string_view<value_type>(__s)); }

  inline int
  path::compare(const value_type* __s) const noexcept
  { return compare(basic_string_view<value_type>(__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 noexcept
  {
    if (_M_type() == _Type::_Multi)
      return iterator(this, _M_cmpts.begin());
    return iterator(this, empty());
  }

  inline path::iterator
  path::end() const noexcept
  {
    if (_M_type() == _Type::_Multi)
      return iterator(this, _M_cmpts.end());
    return iterator(this, true);
  }

  inline path::iterator&
  path::iterator::operator++() noexcept
  {
    do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(_M_path != nullptr), false)) std::__glibcxx_assert_fail(); } while (false);
    if (_M_is_multi())
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(_M_cur != _M_path->_M_cmpts.end()), false)) std::__glibcxx_assert_fail(); } while (false);
 ++_M_cur;
      }
    else
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(!_M_at_end), false)) std::__glibcxx_assert_fail(); } while (false);
 _M_at_end = true;
      }
    return *this;
  }

  inline path::iterator&
  path::iterator::operator--() noexcept
  {
    do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(_M_path != nullptr), false)) std::__glibcxx_assert_fail(); } while (false);
    if (_M_is_multi())
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(_M_cur != _M_path->_M_cmpts.begin()), false)) std::__glibcxx_assert_fail(); } while (false);
 --_M_cur;
      }
    else
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(_M_at_end), false)) std::__glibcxx_assert_fail(); } while (false);
 _M_at_end = false;
      }
    return *this;
  }

  inline path::iterator::reference
  path::iterator::operator*() const noexcept
  {
    do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(_M_path != nullptr), false)) std::__glibcxx_assert_fail(); } while (false);
    if (_M_is_multi())
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(_M_cur != _M_path->_M_cmpts.end()), false)) std::__glibcxx_assert_fail(); } while (false);
 return *_M_cur;
      }
    return *_M_path;
  }

  inline bool
  path::iterator::_M_equals(iterator __rhs) const noexcept
  {
    if (_M_path != __rhs._M_path)
      return false;
    if (_M_path == nullptr)
      return true;
    if (_M_is_multi())
      return _M_cur == __rhs._M_cur;
    return _M_at_end == __rhs._M_at_end;
  }





  inline int
  path::_S_compare(const path& __lhs, const path& __rhs) noexcept
  { return __lhs.compare(__rhs); }


}
}



inline ptrdiff_t
distance(filesystem::path::iterator __first, filesystem::path::iterator __last)
noexcept
{ return __path_iter_distance(__first, __last); }

template<typename _Distance>
  inline void
  advance(filesystem::path::iterator& __i, _Distance __n) noexcept
  { __path_iter_advance(__i, static_cast<ptrdiff_t>(__n)); }

extern template class __shared_ptr<const filesystem::filesystem_error::_Impl>;





template<>
  struct hash<filesystem::path>
  {
    size_t
    operator()(const filesystem::path& __p) const noexcept
    { return filesystem::hash_value(__p); }
  };


}
# 53 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/filesystem" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/fs_dir.h" 1 3
# 44 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/fs_dir.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{


namespace filesystem
{
# 59 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/fs_dir.h" 3
  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; }
# 323 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/fs_dir.h" 3
  private:
    friend struct _Dir;
    friend class directory_iterator;
    friend class recursive_directory_iterator;



    template<typename _CharT, typename _Traits>
      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;
  };
# 372 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/fs_dir.h" 3
  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;
    }

    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);
    }




    bool operator==(default_sentinel_t) const noexcept
    { return !_M_dir; }
# 465 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/fs_dir.h" 3
  private:
    directory_iterator(const path&, directory_options, error_code*);

    friend class recursive_directory_iterator;

    std::__shared_ptr<_Dir> _M_dir;
  };
# 483 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/fs_dir.h" 3
  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;

    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);
    }




    bool operator==(default_sentinel_t) const noexcept
    { return !_M_dirs; }
# 581 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/fs_dir.h" 3
  private:
    recursive_directory_iterator(const path&, directory_options, error_code*);

    struct _Dir_stack;
    std::__shared_ptr<_Dir_stack> _M_dirs;

    recursive_directory_iterator&
    __erase(error_code* = nullptr);

    friend uintmax_t
    filesystem::remove_all(const path&, error_code&);
    friend uintmax_t
    filesystem::remove_all(const path&);
  };
# 606 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/fs_dir.h" 3
  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<filesystem::_Dir>;
  extern template class
    __shared_ptr<filesystem::recursive_directory_iterator::_Dir_stack>;


}
# 54 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/filesystem" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/fs_ops.h" 1 3
# 37 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/fs_ops.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{


namespace filesystem
{




  [[nodiscard]]
  path absolute(const path& __p);

  [[nodiscard]]
  path absolute(const path& __p, error_code& __ec);

  [[nodiscard]]
  path canonical(const path& __p);

  [[nodiscard]]
  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;

  [[nodiscard]]
  path current_path();

  [[nodiscard]]
  path current_path(error_code& __ec);

  void current_path(const path& __p);
  void current_path(const path& __p, error_code& __ec) noexcept;

  [[nodiscard]]
  bool
  equivalent(const path& __p1, const path& __p2);

  [[nodiscard]]
  bool
  equivalent(const path& __p1, const path& __p2, error_code& __ec) noexcept;

  [[nodiscard]]
  inline bool
  exists(file_status __s) noexcept
  { return status_known(__s) && __s.type() != file_type::not_found; }

  [[nodiscard]]
  inline bool
  exists(const path& __p)
  { return exists(status(__p)); }

  [[nodiscard]]
  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;
  }

  [[nodiscard]]
  uintmax_t file_size(const path& __p);

  [[nodiscard]]
  uintmax_t file_size(const path& __p, error_code& __ec) noexcept;

  [[nodiscard]]
  uintmax_t hard_link_count(const path& __p);

  [[nodiscard]]
  uintmax_t hard_link_count(const path& __p, error_code& __ec) noexcept;

  [[nodiscard]]
  inline bool
  is_block_file(file_status __s) noexcept
  { return __s.type() == file_type::block; }

  [[nodiscard]]
  inline bool
  is_block_file(const path& __p)
  { return is_block_file(status(__p)); }

  [[nodiscard]]
  inline bool
  is_block_file(const path& __p, error_code& __ec) noexcept
  { return is_block_file(status(__p, __ec)); }

  [[nodiscard]]
  inline bool
  is_character_file(file_status __s) noexcept
  { return __s.type() == file_type::character; }

  [[nodiscard]]
  inline bool
  is_character_file(const path& __p)
  { return is_character_file(status(__p)); }

  [[nodiscard]]
  inline bool
  is_character_file(const path& __p, error_code& __ec) noexcept
  { return is_character_file(status(__p, __ec)); }

  [[nodiscard]]
  inline bool
  is_directory(file_status __s) noexcept
  { return __s.type() == file_type::directory; }

  [[nodiscard]]
  inline bool
  is_directory(const path& __p)
  { return is_directory(status(__p)); }

  [[nodiscard]]
  inline bool
  is_directory(const path& __p, error_code& __ec) noexcept
  { return is_directory(status(__p, __ec)); }

  [[nodiscard]]
  bool is_empty(const path& __p);

  [[nodiscard]]
  bool is_empty(const path& __p, error_code& __ec);

  [[nodiscard]]
  inline bool
  is_fifo(file_status __s) noexcept
  { return __s.type() == file_type::fifo; }

  [[nodiscard]]
  inline bool
  is_fifo(const path& __p)
  { return is_fifo(status(__p)); }

  [[nodiscard]]
  inline bool
  is_fifo(const path& __p, error_code& __ec) noexcept
  { return is_fifo(status(__p, __ec)); }

  [[nodiscard]]
  inline bool
  is_other(file_status __s) noexcept
  {
    return exists(__s) && !is_regular_file(__s) && !is_directory(__s)
      && !is_symlink(__s);
  }

  [[nodiscard]]
  inline bool
  is_other(const path& __p)
  { return is_other(status(__p)); }

  [[nodiscard]]
  inline bool
  is_other(const path& __p, error_code& __ec) noexcept
  { return is_other(status(__p, __ec)); }

  [[nodiscard]]
  inline bool
  is_regular_file(file_status __s) noexcept
  { return __s.type() == file_type::regular; }

  [[nodiscard]]
  inline bool
  is_regular_file(const path& __p)
  { return is_regular_file(status(__p)); }

  [[nodiscard]]
  inline bool
  is_regular_file(const path& __p, error_code& __ec) noexcept
  { return is_regular_file(status(__p, __ec)); }

  [[nodiscard]]
  inline bool
  is_socket(file_status __s) noexcept
  { return __s.type() == file_type::socket; }

  [[nodiscard]]
  inline bool
  is_socket(const path& __p)
  { return is_socket(status(__p)); }

  [[nodiscard]]
  inline bool
  is_socket(const path& __p, error_code& __ec) noexcept
  { return is_socket(status(__p, __ec)); }

  [[nodiscard]]
  inline bool
  is_symlink(file_status __s) noexcept
  { return __s.type() == file_type::symlink; }

  [[nodiscard]]
  inline bool
  is_symlink(const path& __p)
  { return is_symlink(symlink_status(__p)); }

  [[nodiscard]]
  inline bool
  is_symlink(const path& __p, error_code& __ec) noexcept
  { return is_symlink(symlink_status(__p, __ec)); }

  [[nodiscard]]
  file_time_type last_write_time(const path& __p);

  [[nodiscard]]
  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;

  [[nodiscard]]
  inline path proximate(const path& __p, error_code& __ec)
  { return proximate(__p, current_path(), __ec); }

  [[nodiscard]]
  path proximate(const path& __p, const path& __base = current_path());

  [[nodiscard]]
  path proximate(const path& __p, const path& __base, error_code& __ec);

  [[nodiscard]]
  path read_symlink(const path& __p);

  [[nodiscard]]
  path read_symlink(const path& __p, error_code& __ec);

  [[nodiscard]]
  inline path relative(const path& __p, error_code& __ec)
  { return relative(__p, current_path(), __ec); }

  [[nodiscard]]
  path relative(const path& __p, const path& __base = current_path());

  [[nodiscard]]
  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;

  [[nodiscard]]
  space_info space(const path& __p);

  [[nodiscard]]
  space_info space(const path& __p, error_code& __ec) noexcept;

  [[nodiscard]]
  file_status status(const path& __p);

  [[nodiscard]]
  file_status status(const path& __p, error_code& __ec) noexcept;

  [[nodiscard]]
  inline bool status_known(file_status __s) noexcept
  { return __s.type() != file_type::none; }

  [[nodiscard]]
  file_status symlink_status(const path& __p);

  [[nodiscard]]
  file_status symlink_status(const path& __p, error_code& __ec) noexcept;

  [[nodiscard]]
  path temp_directory_path();

  [[nodiscard]]
  path temp_directory_path(error_code& __ec);

  [[nodiscard]]
  path weakly_canonical(const path& __p);

  [[nodiscard]]
  path weakly_canonical(const path& __p, error_code& __ec);


}


}
# 55 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/filesystem" 2 3
# 61 "/home/avi/scylla-maint/seastar/include/seastar/core/seastar.hh" 2




namespace seastar {




template <class CharType> class input_stream;
template <class CharType> class output_stream;

class server_socket;
class socket;
class connected_socket;
class socket_address;
struct listen_options;
enum class transport;


class file;
struct file_open_options;
struct stat_data;

namespace net {

using udp_channel = class datagram_channel;

}

namespace experimental {

class process;
struct spawn_parameters;
}
# 123 "/home/avi/scylla-maint/seastar/include/seastar/core/seastar.hh"
server_socket listen(socket_address sa);
# 135 "/home/avi/scylla-maint/seastar/include/seastar/core/seastar.hh"
server_socket listen(socket_address sa, listen_options opts);
# 144 "/home/avi/scylla-maint/seastar/include/seastar/core/seastar.hh"
future<connected_socket> connect(socket_address sa);
# 155 "/home/avi/scylla-maint/seastar/include/seastar/core/seastar.hh"
future<connected_socket> connect(socket_address sa, socket_address local, transport proto);





socket make_socket();







[[deprecated("Use `make_unbound_datagram_channel` instead")]]
net::udp_channel make_udp_channel();







[[deprecated("Use `make_bound_datagram_channel` instead")]]
net::udp_channel make_udp_channel(const socket_address& local);
# 196 "/home/avi/scylla-maint/seastar/include/seastar/core/seastar.hh"
net::datagram_channel make_unbound_datagram_channel(sa_family_t family);
# 206 "/home/avi/scylla-maint/seastar/include/seastar/core/seastar.hh"
net::datagram_channel make_bound_datagram_channel(const socket_address& local);
# 238 "/home/avi/scylla-maint/seastar/include/seastar/core/seastar.hh"
future<file> open_file_dma(std::string_view name, open_flags flags) noexcept;
# 253 "/home/avi/scylla-maint/seastar/include/seastar/core/seastar.hh"
future<file> open_file_dma(std::string_view name, open_flags flags, file_open_options options) noexcept;
# 269 "/home/avi/scylla-maint/seastar/include/seastar/core/seastar.hh"
future<> check_direct_io_support(std::string_view path) noexcept;
# 280 "/home/avi/scylla-maint/seastar/include/seastar/core/seastar.hh"
future<file> open_directory(std::string_view name) noexcept;
# 290 "/home/avi/scylla-maint/seastar/include/seastar/core/seastar.hh"
future<> make_directory(std::string_view name, file_permissions permissions = file_permissions::default_dir_permissions) noexcept;
# 304 "/home/avi/scylla-maint/seastar/include/seastar/core/seastar.hh"
future<> touch_directory(std::string_view name, file_permissions permissions = file_permissions::default_dir_permissions) noexcept;
# 318 "/home/avi/scylla-maint/seastar/include/seastar/core/seastar.hh"
future<> recursive_touch_directory(std::string_view name, file_permissions permissions = file_permissions::default_dir_permissions) noexcept;
# 327 "/home/avi/scylla-maint/seastar/include/seastar/core/seastar.hh"
future<> sync_directory(std::string_view name) noexcept;
# 337 "/home/avi/scylla-maint/seastar/include/seastar/core/seastar.hh"
future<> remove_file(std::string_view name) noexcept;
# 347 "/home/avi/scylla-maint/seastar/include/seastar/core/seastar.hh"
future<> rename_file(std::string_view old_name, std::string_view new_name) noexcept;

struct follow_symlink_tag { };
using follow_symlink = bool_class<follow_symlink_tag>;
# 360 "/home/avi/scylla-maint/seastar/include/seastar/core/seastar.hh"
future<stat_data> file_stat(std::string_view name, follow_symlink fs = follow_symlink::yes) noexcept;
# 369 "/home/avi/scylla-maint/seastar/include/seastar/core/seastar.hh"
future<uint64_t> file_size(std::string_view name) noexcept;
# 385 "/home/avi/scylla-maint/seastar/include/seastar/core/seastar.hh"
future<bool> file_accessible(std::string_view name, access_flags flags) noexcept;




future<bool> file_exists(std::string_view name) noexcept;
# 400 "/home/avi/scylla-maint/seastar/include/seastar/core/seastar.hh"
future<std::optional<directory_entry_type>> file_type(std::string_view name, follow_symlink follow = follow_symlink::yes) noexcept;







future<> link_file(std::string_view oldpath, std::string_view newpath) noexcept;






future<> chmod(std::string_view name, file_permissions permissions) noexcept;




future<fs_type> file_system_at(std::string_view name) noexcept;




future<uint64_t> fs_avail(std::string_view name) noexcept;




future<uint64_t> fs_free(std::string_view name) noexcept;


namespace experimental {
# 445 "/home/avi/scylla-maint/seastar/include/seastar/core/seastar.hh"
future<std::tuple<file_desc, file_desc>> make_pipe();
# 456 "/home/avi/scylla-maint/seastar/include/seastar/core/seastar.hh"
future<process> spawn_process(const std::filesystem::path& pathname,
                              spawn_parameters params);
# 466 "/home/avi/scylla-maint/seastar/include/seastar/core/seastar.hh"
future<process> spawn_process(const std::filesystem::path& pathname);

}



}
# 31 "/home/avi/scylla-maint/seastar/include/seastar/rpc/rpc.hh" 2
# 1 "/home/avi/scylla-maint/seastar/include/seastar/net/api.hh" 1
# 28 "/home/avi/scylla-maint/seastar/include/seastar/net/api.hh"
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 1 3
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 3


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 43 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 2 3
# 29 "/home/avi/scylla-maint/seastar/include/seastar/net/api.hh" 2






# 1 "/home/avi/scylla-maint/seastar/include/seastar/net/packet.hh" 1
# 26 "/home/avi/scylla-maint/seastar/include/seastar/net/packet.hh"
# 1 "/home/avi/scylla-maint/seastar/include/seastar/net/const.hh" 1
# 26 "/home/avi/scylla-maint/seastar/include/seastar/net/const.hh"
namespace seastar {

namespace net {

enum class ip_protocol_num : uint8_t {
    icmp = 1, tcp = 6, udp = 17, unused = 255
};

enum class eth_protocol_num : uint16_t {
    ipv4 = 0x0800, arp = 0x0806, ipv6 = 0x86dd
};

const uint8_t eth_hdr_len = 14;
const uint8_t tcp_hdr_len_min = 20;
const uint8_t ipv4_hdr_len_min = 20;
const uint8_t ipv6_hdr_len_min = 40;
const uint16_t ip_packet_len_max = 65535;

}

}
# 27 "/home/avi/scylla-maint/seastar/include/seastar/net/packet.hh" 2




# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 1 3
# 42 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 3


# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 45 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 2 3
# 32 "/home/avi/scylla-maint/seastar/include/seastar/net/packet.hh" 2








namespace seastar {

namespace net {



struct fragment {
    char* base;
    size_t size;
};

struct offload_info {
    ip_protocol_num protocol = ip_protocol_num::unused;
    bool needs_csum = false;
    uint8_t ip_hdr_len = 20;
    uint8_t tcp_hdr_len = 20;
    uint8_t udp_hdr_len = 8;
    bool needs_ip_csum = false;
    bool reassembled = false;
    uint16_t tso_seg_size = 0;

    std::optional<uint16_t> vlan_tci;
};
# 87 "/home/avi/scylla-maint/seastar/include/seastar/net/packet.hh"
class packet final {

    static constexpr size_t internal_data_size = 128 - 16;
    static constexpr size_t default_nr_frags = 4;

    struct pseudo_vector {
        fragment* _start;
        fragment* _finish;
        pseudo_vector(fragment* start, size_t nr) noexcept
            : _start(start), _finish(_start + nr) {}
        fragment* begin() noexcept { return _start; }
        fragment* end() noexcept { return _finish; }
        fragment& operator[](size_t idx) noexcept { return _start[idx]; }
    };

    struct impl {

        deleter _deleter;
        unsigned _len = 0;
        uint16_t _nr_frags = 0;
        uint16_t _allocated_frags;
        offload_info _offload_info;
        std::optional<uint32_t> _rss_hash;
        char _data[internal_data_size];
        unsigned _headroom = internal_data_size;


        fragment _frags[];

        impl(size_t nr_frags = default_nr_frags) noexcept;
        impl(const impl&) = delete;
        impl(fragment frag, size_t nr_frags = default_nr_frags);

        pseudo_vector fragments() noexcept { return { _frags, _nr_frags }; }

        static std::unique_ptr<impl> allocate(size_t nr_frags) {
            nr_frags = std::max(nr_frags, default_nr_frags);
            return std::unique_ptr<impl>(new (nr_frags) impl(nr_frags));
        }

        static std::unique_ptr<impl> copy(impl* old, size_t nr) {
            auto n = allocate(nr);
            n->_deleter = std::move(old->_deleter);
            n->_len = old->_len;
            n->_nr_frags = old->_nr_frags;
            n->_headroom = old->_headroom;
            n->_offload_info = old->_offload_info;
            n->_rss_hash = old->_rss_hash;
            std::copy(old->_frags, old->_frags + old->_nr_frags, n->_frags);
            old->copy_internal_fragment_to(n.get());
            return n;
        }

        static std::unique_ptr<impl> copy(impl* old) {
            return copy(old, old->_nr_frags);
        }

        static std::unique_ptr<impl> allocate_if_needed(std::unique_ptr<impl> old, size_t extra_frags) {
            if (old->_allocated_frags >= old->_nr_frags + extra_frags) {
                return old;
            }
            return copy(old.get(), std::max<size_t>(old->_nr_frags + extra_frags, 2 * old->_nr_frags));
        }
        void* operator new(size_t size, size_t nr_frags = default_nr_frags) {
            (static_cast <bool> (nr_frags == uint16_t(nr_frags)) ? void (0) : __assert_fail ("nr_frags == uint16_t(nr_frags)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
            return ::operator new(size + nr_frags * sizeof(fragment));
        }

        void operator delete(void* ptr, size_t) {
            return ::operator delete(ptr);
        }

        void operator delete(void* ptr) {
            return ::operator delete(ptr);
        }

        bool using_internal_data() const noexcept {
            return _nr_frags
                    && _frags[0].base >= _data
                    && _frags[0].base < _data + internal_data_size;
        }

        void unuse_internal_data() {
            if (!using_internal_data()) {
                return;
            }
            auto buf = static_cast<char*>(::malloc(_frags[0].size));
            if (!buf) {
                throw std::bad_alloc();
            }
            deleter d = make_free_deleter(buf);
            std::copy(_frags[0].base, _frags[0].base + _frags[0].size, buf);
            _frags[0].base = buf;
            d.append(std::move(_deleter));
            _deleter = std::move(d);
            _headroom = internal_data_size;
        }
        void copy_internal_fragment_to(impl* to) noexcept {
            if (!using_internal_data()) {
                return;
            }
            to->_frags[0].base = to->_data + _headroom;
            std::copy(_frags[0].base, _frags[0].base + _frags[0].size,
                    to->_frags[0].base);
        }
    };
    packet(std::unique_ptr<impl>&& impl) noexcept : _impl(std::move(impl)) {}
    std::unique_ptr<impl> _impl;
public:
    static packet from_static_data(const char* data, size_t len) noexcept {
        return {fragment{const_cast<char*>(data), len}, deleter()};
    }


    packet();

    packet(size_t nr_frags);

    packet(packet&& x) noexcept;

    packet(const char* data, size_t len);

    packet(fragment frag);

    packet(fragment frag, deleter del);

    packet(std::vector<fragment> frag, deleter del);

    template <typename Iterator>
    packet(Iterator begin, Iterator end, deleter del);

    packet(packet&& x, fragment frag);

    packet(fragment frag, packet&& x);

    packet(fragment frag, deleter del, packet&& x);

    packet(packet&& x, fragment frag, deleter d);

    packet(packet&& x, temporary_buffer<char> buf);

    packet(temporary_buffer<char> buf);

    packet(packet&& x, deleter d);

    packet& operator=(packet&& x) noexcept {
        if (this != &x) {
            this->~packet();
            new (this) packet(std::move(x));
        }
        return *this;
    }

    unsigned len() const noexcept { return _impl->_len; }
    unsigned memory() const noexcept { return len() + sizeof(packet::impl); }

    fragment frag(unsigned idx) const noexcept { return _impl->_frags[idx]; }
    fragment& frag(unsigned idx) noexcept { return _impl->_frags[idx]; }

    unsigned nr_frags() const noexcept { return _impl->_nr_frags; }
    pseudo_vector fragments() const noexcept { return { _impl->_frags, _impl->_nr_frags }; }
    fragment* fragment_array() const noexcept { return _impl->_frags; }


    packet share();
    packet share(size_t offset, size_t len);

    void append(packet&& p);

    void trim_front(size_t how_much) noexcept;
    void trim_back(size_t how_much) noexcept;


    template <typename Header>
    Header* get_header(size_t offset = 0);


    char* get_header(size_t offset, size_t size);


    template <typename Header>
    Header* prepend_header(size_t extra_size = 0);


    char* prepend_uninitialized_header(size_t size);

    packet free_on_cpu(unsigned cpu, std::function<void()> cb = []{});

    void linearize() { return linearize(0, len()); }

    void reset() noexcept { _impl.reset(); }

    void reserve(int n_frags) {
        if (n_frags > _impl->_nr_frags) {
            auto extra = n_frags - _impl->_nr_frags;
            _impl = impl::allocate_if_needed(std::move(_impl), extra);
        }
    }
    std::optional<uint32_t> rss_hash() const noexcept {
        return _impl->_rss_hash;
    }
    std::optional<uint32_t> set_rss_hash(uint32_t hash) noexcept {
        return _impl->_rss_hash = hash;
    }


    template <typename Func>
    void release_into(Func&& func) {
        unsigned idx = 0;
        if (_impl->using_internal_data()) {
            auto&& f = frag(idx++);
            func(temporary_buffer<char>(f.base, f.size));
        }
        while (idx < nr_frags()) {
            auto&& f = frag(idx++);
            func(temporary_buffer<char>(f.base, f.size, _impl->_deleter.share()));
        }
    }
    std::vector<temporary_buffer<char>> release() {
        std::vector<temporary_buffer<char>> ret;
        ret.reserve(_impl->_nr_frags);
        release_into([&ret] (temporary_buffer<char>&& frag) {
            ret.push_back(std::move(frag));
        });
        return ret;
    }
    explicit operator bool() noexcept {
        return bool(_impl);
    }
    static packet make_null_packet() noexcept {
        return net::packet(nullptr);
    }
private:
    void linearize(size_t at_frag, size_t desired_size);
    bool allocate_headroom(size_t size);
public:
    struct offload_info get_offload_info() const noexcept { return _impl->_offload_info; }
    struct offload_info& offload_info_ref() noexcept { return _impl->_offload_info; }
    void set_offload_info(struct offload_info oi) noexcept { _impl->_offload_info = oi; }
};

std::ostream& operator<<(std::ostream& os, const packet& p);



inline
packet::packet(packet&& x) noexcept
    : _impl(std::move(x._impl)) {
}

inline
packet::impl::impl(size_t nr_frags) noexcept
    : _len(0), _allocated_frags(nr_frags) {
}

inline
packet::impl::impl(fragment frag, size_t nr_frags)
    : _len(frag.size), _allocated_frags(nr_frags) {
    (static_cast <bool> (_allocated_frags > _nr_frags) ? void (0) : __assert_fail ("_allocated_frags > _nr_frags", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
    if (frag.size <= internal_data_size) {
        _headroom -= frag.size;
        _frags[0] = { _data + _headroom, frag.size };
    } else {
        auto buf = static_cast<char*>(::malloc(frag.size));
        if (!buf) {
            throw std::bad_alloc();
        }
        deleter d = make_free_deleter(buf);
        _frags[0] = { buf, frag.size };
        _deleter.append(std::move(d));
    }
    std::copy(frag.base, frag.base + frag.size, _frags[0].base);
    ++_nr_frags;
}

inline
packet::packet()
    : _impl(impl::allocate(1)) {
}

inline
packet::packet(size_t nr_frags)
    : _impl(impl::allocate(nr_frags)) {
}

inline
packet::packet(fragment frag) : _impl(new impl(frag)) {
}

inline
packet::packet(const char* data, size_t size) : packet(fragment{const_cast<char*>(data), size}) {
}

inline
packet::packet(fragment frag, deleter d)
    : _impl(impl::allocate(1)) {
    _impl->_deleter = std::move(d);
    _impl->_frags[_impl->_nr_frags++] = frag;
    _impl->_len = frag.size;
}

inline
packet::packet(std::vector<fragment> frag, deleter d)
    : _impl(impl::allocate(frag.size())) {
    _impl->_deleter = std::move(d);
    std::copy(frag.begin(), frag.end(), _impl->_frags);
    _impl->_nr_frags = frag.size();
    _impl->_len = 0;
    for (auto&& f : _impl->fragments()) {
        _impl->_len += f.size;
    }
}

template <typename Iterator>
inline
packet::packet(Iterator begin, Iterator end, deleter del) {
    unsigned nr_frags = 0, len = 0;
    nr_frags = std::distance(begin, end);
    std::for_each(begin, end, [&] (const fragment& frag) { len += frag.size; });
    _impl = impl::allocate(nr_frags);
    _impl->_deleter = std::move(del);
    _impl->_len = len;
    _impl->_nr_frags = nr_frags;
    std::copy(begin, end, _impl->_frags);
}

inline
packet::packet(packet&& x, fragment frag)
    : _impl(impl::allocate_if_needed(std::move(x._impl), 1)) {
    _impl->_len += frag.size;
    std::unique_ptr<char[]> buf(new char[frag.size]);
    std::copy(frag.base, frag.base + frag.size, buf.get());
    _impl->_frags[_impl->_nr_frags++] = {buf.get(), frag.size};
    _impl->_deleter = make_deleter(std::move(_impl->_deleter), [buf = buf.release()] {
        delete[] buf;
    });
}

inline
bool
packet::allocate_headroom(size_t size) {
    if (_impl->_headroom >= size) {
        _impl->_len += size;
        if (!_impl->using_internal_data()) {
            _impl = impl::allocate_if_needed(std::move(_impl), 1);
            std::copy_backward(_impl->_frags, _impl->_frags + _impl->_nr_frags,
                    _impl->_frags + _impl->_nr_frags + 1);
            _impl->_frags[0] = { _impl->_data + internal_data_size, 0 };
            ++_impl->_nr_frags;
        }
        _impl->_headroom -= size;
        _impl->_frags[0].base -= size;
        _impl->_frags[0].size += size;
        return true;
    } else {
        return false;
    }
}


inline
packet::packet(fragment frag, packet&& x)
    : _impl(std::move(x._impl)) {

    if (allocate_headroom(frag.size)) {
        std::copy(frag.base, frag.base + frag.size, _impl->_frags[0].base);
        return;
    } else {

        _impl->unuse_internal_data();
        _impl = impl::allocate_if_needed(std::move(_impl), 1);
        _impl->_len += frag.size;
        std::unique_ptr<char[]> buf(new char[frag.size]);
        std::copy(frag.base, frag.base + frag.size, buf.get());
        std::copy_backward(_impl->_frags, _impl->_frags + _impl->_nr_frags,
                _impl->_frags + _impl->_nr_frags + 1);
        ++_impl->_nr_frags;
        _impl->_frags[0] = {buf.get(), frag.size};
        _impl->_deleter = make_deleter(std::move(_impl->_deleter),
                [buf = std::move(buf)] {});
    }
}

inline
packet::packet(packet&& x, fragment frag, deleter d)
    : _impl(impl::allocate_if_needed(std::move(x._impl), 1)) {
    _impl->_len += frag.size;
    _impl->_frags[_impl->_nr_frags++] = frag;
    d.append(std::move(_impl->_deleter));
    _impl->_deleter = std::move(d);
}

inline
packet::packet(packet&& x, deleter d)
    : _impl(std::move(x._impl)) {
    _impl->_deleter.append(std::move(d));
}

inline
packet::packet(packet&& x, temporary_buffer<char> buf)
    : packet(std::move(x), fragment{buf.get_write(), buf.size()}, buf.release()) {
}

inline
packet::packet(temporary_buffer<char> buf)
    : packet(fragment{buf.get_write(), buf.size()}, buf.release()) {}

inline
void packet::append(packet&& p) {
    if (!_impl->_len) {
        *this = std::move(p);
        return;
    }
    _impl = impl::allocate_if_needed(std::move(_impl), p._impl->_nr_frags);
    _impl->_len += p._impl->_len;
    p._impl->unuse_internal_data();
    std::copy(p._impl->_frags, p._impl->_frags + p._impl->_nr_frags,
            _impl->_frags + _impl->_nr_frags);
    _impl->_nr_frags += p._impl->_nr_frags;
    p._impl->_deleter.append(std::move(_impl->_deleter));
    _impl->_deleter = std::move(p._impl->_deleter);
}

inline
char* packet::get_header(size_t offset, size_t size) {
    if (offset + size > _impl->_len) {
        return nullptr;
    }
    size_t i = 0;
    while (i != _impl->_nr_frags && offset >= _impl->_frags[i].size) {
        offset -= _impl->_frags[i++].size;
    }
    if (i == _impl->_nr_frags) {
        return nullptr;
    }
    if (offset + size > _impl->_frags[i].size) {
        linearize(i, offset + size);
    }
    return _impl->_frags[i].base + offset;
}

template <typename Header>
inline
Header* packet::get_header(size_t offset) {
    return reinterpret_cast<Header*>(get_header(offset, sizeof(Header)));
}

inline
void packet::trim_front(size_t how_much) noexcept {
    (static_cast <bool> (how_much <= _impl->_len) ? void (0) : __assert_fail ("how_much <= _impl->_len", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
    _impl->_len -= how_much;
    size_t i = 0;
    while (how_much && how_much >= _impl->_frags[i].size) {
        how_much -= _impl->_frags[i++].size;
    }
    std::copy(_impl->_frags + i, _impl->_frags + _impl->_nr_frags, _impl->_frags);
    _impl->_nr_frags -= i;
    if (!_impl->using_internal_data()) {
        _impl->_headroom = internal_data_size;
    }
    if (how_much) {
        if (_impl->using_internal_data()) {
            _impl->_headroom += how_much;
        }
        _impl->_frags[0].base += how_much;
        _impl->_frags[0].size -= how_much;
    }
}

inline
void packet::trim_back(size_t how_much) noexcept {
    (static_cast <bool> (how_much <= _impl->_len) ? void (0) : __assert_fail ("how_much <= _impl->_len", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
    _impl->_len -= how_much;
    size_t i = _impl->_nr_frags - 1;
    while (how_much && how_much >= _impl->_frags[i].size) {
        how_much -= _impl->_frags[i--].size;
    }
    _impl->_nr_frags = i + 1;
    if (how_much) {
        _impl->_frags[i].size -= how_much;
        if (i == 0 && _impl->using_internal_data()) {
            _impl->_headroom += how_much;
        }
    }
}

template <typename Header>
Header*
packet::prepend_header(size_t extra_size) {
    auto h = prepend_uninitialized_header(sizeof(Header) + extra_size);
    return new (h) Header{};
}


inline
char* packet::prepend_uninitialized_header(size_t size) {
    if (!allocate_headroom(size)) {

        _impl->unuse_internal_data();

        if (!allocate_headroom(size)) {

            _impl->_len += size;
            _impl = impl::allocate_if_needed(std::move(_impl), 1);
            std::unique_ptr<char[]> buf(new char[size]);
            std::copy_backward(_impl->_frags, _impl->_frags + _impl->_nr_frags,
                    _impl->_frags + _impl->_nr_frags + 1);
            ++_impl->_nr_frags;
            _impl->_frags[0] = {buf.get(), size};
            _impl->_deleter = make_deleter(std::move(_impl->_deleter),
                    [buf = std::move(buf)] {});
        }
    }
    return _impl->_frags[0].base;
}

inline
packet packet::share() {
    return share(0, _impl->_len);
}

inline
packet packet::share(size_t offset, size_t len) {
    _impl->unuse_internal_data();
    packet n;
    n._impl = impl::allocate_if_needed(std::move(n._impl), _impl->_nr_frags);
    size_t idx = 0;
    while (offset > 0 && offset >= _impl->_frags[idx].size) {
        offset -= _impl->_frags[idx++].size;
    }
    while (n._impl->_len < len) {
        auto& f = _impl->_frags[idx++];
        auto fsize = std::min(len - n._impl->_len, f.size - offset);
        n._impl->_frags[n._impl->_nr_frags++] = { f.base + offset, fsize };
        n._impl->_len += fsize;
        offset = 0;
    }
    n._impl->_offload_info = _impl->_offload_info;
    (static_cast <bool> (!n._impl->_deleter) ? void (0) : __assert_fail ("!n._impl->_deleter", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
    n._impl->_deleter = _impl->_deleter.share();
    return n;
}

}

}
# 36 "/home/avi/scylla-maint/seastar/include/seastar/net/api.hh" 2



# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/iostream.hh" 1
# 40 "/home/avi/scylla-maint/seastar/include/seastar/core/iostream.hh"
# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/scattered_message.hh" 1
# 31 "/home/avi/scylla-maint/seastar/include/seastar/core/scattered_message.hh"
namespace seastar {


template <typename CharType>
class scattered_message {
private:
    using fragment = net::fragment;
    using packet = net::packet;
    using char_type = CharType;
    packet _p;
public:
    scattered_message() {}
    scattered_message(scattered_message&&) = default;
    scattered_message(const scattered_message&) = delete;

    void append_static(const char_type* buf, size_t size) {
        if (size) {
            _p = packet(std::move(_p), fragment{(char_type*)buf, size}, deleter());
        }
    }

    template <size_t N>
    void append_static(const char_type(&s)[N]) {
        append_static(s, N - 1);
    }

    void append_static(const char_type* s) {
        append_static(s, strlen(s));
    }

    template <typename size_type, size_type max_size>
    void append_static(const basic_sstring<char_type, size_type, max_size>& s) {
        append_static(s.begin(), s.size());
    }

    void append_static(const std::string_view& s) {
        append_static(s.data(), s.size());
    }

    void append(std::string_view v) {
        if (v.size()) {
            _p = packet(std::move(_p), temporary_buffer<char>::copy_of(v));
        }
    }

    void append(temporary_buffer<CharType> buff) {
        if (buff.size()) {
            _p = packet(std::move(_p), std::move(buff));
        }
    }

    template <typename size_type, size_type max_size>
    void append(basic_sstring<char_type, size_type, max_size> s) {
        if (s.size()) {
            _p = packet(std::move(_p), std::move(s).release());
        }
    }

    template <typename size_type, size_type max_size, typename Callback>
    void append(const basic_sstring<char_type, size_type, max_size>& s, Callback callback) {
        if (s.size()) {
            _p = packet(std::move(_p), fragment{s.begin(), s.size()}, make_deleter(std::move(callback)));
        }
    }

    void reserve(int n_frags) {
        _p.reserve(n_frags);
    }

    packet release() && {
        return std::move(_p);
    }

    template <typename Callback>
    void on_delete(Callback callback) {
        _p = packet(std::move(_p), make_deleter(std::move(callback)));
    }

    operator bool() const {
        return _p.len();
    }

    size_t size() {
        return _p.len();
    }
};

}
# 41 "/home/avi/scylla-maint/seastar/include/seastar/core/iostream.hh" 2



# 1 "/usr/include/boost/intrusive/slist.hpp" 1 3 4
# 17 "/usr/include/boost/intrusive/slist.hpp" 3 4
# 1 "/usr/include/boost/intrusive/detail/config_begin.hpp" 1 3 4
# 18 "/usr/include/boost/intrusive/slist.hpp" 2 3 4



# 1 "/usr/include/boost/intrusive/slist_hook.hpp" 1 3 4
# 17 "/usr/include/boost/intrusive/slist_hook.hpp" 3 4
# 1 "/usr/include/boost/intrusive/detail/config_begin.hpp" 1 3 4
# 18 "/usr/include/boost/intrusive/slist_hook.hpp" 2 3 4


# 1 "/usr/include/boost/intrusive/detail/slist_node.hpp" 1 3 4
# 25 "/usr/include/boost/intrusive/detail/slist_node.hpp" 3 4
# 1 "/usr/include/boost/intrusive/detail/config_begin.hpp" 1 3 4
# 26 "/usr/include/boost/intrusive/detail/slist_node.hpp" 2 3 4



namespace boost {
namespace intrusive {

template<class VoidPointer>
struct slist_node
{
   typedef typename pointer_rebind<VoidPointer, slist_node>::type node_ptr;
   node_ptr next_;
};




template<class VoidPointer>
struct slist_node_traits
{
   typedef slist_node<VoidPointer> node;
   typedef typename node::node_ptr node_ptr;
   typedef typename pointer_rebind<VoidPointer, const node>::type const_node_ptr;

   inline __attribute__ ((__always_inline__)) static node_ptr get_next(const_node_ptr n)
   { return n->next_; }

   inline __attribute__ ((__always_inline__)) static node_ptr get_next(node_ptr n)
   { return n->next_; }

   inline __attribute__ ((__always_inline__)) static void set_next(node_ptr n, node_ptr next)
   { n->next_ = next; }
};

}
}

# 1 "/usr/include/boost/intrusive/detail/config_end.hpp" 1 3 4
# 63 "/usr/include/boost/intrusive/detail/slist_node.hpp" 2 3 4
# 21 "/usr/include/boost/intrusive/slist_hook.hpp" 2 3 4
# 1 "/usr/include/boost/intrusive/circular_slist_algorithms.hpp" 1 3 4
# 18 "/usr/include/boost/intrusive/circular_slist_algorithms.hpp" 3 4
# 1 "/usr/include/boost/intrusive/detail/config_begin.hpp" 1 3 4
# 19 "/usr/include/boost/intrusive/circular_slist_algorithms.hpp" 2 3 4

# 1 "/usr/include/boost/intrusive/detail/common_slist_algorithms.hpp" 1 3 4
# 30 "/usr/include/boost/intrusive/detail/common_slist_algorithms.hpp" 3 4
namespace boost {
namespace intrusive {
namespace detail {

template<class NodeTraits>
class common_slist_algorithms
{
   public:
   typedef typename NodeTraits::node node;
   typedef typename NodeTraits::node_ptr node_ptr;
   typedef typename NodeTraits::const_node_ptr const_node_ptr;
   typedef NodeTraits node_traits;

   static node_ptr get_previous_node(node_ptr p, node_ptr this_node)
   {
      for( node_ptr p_next
         ; this_node != (p_next = NodeTraits::get_next(p))
         ; p = p_next){


         (static_cast <bool> (p) ? void (0) : __assert_fail ("p", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      }
      return p;
   }

   inline __attribute__ ((__always_inline__)) static void init(node_ptr this_node) noexcept
   { NodeTraits::set_next(this_node, node_ptr()); }

   static bool unique(const_node_ptr this_node) noexcept
   {
      node_ptr next = NodeTraits::get_next(this_node);
      return !next || next == this_node;
   }

   inline __attribute__ ((__always_inline__)) static bool inited(const_node_ptr this_node) noexcept
   { return !NodeTraits::get_next(this_node); }

   inline __attribute__ ((__always_inline__)) static void unlink_after(node_ptr prev_node) noexcept
   {
      const_node_ptr this_node(NodeTraits::get_next(prev_node));
      NodeTraits::set_next(prev_node, NodeTraits::get_next(this_node));
   }

   inline __attribute__ ((__always_inline__)) static void unlink_after(node_ptr prev_node, node_ptr last_node) noexcept
   { NodeTraits::set_next(prev_node, last_node); }

   static void link_after(node_ptr prev_node, node_ptr this_node) noexcept
   {
      NodeTraits::set_next(this_node, NodeTraits::get_next(prev_node));
      NodeTraits::set_next(prev_node, this_node);
   }

   static void incorporate_after(node_ptr bp, node_ptr b, node_ptr be) noexcept
   {
      node_ptr p(NodeTraits::get_next(bp));
      NodeTraits::set_next(bp, b);
      NodeTraits::set_next(be, p);
   }

   static void transfer_after(node_ptr bp, node_ptr bb, node_ptr be) noexcept
   {
      if (bp != bb && bp != be && bb != be) {
         node_ptr next_b = NodeTraits::get_next(bb);
         node_ptr next_e = NodeTraits::get_next(be);
         node_ptr next_p = NodeTraits::get_next(bp);
         NodeTraits::set_next(bb, next_e);
         NodeTraits::set_next(be, next_p);
         NodeTraits::set_next(bp, next_b);
      }
   }

   struct stable_partition_info
   {
      std::size_t num_1st_partition;
      std::size_t num_2nd_partition;
      node_ptr beg_2st_partition;
      node_ptr new_last_node;
   };

   template<class Pred>
   static void stable_partition(node_ptr before_beg, node_ptr end, Pred pred, stable_partition_info &info)
   {
      node_ptr bcur = before_beg;
      node_ptr cur = node_traits::get_next(bcur);
      node_ptr new_f = end;

      std::size_t num1 = 0, num2 = 0;
      while(cur != end){
         if(pred(cur)){
            ++num1;
            bcur = cur;
            cur = node_traits::get_next(cur);
         }
         else{
            ++num2;
            node_ptr last_to_remove = bcur;
            new_f = cur;
            bcur = cur;
            cur = node_traits::get_next(cur);
            { try{

               while(cur != end){
                  if(pred(cur)){
                     ++num1;

                     node_traits::set_next(last_to_remove, cur);
                     last_to_remove = cur;
                     node_ptr nxt = node_traits::get_next(cur);
                     node_traits::set_next(bcur, nxt);
                     cur = nxt;
                  }
                  else{
                     ++num2;
                     bcur = cur;
                     cur = node_traits::get_next(cur);
                  }
               }
            }
            catch(...){
               node_traits::set_next(last_to_remove, new_f);
               throw;;
            }
            }
            node_traits::set_next(last_to_remove, new_f);
            break;
         }
      }
      info.num_1st_partition = num1;
      info.num_2nd_partition = num2;
      info.beg_2st_partition = new_f;
      info.new_last_node = bcur;
   }
# 170 "/usr/include/boost/intrusive/detail/common_slist_algorithms.hpp" 3 4
   static std::size_t distance(const_node_ptr f, const_node_ptr l) noexcept
   {
      const_node_ptr i(f);
      std::size_t result = 0;
      while(i != l){
         i = NodeTraits::get_next(i);
         ++result;
      }
      return result;
   }
# 193 "/usr/include/boost/intrusive/detail/common_slist_algorithms.hpp" 3 4
   template<class Disposer>
   static std::size_t unlink_after_and_dispose(node_ptr bb, node_ptr e, Disposer disposer) noexcept
   {
      std::size_t n = 0u;
      node_ptr i = node_traits::get_next(bb);
      while (i != e) {
         node_ptr to_erase(i);
         i = node_traits::get_next(i);
         disposer(to_erase);
         ++n;
      }
      node_traits::set_next(bb, e);
      return n;
   }
# 218 "/usr/include/boost/intrusive/detail/common_slist_algorithms.hpp" 3 4
   template<class Disposer>
   inline __attribute__ ((__always_inline__)) static void unlink_after_and_dispose(node_ptr bb, Disposer disposer) noexcept
   {
      node_ptr i = node_traits::get_next(bb);
      node_traits::set_next(bb, node_traits::get_next(i));
      disposer(i);
   }
# 236 "/usr/include/boost/intrusive/detail/common_slist_algorithms.hpp" 3 4
   template<class Disposer>
   static std::size_t detach_and_dispose(node_ptr p, Disposer disposer) noexcept
   {
      std::size_t n = 0;
      node_ptr i = node_traits::get_next(p);
      while ( i != p || i != node_ptr() ) {
         node_ptr to_erase(i);
         i = node_traits::get_next(i);
         disposer(to_erase);
      }
      node_traits::set_next(p, i);
      return n;
   }
};



}



template<class NodeTraits>
struct get_algo<CommonSListAlgorithms, NodeTraits>
{
   typedef detail::common_slist_algorithms<NodeTraits> type;
};


}
}
# 21 "/usr/include/boost/intrusive/circular_slist_algorithms.hpp" 2 3 4







namespace boost {
namespace intrusive {
# 52 "/usr/include/boost/intrusive/circular_slist_algorithms.hpp" 3 4
template<class NodeTraits>
class circular_slist_algorithms

   : public detail::common_slist_algorithms<NodeTraits>

{

   typedef detail::common_slist_algorithms<NodeTraits> base_t;

   public:
   typedef typename NodeTraits::node node;
   typedef typename NodeTraits::node_ptr node_ptr;
   typedef typename NodeTraits::const_node_ptr const_node_ptr;
   typedef NodeTraits node_traits;
# 138 "/usr/include/boost/intrusive/circular_slist_algorithms.hpp" 3 4
   using base_t::transfer_after;
# 149 "/usr/include/boost/intrusive/circular_slist_algorithms.hpp" 3 4
   inline __attribute__ ((__always_inline__)) static void init_header(node_ptr this_node) noexcept
   { NodeTraits::set_next(this_node, this_node); }
# 159 "/usr/include/boost/intrusive/circular_slist_algorithms.hpp" 3 4
   inline __attribute__ ((__always_inline__)) static node_ptr end_node(const_node_ptr p) noexcept
   { return detail::uncast(p); }






   inline __attribute__ ((__always_inline__)) static bool is_empty(const_node_ptr this_node) noexcept
   { return NodeTraits::get_next(this_node) == this_node; }






   inline __attribute__ ((__always_inline__)) static bool is_sentinel(const_node_ptr this_node) noexcept
   { return NodeTraits::get_next(this_node) == node_ptr(); }







   inline __attribute__ ((__always_inline__)) static void set_sentinel(node_ptr this_node) noexcept
   { NodeTraits::set_next(this_node, node_ptr()); }
# 196 "/usr/include/boost/intrusive/circular_slist_algorithms.hpp" 3 4
   inline __attribute__ ((__always_inline__)) static node_ptr get_previous_node(node_ptr prev_init_node, node_ptr this_node) noexcept
   { return base_t::get_previous_node(prev_init_node, this_node); }
# 206 "/usr/include/boost/intrusive/circular_slist_algorithms.hpp" 3 4
   inline __attribute__ ((__always_inline__)) static node_ptr get_previous_node(node_ptr this_node) noexcept
   { return base_t::get_previous_node(this_node, this_node); }
# 216 "/usr/include/boost/intrusive/circular_slist_algorithms.hpp" 3 4
   inline __attribute__ ((__always_inline__)) static node_ptr get_previous_previous_node(node_ptr this_node) noexcept
   { return get_previous_previous_node(this_node, this_node); }
# 228 "/usr/include/boost/intrusive/circular_slist_algorithms.hpp" 3 4
   static node_ptr get_previous_previous_node(node_ptr p, node_ptr this_node) noexcept
   {
      node_ptr p_next = NodeTraits::get_next(p);
      node_ptr p_next_next = NodeTraits::get_next(p_next);
      while (this_node != p_next_next){
         p = p_next;
         p_next = p_next_next;
         p_next_next = NodeTraits::get_next(p_next);
      }
      return p;
   }
# 248 "/usr/include/boost/intrusive/circular_slist_algorithms.hpp" 3 4
   static std::size_t count(const_node_ptr this_node) noexcept
   {
      std::size_t result = 0;
      const_node_ptr p = this_node;
      do{
         p = NodeTraits::get_next(p);
         ++result;
      } while (p != this_node);
      return result;
   }
# 266 "/usr/include/boost/intrusive/circular_slist_algorithms.hpp" 3 4
   static void unlink(node_ptr this_node) noexcept
   {
      if(NodeTraits::get_next(this_node))
         base_t::unlink_after(get_previous_node(this_node));
   }
# 279 "/usr/include/boost/intrusive/circular_slist_algorithms.hpp" 3 4
   inline __attribute__ ((__always_inline__)) static void link_before (node_ptr nxt_node, node_ptr this_node) noexcept
   { base_t::link_after(get_previous_node(nxt_node), this_node); }
# 292 "/usr/include/boost/intrusive/circular_slist_algorithms.hpp" 3 4
   static void swap_nodes(node_ptr this_node, node_ptr other_node) noexcept
   {
      if (other_node == this_node)
         return;
      const node_ptr this_next = NodeTraits::get_next(this_node);
      const node_ptr other_next = NodeTraits::get_next(other_node);
      const bool this_null = !this_next;
      const bool other_null = !other_next;
      const bool this_empty = this_next == this_node;
      const bool other_empty = other_next == other_node;

      if(!(other_null || other_empty)){
         NodeTraits::set_next(this_next == other_node ? other_node : get_previous_node(other_node), this_node );
      }
      if(!(this_null | this_empty)){
         NodeTraits::set_next(other_next == this_node ? this_node : get_previous_node(this_node), other_node );
      }
      NodeTraits::set_next(this_node, other_empty ? this_node : (other_next == this_node ? other_node : other_next) );
      NodeTraits::set_next(other_node, this_empty ? other_node : (this_next == other_node ? this_node : this_next ) );
   }






   static void reverse(node_ptr p) noexcept
   {
      node_ptr i = NodeTraits::get_next(p), e(p);
      for (;;) {
         node_ptr nxt(NodeTraits::get_next(i));
         if (nxt == e)
            break;
         base_t::transfer_after(e, i, nxt);
      }
   }
# 337 "/usr/include/boost/intrusive/circular_slist_algorithms.hpp" 3 4
   static node_ptr move_backwards(node_ptr p, std::size_t n) noexcept
   {

      if(!n) return node_ptr();
      node_ptr first = NodeTraits::get_next(p);


      if(NodeTraits::get_next(first) == p)
         return node_ptr();

      bool end_found = false;
      node_ptr new_last = node_ptr();





      for(std::size_t i = 1; i <= n; ++i){
         new_last = first;
         first = NodeTraits::get_next(first);
         if(first == p){

            n %= i;
            if(!n)
               return node_ptr();
            i = 0;

            first = NodeTraits::get_next(p);
            base_t::unlink_after(new_last);
            end_found = true;
         }
      }



      if(!end_found){
         base_t::unlink_after(base_t::get_previous_node(first, p));
      }


      base_t::link_after(new_last, p);
      return new_last;
   }
# 389 "/usr/include/boost/intrusive/circular_slist_algorithms.hpp" 3 4
   static node_ptr move_forward(node_ptr p, std::size_t n) noexcept
   {

      if(!n) return node_ptr();
      node_ptr first = node_traits::get_next(p);


      if(node_traits::get_next(first) == p) return node_ptr();




      node_ptr old_last(first), next_to_it, new_last(p);
      std::size_t distance = 1;
      while(p != (next_to_it = node_traits::get_next(old_last))){
         if(++distance > n)
            new_last = node_traits::get_next(new_last);
         old_last = next_to_it;
      }


      if(distance <= n){


         std::size_t new_before_last_pos = (distance - (n % distance))% distance;

         if(!new_before_last_pos) return node_ptr();

         for( new_last = p
            ; new_before_last_pos--
            ; new_last = node_traits::get_next(new_last)){

         }
      }


      base_t::unlink_after(old_last);
      base_t::link_after(new_last, p);
      return new_last;
   }
# 437 "/usr/include/boost/intrusive/circular_slist_algorithms.hpp" 3 4
   static void transfer_after(node_ptr p, node_ptr other) noexcept
   {
      node_ptr other_last((get_previous_node)(other));
      base_t::transfer_after(p, other, other_last);
   }
# 455 "/usr/include/boost/intrusive/circular_slist_algorithms.hpp" 3 4
   template<class Disposer>
   inline __attribute__ ((__always_inline__)) static std::size_t detach_and_dispose(node_ptr p, Disposer disposer) noexcept
   { return base_t::unlink_after_and_dispose(p, p, disposer); }
};



template<class NodeTraits>
struct get_algo<CircularSListAlgorithms, NodeTraits>
{
   typedef circular_slist_algorithms<NodeTraits> type;
};



}
}

# 1 "/usr/include/boost/intrusive/detail/config_end.hpp" 1 3 4
# 474 "/usr/include/boost/intrusive/circular_slist_algorithms.hpp" 2 3 4
# 22 "/usr/include/boost/intrusive/slist_hook.hpp" 2 3 4








namespace boost {
namespace intrusive {




template<class ...Options>



struct make_slist_base_hook
{

   typedef typename pack_options
      < hook_defaults,



         Options...

      >::type packed_options;

   typedef generic_hook
   < CircularSListAlgorithms
   , slist_node_traits<typename packed_options::void_pointer>
   , typename packed_options::tag
   , packed_options::link_mode
   , SlistBaseHookId
   > implementation_defined;

   typedef implementation_defined type;
};
# 81 "/usr/include/boost/intrusive/slist_hook.hpp" 3 4
template<class ...Options>



class slist_base_hook
   : public make_slist_base_hook<



         Options...

      >::type
{
# 162 "/usr/include/boost/intrusive/slist_hook.hpp" 3 4
};




template<class ...Options>



struct make_slist_member_hook
{

   typedef typename pack_options
      < hook_defaults,



         Options...

      >::type packed_options;

   typedef generic_hook
   < CircularSListAlgorithms
   , slist_node_traits<typename packed_options::void_pointer>
   , member_tag
   , packed_options::link_mode
   , NoBaseHookId
   > implementation_defined;

   typedef implementation_defined type;
};
# 207 "/usr/include/boost/intrusive/slist_hook.hpp" 3 4
template<class ...Options>



class slist_member_hook
   : public make_slist_member_hook<



         Options...

      >::type
{
# 291 "/usr/include/boost/intrusive/slist_hook.hpp" 3 4
};

}
}

# 1 "/usr/include/boost/intrusive/detail/config_end.hpp" 1 3 4
# 297 "/usr/include/boost/intrusive/slist_hook.hpp" 2 3 4
# 22 "/usr/include/boost/intrusive/slist.hpp" 2 3 4

# 1 "/usr/include/boost/intrusive/linear_slist_algorithms.hpp" 1 3 4
# 17 "/usr/include/boost/intrusive/linear_slist_algorithms.hpp" 3 4
# 1 "/usr/include/boost/intrusive/detail/config_begin.hpp" 1 3 4
# 18 "/usr/include/boost/intrusive/linear_slist_algorithms.hpp" 2 3 4




# 1 "/usr/include/boost/intrusive/detail/twin.hpp" 1 3 4
# 27 "/usr/include/boost/intrusive/detail/twin.hpp" 3 4
namespace boost {
namespace intrusive {

template <class T>
struct twin
{
   typedef T type;
   twin()
      : first(), second()
   {}

   twin(const type &f, const type &s)
      : first(f), second(s)
   {}

   T first;
   T second;
};

}
}
# 23 "/usr/include/boost/intrusive/linear_slist_algorithms.hpp" 2 3 4





namespace boost {
namespace intrusive {
# 51 "/usr/include/boost/intrusive/linear_slist_algorithms.hpp" 3 4
template<class NodeTraits>
class linear_slist_algorithms

   : public detail::common_slist_algorithms<NodeTraits>

{

   typedef detail::common_slist_algorithms<NodeTraits> base_t;

   public:
   typedef typename NodeTraits::node node;
   typedef typename NodeTraits::node_ptr node_ptr;
   typedef typename NodeTraits::const_node_ptr const_node_ptr;
   typedef NodeTraits node_traits;





   typedef twin<node_ptr> node_pair;
# 143 "/usr/include/boost/intrusive/linear_slist_algorithms.hpp" 3 4
   using base_t::transfer_after;
# 154 "/usr/include/boost/intrusive/linear_slist_algorithms.hpp" 3 4
   inline __attribute__ ((__always_inline__)) static void init_header(node_ptr this_node) noexcept
   { NodeTraits::set_next(this_node, node_ptr ()); }
# 164 "/usr/include/boost/intrusive/linear_slist_algorithms.hpp" 3 4
   inline __attribute__ ((__always_inline__)) static node_ptr end_node(const_node_ptr) noexcept
   { return node_ptr(); }






   inline __attribute__ ((__always_inline__)) static bool is_empty(const_node_ptr this_node) noexcept
   { return !NodeTraits::get_next(this_node); }






   inline __attribute__ ((__always_inline__)) static bool is_sentinel(const_node_ptr this_node) noexcept
   { return NodeTraits::get_next(this_node) == this_node; }







   inline __attribute__ ((__always_inline__)) static void set_sentinel(node_ptr this_node) noexcept
   { NodeTraits::set_next(this_node, this_node); }
# 201 "/usr/include/boost/intrusive/linear_slist_algorithms.hpp" 3 4
   inline __attribute__ ((__always_inline__)) static node_ptr
      get_previous_node(node_ptr prev_init_node, node_ptr this_node) noexcept
   { return base_t::get_previous_node(prev_init_node, this_node); }
# 213 "/usr/include/boost/intrusive/linear_slist_algorithms.hpp" 3 4
   static std::size_t count(const_node_ptr this_node) noexcept
   {
      std::size_t result = 0;
      const_node_ptr p = this_node;
      do{
         p = NodeTraits::get_next(p);
         ++result;
      } while (p);
      return result;
   }
# 233 "/usr/include/boost/intrusive/linear_slist_algorithms.hpp" 3 4
   inline __attribute__ ((__always_inline__)) static void swap_trailing_nodes(node_ptr this_node, node_ptr other_node) noexcept
   {
      node_ptr this_nxt = NodeTraits::get_next(this_node);
      node_ptr other_nxt = NodeTraits::get_next(other_node);
      NodeTraits::set_next(this_node, other_nxt);
      NodeTraits::set_next(other_node, this_nxt);
   }
# 248 "/usr/include/boost/intrusive/linear_slist_algorithms.hpp" 3 4
   static node_ptr reverse(node_ptr p) noexcept
   {
      if(!p) return node_ptr();
      node_ptr i = NodeTraits::get_next(p);
      node_ptr first(p);
      while(i){
         node_ptr nxti(NodeTraits::get_next(i));
         base_t::unlink_after(p);
         NodeTraits::set_next(i, first);
         first = i;
         i = nxti;
      }
      return first;
   }
# 271 "/usr/include/boost/intrusive/linear_slist_algorithms.hpp" 3 4
   static node_pair move_first_n_backwards(node_ptr p, std::size_t n) noexcept
   {
      node_pair ret;

      if(!n || !p || !NodeTraits::get_next(p)){
         return ret;
      }

      node_ptr first = p;
      bool end_found = false;
      node_ptr new_last = node_ptr();
      node_ptr old_last = node_ptr();





      for(std::size_t i = 1; i <= n; ++i){
         new_last = first;
         first = NodeTraits::get_next(first);
         if(first == node_ptr()){

            n %= i;
            if(!n) return ret;
            old_last = new_last;
            i = 0;

            first = p;

            end_found = true;
         }
      }



      if(!end_found){
         old_last = base_t::get_previous_node(first, node_ptr());
      }


      NodeTraits::set_next(old_last, p);
      NodeTraits::set_next(new_last, node_ptr());
      ret.first = first;
      ret.second = new_last;
      return ret;
   }
# 326 "/usr/include/boost/intrusive/linear_slist_algorithms.hpp" 3 4
   static node_pair move_first_n_forward(node_ptr p, std::size_t n) noexcept
   {
      node_pair ret;

      if(!n || !p || !NodeTraits::get_next(p))
         return ret;

      node_ptr first = p;




      node_ptr old_last(first), next_to_it, new_last(p);
      std::size_t distance = 1;
      while(!!(next_to_it = node_traits::get_next(old_last))){
         if(distance++ > n)
            new_last = node_traits::get_next(new_last);
         old_last = next_to_it;
      }


      if(distance <= n){


         std::size_t new_before_last_pos = (distance - (n % distance))% distance;

         if(!new_before_last_pos)
            return ret;

         for( new_last = p
            ; --new_before_last_pos
            ; new_last = node_traits::get_next(new_last)){

         }
      }


      node_ptr new_first(node_traits::get_next(new_last));

      NodeTraits::set_next(old_last, p);
      NodeTraits::set_next(new_last, node_ptr());
      ret.first = new_first;
      ret.second = new_last;
      return ret;
   }
# 379 "/usr/include/boost/intrusive/linear_slist_algorithms.hpp" 3 4
   static void transfer_after(node_ptr p, node_ptr other) noexcept
   {
      if ((is_empty)(p)) {
         (swap_trailing_nodes)(p, other);
      }
      else {
         node_ptr other_last((get_previous_node)(other, node_ptr()));
         base_t::transfer_after(p, other, other_last);
      }
   }
# 402 "/usr/include/boost/intrusive/linear_slist_algorithms.hpp" 3 4
   template<class Disposer>
   inline __attribute__ ((__always_inline__)) static std::size_t detach_and_dispose(node_ptr p, Disposer disposer) noexcept
   { return base_t::unlink_after_and_dispose(p, node_ptr(), disposer); }
};



template<class NodeTraits>
struct get_algo<LinearSListAlgorithms, NodeTraits>
{
   typedef linear_slist_algorithms<NodeTraits> type;
};



}
}

# 1 "/usr/include/boost/intrusive/detail/config_end.hpp" 1 3 4
# 421 "/usr/include/boost/intrusive/linear_slist_algorithms.hpp" 2 3 4
# 24 "/usr/include/boost/intrusive/slist.hpp" 2 3 4








# 1 "/usr/include/boost/intrusive/detail/slist_iterator.hpp" 1 3 4
# 25 "/usr/include/boost/intrusive/detail/slist_iterator.hpp" 3 4
# 1 "/usr/include/boost/intrusive/detail/config_begin.hpp" 1 3 4
# 26 "/usr/include/boost/intrusive/detail/slist_iterator.hpp" 2 3 4






namespace boost {
namespace intrusive {




template<class ValueTraits, bool IsConst>
class slist_iterator
{
   private:
   typedef iiterator
      <ValueTraits, IsConst, std::forward_iterator_tag> types_t;

   static const bool stateful_value_traits = types_t::stateful_value_traits;

   typedef ValueTraits value_traits;
   typedef typename types_t::node_traits node_traits;

   typedef typename types_t::node node;
   typedef typename types_t::node_ptr node_ptr;
   typedef typename types_t::const_value_traits_ptr const_value_traits_ptr;
   class nat;
   typedef typename
      detail::if_c< IsConst
                  , slist_iterator<value_traits, false>
                  , nat>::type nonconst_iterator;

   public:
   typedef typename types_t::iterator_type::difference_type difference_type;
   typedef typename types_t::iterator_type::value_type value_type;
   typedef typename types_t::iterator_type::pointer pointer;
   typedef typename types_t::iterator_type::reference reference;
   typedef typename types_t::iterator_type::iterator_category iterator_category;

   inline __attribute__ ((__always_inline__)) slist_iterator()
   {}

   inline __attribute__ ((__always_inline__)) slist_iterator(node_ptr nodeptr, const_value_traits_ptr traits_ptr)
      : members_(nodeptr, traits_ptr)
   {}

   inline __attribute__ ((__always_inline__)) explicit slist_iterator(node_ptr nodeptr)
      : members_(nodeptr, const_value_traits_ptr())
   { static_assert((stateful_value_traits == false), "(stateful_value_traits == false)"); }

   inline __attribute__ ((__always_inline__)) slist_iterator(const slist_iterator &other)
      : members_(other.pointed_node(), other.get_value_traits())
   {}

   inline __attribute__ ((__always_inline__)) slist_iterator(const nonconst_iterator &other)
      : members_(other.pointed_node(), other.get_value_traits())
   {}

   inline __attribute__ ((__always_inline__)) slist_iterator &operator=(const slist_iterator &other)
   { members_.nodeptr_ = other.members_.nodeptr_; return *this; }

   inline __attribute__ ((__always_inline__)) node_ptr pointed_node() const
   { return members_.nodeptr_; }

   inline __attribute__ ((__always_inline__)) slist_iterator &operator=(node_ptr n)
   { members_.nodeptr_ = n; return static_cast<slist_iterator&>(*this); }

   inline __attribute__ ((__always_inline__)) const_value_traits_ptr get_value_traits() const
   { return members_.get_ptr(); }

   inline __attribute__ ((__always_inline__)) bool operator!() const
   { return !members_.nodeptr_; }

   public:
   inline __attribute__ ((__always_inline__)) slist_iterator& operator++()
   {
      members_.nodeptr_ = node_traits::get_next(members_.nodeptr_);
      return static_cast<slist_iterator&> (*this);
   }

   inline __attribute__ ((__always_inline__)) slist_iterator operator++(int)
   {
      slist_iterator result (*this);
      members_.nodeptr_ = node_traits::get_next(members_.nodeptr_);
      return result;
   }

   inline __attribute__ ((__always_inline__)) friend bool operator== (const slist_iterator& l, const slist_iterator& r)
   { return l.pointed_node() == r.pointed_node(); }

   inline __attribute__ ((__always_inline__)) friend bool operator!= (const slist_iterator& l, const slist_iterator& r)
   { return l.pointed_node() != r.pointed_node(); }

   inline __attribute__ ((__always_inline__)) reference operator*() const
   { return *operator->(); }

   inline __attribute__ ((__always_inline__)) pointer operator->() const
   { return this->operator_arrow(detail::bool_<stateful_value_traits>()); }

   inline __attribute__ ((__always_inline__)) slist_iterator<ValueTraits, false> unconst() const
   { return slist_iterator<ValueTraits, false>(this->pointed_node(), this->get_value_traits()); }

   private:

   inline __attribute__ ((__always_inline__)) pointer operator_arrow(detail::false_) const
   { return ValueTraits::to_value_ptr(members_.nodeptr_); }

   inline __attribute__ ((__always_inline__)) pointer operator_arrow(detail::true_) const
   { return this->get_value_traits()->to_value_ptr(members_.nodeptr_); }

   iiterator_members<node_ptr, const_value_traits_ptr, stateful_value_traits> members_;
};

}
}

# 1 "/usr/include/boost/intrusive/detail/config_end.hpp" 1 3 4
# 144 "/usr/include/boost/intrusive/detail/slist_iterator.hpp" 2 3 4
# 33 "/usr/include/boost/intrusive/slist.hpp" 2 3 4








# 1 "/usr/include/boost/intrusive/detail/node_cloner_disposer.hpp" 1 3 4
# 30 "/usr/include/boost/intrusive/detail/node_cloner_disposer.hpp" 3 4
namespace boost {
namespace intrusive {
namespace detail {

template<class F, class ValueTraits, algo_types AlgoType, bool IsConst = true>
struct node_cloner

   : public ebo_functor_holder<F>
{
   typedef ValueTraits value_traits;
   typedef typename value_traits::node_traits node_traits;
   typedef typename node_traits::node_ptr node_ptr;
   typedef ebo_functor_holder<F> base_t;
   typedef typename get_algo< AlgoType
                            , node_traits>::type node_algorithms;
   static const bool safemode_or_autounlink =
      is_safe_autounlink<value_traits::link_mode>::value;
   typedef typename value_traits::value_type value_type;
   typedef typename value_traits::pointer pointer;
   typedef typename value_traits::const_pointer const_pointer;
   typedef typename node_traits::node node;
   typedef typename value_traits::const_node_ptr const_node_ptr;
   typedef typename pointer_traits<pointer>::reference reference;
   typedef typename pointer_traits
      <const_pointer>::reference const_reference;
   typedef typename if_c<IsConst, const_reference, reference>::type reference_type;

   node_cloner(F f, const ValueTraits *traits)
      : base_t(f), traits_(traits)
   {}


   inline __attribute__ ((__always_inline__)) node_ptr operator()(node_ptr p)
   {
      reference_type v = *traits_->to_value_ptr(p);
      node_ptr n = traits_->to_node_ptr(*base_t::get()(v));

      (static_cast <bool> (!safemode_or_autounlink || node_algorithms::unique(n)) ? void (0) : __assert_fail ("!safemode_or_autounlink || node_algorithms::unique(n)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      return n;
   }

   const ValueTraits * const traits_;
};

template<class F, class ValueTraits, algo_types AlgoType>
struct node_disposer

   : public ebo_functor_holder<F>
{
   typedef ValueTraits value_traits;
   typedef typename value_traits::node_traits node_traits;
   typedef typename node_traits::node_ptr node_ptr;
   typedef ebo_functor_holder<F> base_t;
   typedef typename get_algo< AlgoType
                            , node_traits>::type node_algorithms;
   static const bool safemode_or_autounlink =
      is_safe_autounlink<value_traits::link_mode>::value;

   inline __attribute__ ((__always_inline__)) node_disposer(F f, const ValueTraits *cont)
      : base_t(f), traits_(cont)
   {}

   inline __attribute__ ((__always_inline__)) void operator()(node_ptr p)
   {
      if constexpr(safemode_or_autounlink)
         node_algorithms::init(p);
      base_t::get()(traits_->to_value_ptr(p));
   }
   const ValueTraits * const traits_;
};

}
}
}
# 42 "/usr/include/boost/intrusive/slist.hpp" 2 3 4
# 52 "/usr/include/boost/intrusive/slist.hpp" 3 4
namespace boost {
namespace intrusive {



template<class HeaderHolder, class NodePtr, bool>
struct header_holder_plus_last
{
   HeaderHolder header_holder_;
   NodePtr last_;
};

template<class HeaderHolder, class NodePtr>
struct header_holder_plus_last<HeaderHolder, NodePtr, false>
{
   HeaderHolder header_holder_;
};

struct default_slist_hook_applier
{ template <class T> struct apply{ typedef typename T::default_slist_hook type; }; };

template<>
struct is_default_hook_tag<default_slist_hook_applier>
{ static const bool value = true; };

struct slist_defaults
{
   typedef default_slist_hook_applier proto_value_traits;
   static const bool constant_time_size = true;
   static const bool linear = false;
   typedef std::size_t size_type;
   static const bool cache_last = false;
   typedef void header_holder_type;
};

struct slist_bool_flags
{
   static const std::size_t linear_pos = 1u;
   static const std::size_t constant_time_size_pos = 2u;
   static const std::size_t cache_last_pos = 4u;
};
# 123 "/usr/include/boost/intrusive/slist.hpp" 3 4
template<class ValueTraits, class SizeType, std::size_t BoolFlags, typename HeaderHolder>

class slist_impl
{

   public:
   typedef ValueTraits value_traits;
   typedef typename value_traits::pointer pointer;
   typedef typename value_traits::const_pointer const_pointer;
   typedef typename pointer_traits<pointer>::element_type value_type;
   typedef typename pointer_traits<pointer>::reference reference;
   typedef typename pointer_traits<const_pointer>::reference const_reference;
   typedef typename pointer_traits<pointer>::difference_type difference_type;
   typedef SizeType size_type;
   typedef slist_iterator<value_traits, false> iterator;
   typedef slist_iterator<value_traits, true> const_iterator;
   typedef typename value_traits::node_traits node_traits;
   typedef typename node_traits::node node;
   typedef typename node_traits::node_ptr node_ptr;
   typedef typename node_traits::const_node_ptr const_node_ptr;
   typedef typename detail::get_header_holder_type
      < value_traits, HeaderHolder >::type header_holder_type;

   static const bool constant_time_size = 0 != (BoolFlags & slist_bool_flags::constant_time_size_pos);
   static const bool stateful_value_traits = detail::is_stateful_value_traits<value_traits>::value;
   static const bool linear = 0 != (BoolFlags & slist_bool_flags::linear_pos);
   static const bool cache_last = 0 != (BoolFlags & slist_bool_flags::cache_last_pos);
   static const bool has_container_from_iterator =
        detail::is_same< header_holder_type, detail::default_header_holder< node_traits > >::value;

   typedef typename detail::if_c
      < linear
      , linear_slist_algorithms<node_traits>
      , circular_slist_algorithms<node_traits>
      >::type node_algorithms;


   private:
   typedef detail::size_holder<constant_time_size, size_type> size_traits;


   public: slist_impl(slist_impl const &) = delete; slist_impl& operator=(slist_impl const &) = delete; public: typedef int boost_move_no_copy_constructor_or_assign; private: public: typedef int boost_move_emulation_t; private:

   static const bool safemode_or_autounlink = is_safe_autounlink<value_traits::link_mode>::value;


   static_assert(!(constant_time_size && ((int)value_traits::link_mode == (int)auto_unlink)), "!(constant_time_size && ((int)value_traits::link_mode == (int)auto_unlink))");

   static_assert(!(linear && ((int)value_traits::link_mode == (int)auto_unlink)), "!(linear && ((int)value_traits::link_mode == (int)auto_unlink))");

   static_assert(!(cache_last && ((int)value_traits::link_mode == (int)auto_unlink)), "!(cache_last && ((int)value_traits::link_mode == (int)auto_unlink))");

   inline __attribute__ ((__always_inline__)) node_ptr get_end_node()
   { return node_algorithms::end_node(this->get_root_node()); }

   inline __attribute__ ((__always_inline__)) const_node_ptr get_end_node() const
   { return node_algorithms::end_node(this->get_root_node()); }

   inline __attribute__ ((__always_inline__)) node_ptr get_root_node()
   { return data_.root_plus_size_.header_holder_.get_node(); }

   inline __attribute__ ((__always_inline__)) const_node_ptr get_root_node() const
   { return data_.root_plus_size_.header_holder_.get_node(); }

   inline __attribute__ ((__always_inline__)) node_ptr get_last_node()
   { return this->get_last_node(detail::bool_<cache_last>()); }

   inline __attribute__ ((__always_inline__)) const_node_ptr get_last_node() const
   { return this->get_last_node(detail::bool_<cache_last>()); }

   inline __attribute__ ((__always_inline__)) void set_last_node(node_ptr n)
   { return this->set_last_node(n, detail::bool_<cache_last>()); }

   inline __attribute__ ((__always_inline__)) static node_ptr get_last_node(detail::bool_<false>)
   {

      (static_cast <bool> (cache_last) ? void (0) : __assert_fail ("cache_last", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      return node_ptr();
   }

   inline __attribute__ ((__always_inline__)) static void set_last_node(node_ptr , detail::bool_<false>)
   {

      (static_cast <bool> (cache_last) ? void (0) : __assert_fail ("cache_last", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
   }

   inline __attribute__ ((__always_inline__)) node_ptr get_last_node(detail::bool_<true>)
   { return node_ptr(data_.root_plus_size_.last_); }

   inline __attribute__ ((__always_inline__)) const_node_ptr get_last_node(detail::bool_<true>) const
   { return const_node_ptr(data_.root_plus_size_.last_); }

   inline __attribute__ ((__always_inline__)) void set_last_node(node_ptr n, detail::bool_<true>)
   { data_.root_plus_size_.last_ = n; }

   void set_default_constructed_state()
   {
      node_algorithms::init_header(this->get_root_node());
      this->priv_size_traits().set_size(size_type(0));
      if constexpr(cache_last){
         this->set_last_node(this->get_root_node());
      }
   }

   typedef header_holder_plus_last<header_holder_type, node_ptr, cache_last> header_holder_plus_last_t;
   struct root_plus_size
      : public size_traits
      , public header_holder_plus_last_t
   {};

   struct data_t
      : public value_traits
   {
      typedef typename slist_impl::value_traits value_traits;
      explicit data_t(const value_traits &val_traits)
         : value_traits(val_traits)
      {}

      root_plus_size root_plus_size_;
   } data_;

   inline __attribute__ ((__always_inline__)) size_traits &priv_size_traits()
   { return data_.root_plus_size_; }

   inline __attribute__ ((__always_inline__)) const size_traits &priv_size_traits() const
   { return data_.root_plus_size_; }

   inline __attribute__ ((__always_inline__)) const value_traits &priv_value_traits() const
   { return data_; }

   inline __attribute__ ((__always_inline__)) value_traits &priv_value_traits()
   { return data_; }

   typedef typename boost::intrusive::value_traits_pointers
      <ValueTraits>::const_value_traits_ptr const_value_traits_ptr;

   inline __attribute__ ((__always_inline__)) const_value_traits_ptr priv_value_traits_ptr() const
   { return pointer_traits<const_value_traits_ptr>::pointer_to(this->priv_value_traits()); }



   public:
# 283 "/usr/include/boost/intrusive/slist.hpp" 3 4
   slist_impl( node_ptr f, node_ptr before_l
             , size_type n, const value_traits &v_traits = value_traits())
      : data_(v_traits)
   {
      if(n){
         this->priv_size_traits().set_size(n);
         if constexpr(cache_last){
            this->set_last_node(before_l);
         }
         node_traits::set_next(this->get_root_node(), f);
         node_traits::set_next(before_l, this->get_end_node());
      }
      else{
         this->set_default_constructed_state();
      }
   }
# 308 "/usr/include/boost/intrusive/slist.hpp" 3 4
   slist_impl()
      : data_(value_traits())
   { this->set_default_constructed_state(); }







   explicit slist_impl(const value_traits &v_traits)
      : data_(v_traits)
   { this->set_default_constructed_state(); }
# 330 "/usr/include/boost/intrusive/slist.hpp" 3 4
   template<class Iterator>
   slist_impl(Iterator b, Iterator e, const value_traits &v_traits = value_traits())
      : data_(v_traits)
   {
      this->set_default_constructed_state();

      this->insert_after(this->cbefore_begin(), b, e);
   }
# 348 "/usr/include/boost/intrusive/slist.hpp" 3 4
   slist_impl(slist_impl && x)
      : data_(::boost::move(x.priv_value_traits()))
   {
      this->set_default_constructed_state();

      this->swap(x);
   }



   slist_impl& operator=(slist_impl && x)
   { this->swap(x); return *this; }
# 370 "/usr/include/boost/intrusive/slist.hpp" 3 4
   ~slist_impl()
   {
      if constexpr(is_safe_autounlink<ValueTraits::link_mode>::value){
         this->clear();
         node_algorithms::init(this->get_root_node());
      }
   }
# 386 "/usr/include/boost/intrusive/slist.hpp" 3 4
   void clear() noexcept
   {
      if constexpr(safemode_or_autounlink){
         this->clear_and_dispose(detail::null_disposer());
      }
      else{
         this->set_default_constructed_state();
      }
   }
# 406 "/usr/include/boost/intrusive/slist.hpp" 3 4
   template <class Disposer>
   void clear_and_dispose(Disposer disposer) noexcept
   {
      node_algorithms::detach_and_dispose
         ( this->get_root_node()
         , detail::node_disposer<Disposer, value_traits, CommonSListAlgorithms>
               (disposer, &this->priv_value_traits()) );
      this->set_default_constructed_state();
   }
# 426 "/usr/include/boost/intrusive/slist.hpp" 3 4
   void push_front(reference value) noexcept
   {
      node_ptr to_insert = priv_value_traits().to_node_ptr(value);
      (static_cast <bool> (!safemode_or_autounlink || node_algorithms::inited(to_insert)) ? void (0) : __assert_fail ("!safemode_or_autounlink || node_algorithms::inited(to_insert)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      if constexpr(cache_last){
         if(this->empty()){
            this->set_last_node(to_insert);
         }
      }
      node_algorithms::link_after(this->get_root_node(), to_insert);
      this->priv_size_traits().increment();
   }
# 450 "/usr/include/boost/intrusive/slist.hpp" 3 4
   void push_back(reference value) noexcept
   {
      static_assert((cache_last), "(cache_last)");
      node_ptr n = priv_value_traits().to_node_ptr(value);
      (static_cast <bool> (!safemode_or_autounlink || node_algorithms::inited(n)) ? void (0) : __assert_fail ("!safemode_or_autounlink || node_algorithms::inited(n)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      node_algorithms::link_after(this->get_last_node(), n);
      if constexpr(cache_last){
         this->set_last_node(n);
      }
      this->priv_size_traits().increment();
   }
# 470 "/usr/include/boost/intrusive/slist.hpp" 3 4
   void pop_front() noexcept
   { return this->pop_front_and_dispose(detail::null_disposer()); }
# 483 "/usr/include/boost/intrusive/slist.hpp" 3 4
   template<class Disposer>
   void pop_front_and_dispose(Disposer disposer) noexcept
   {
      node_ptr to_erase = node_traits::get_next(this->get_root_node());
      node_algorithms::unlink_after(this->get_root_node());
      this->priv_size_traits().decrement();
      if constexpr(safemode_or_autounlink)
         node_algorithms::init(to_erase);
      disposer(priv_value_traits().to_value_ptr(to_erase));
      if constexpr(cache_last){
         if(this->empty()){
            this->set_last_node(this->get_root_node());
         }
      }
   }






   inline __attribute__ ((__always_inline__)) reference front() noexcept
   { return *this->priv_value_traits().to_value_ptr(node_traits::get_next(this->get_root_node())); }






   inline __attribute__ ((__always_inline__)) const_reference front() const noexcept
   { return *this->priv_value_traits().to_value_ptr(detail::uncast(node_traits::get_next(this->get_root_node()))); }
# 523 "/usr/include/boost/intrusive/slist.hpp" 3 4
   reference back() noexcept
   {
      static_assert((cache_last), "(cache_last)");
      return *this->priv_value_traits().to_value_ptr(this->get_last_node());
   }
# 537 "/usr/include/boost/intrusive/slist.hpp" 3 4
   inline __attribute__ ((__always_inline__)) const_reference back() const noexcept
   {
      static_assert((cache_last), "(cache_last)");
      return *this->priv_value_traits().to_value_ptr(this->get_last_node());
   }






   inline __attribute__ ((__always_inline__)) iterator begin() noexcept
   { return iterator (node_traits::get_next(this->get_root_node()), this->priv_value_traits_ptr()); }






   inline __attribute__ ((__always_inline__)) const_iterator begin() const noexcept
   { return const_iterator (node_traits::get_next(this->get_root_node()), this->priv_value_traits_ptr()); }






   inline __attribute__ ((__always_inline__)) const_iterator cbegin() const noexcept
   { return const_iterator(node_traits::get_next(this->get_root_node()), this->priv_value_traits_ptr()); }






   inline __attribute__ ((__always_inline__)) iterator end() noexcept
   { return iterator(this->get_end_node(), this->priv_value_traits_ptr()); }






   inline __attribute__ ((__always_inline__)) const_iterator end() const noexcept
   { return const_iterator(detail::uncast(this->get_end_node()), this->priv_value_traits_ptr()); }






   inline __attribute__ ((__always_inline__)) const_iterator cend() const noexcept
   { return this->end(); }







   inline __attribute__ ((__always_inline__)) iterator before_begin() noexcept
   { return iterator(this->get_root_node(), this->priv_value_traits_ptr()); }







   inline __attribute__ ((__always_inline__)) const_iterator before_begin() const noexcept
   { return const_iterator(detail::uncast(this->get_root_node()), this->priv_value_traits_ptr()); }







   inline __attribute__ ((__always_inline__)) const_iterator cbefore_begin() const noexcept
   { return this->before_begin(); }
# 625 "/usr/include/boost/intrusive/slist.hpp" 3 4
   inline __attribute__ ((__always_inline__)) iterator last() noexcept
   {

      (static_cast <bool> (cache_last) ? void (0) : __assert_fail ("cache_last", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      return iterator (this->get_last_node(), this->priv_value_traits_ptr());
   }
# 639 "/usr/include/boost/intrusive/slist.hpp" 3 4
   inline __attribute__ ((__always_inline__)) const_iterator last() const noexcept
   {

      (static_cast <bool> (cache_last) ? void (0) : __assert_fail ("cache_last", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      return const_iterator (this->get_last_node(), this->priv_value_traits_ptr());
   }
# 653 "/usr/include/boost/intrusive/slist.hpp" 3 4
   inline __attribute__ ((__always_inline__)) const_iterator clast() const noexcept
   { return const_iterator(this->get_last_node(), this->priv_value_traits_ptr()); }
# 664 "/usr/include/boost/intrusive/slist.hpp" 3 4
   inline __attribute__ ((__always_inline__)) static slist_impl &container_from_end_iterator(iterator end_iterator) noexcept
   { return slist_impl::priv_container_from_end_iterator(end_iterator); }
# 675 "/usr/include/boost/intrusive/slist.hpp" 3 4
   inline __attribute__ ((__always_inline__)) static const slist_impl &container_from_end_iterator(const_iterator end_iterator) noexcept
   { return slist_impl::priv_container_from_end_iterator(end_iterator); }
# 686 "/usr/include/boost/intrusive/slist.hpp" 3 4
   inline __attribute__ ((__always_inline__)) size_type size() const noexcept
   {
      if constexpr(constant_time_size)
         return this->priv_size_traits().get_size();
      else
         return node_algorithms::count(this->get_root_node()) - 1;
   }
# 701 "/usr/include/boost/intrusive/slist.hpp" 3 4
   inline __attribute__ ((__always_inline__)) bool empty() const noexcept
   { return node_algorithms::is_empty(this->get_root_node()); }
# 712 "/usr/include/boost/intrusive/slist.hpp" 3 4
   void swap(slist_impl& other)
   {
      if constexpr(cache_last){
         priv_swap_cache_last(this, &other);
      }
      else{
         this->priv_swap_lists(this->get_root_node(), other.get_root_node(), detail::bool_<linear>());
      }
      this->priv_size_traits().swap(other.priv_size_traits());
   }
# 732 "/usr/include/boost/intrusive/slist.hpp" 3 4
   void shift_backwards(size_type n = 1) noexcept
   { this->priv_shift_backwards(n, detail::bool_<linear>()); }
# 744 "/usr/include/boost/intrusive/slist.hpp" 3 4
   void shift_forward(size_type n = 1) noexcept
   { this->priv_shift_forward(n, detail::bool_<linear>()); }
# 761 "/usr/include/boost/intrusive/slist.hpp" 3 4
   template <class Cloner, class Disposer>
   void clone_from(const slist_impl &src, Cloner cloner, Disposer disposer)
   {
      this->clear_and_dispose(disposer);
      detail::exception_disposer<slist_impl, Disposer>
         rollback(*this, disposer);
      const_iterator prev(this->cbefore_begin());
      const_iterator b(src.begin()), e(src.end());
      for(; b != e; ++b){
         prev = this->insert_after(prev, *cloner(*b));
      }
      rollback.release();
   }
# 789 "/usr/include/boost/intrusive/slist.hpp" 3 4
   template <class Cloner, class Disposer>
   void clone_from(slist_impl && src, Cloner cloner, Disposer disposer)
   {
      this->clear_and_dispose(disposer);
      detail::exception_disposer<slist_impl, Disposer>
         rollback(*this, disposer);
      iterator prev(this->cbefore_begin());
      iterator b(src.begin()), e(src.end());
      for(; b != e; ++b){
         prev = this->insert_after(prev, *cloner(*b));
      }
      rollback.release();
   }
# 816 "/usr/include/boost/intrusive/slist.hpp" 3 4
   iterator insert_after(const_iterator prev_p, reference value) noexcept
   {
      node_ptr n = priv_value_traits().to_node_ptr(value);
      (static_cast <bool> (!safemode_or_autounlink || node_algorithms::inited(n)) ? void (0) : __assert_fail ("!safemode_or_autounlink || node_algorithms::inited(n)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      node_ptr prev_n(prev_p.pointed_node());
      node_algorithms::link_after(prev_n, n);
      if(cache_last && (this->get_last_node() == prev_n)){
         this->set_last_node(n);
      }
      this->priv_size_traits().increment();
      return iterator (n, this->priv_value_traits_ptr());
   }
# 841 "/usr/include/boost/intrusive/slist.hpp" 3 4
   template<class Iterator>
   void insert_after(const_iterator prev_p, Iterator f, Iterator l) noexcept
   {

      size_type count = 0;
      node_ptr prev_n(prev_p.pointed_node());
      for (; f != l; ++f, ++count){
         const node_ptr n = priv_value_traits().to_node_ptr(*f);
         (static_cast <bool> (!safemode_or_autounlink || node_algorithms::inited(n)) ? void (0) : __assert_fail ("!safemode_or_autounlink || node_algorithms::inited(n)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
         node_algorithms::link_after(prev_n, n);
         prev_n = n;
      }

      if(cache_last && (this->get_last_node() == prev_p.pointed_node())){
         this->set_last_node(prev_n);
      }
      if constexpr(constant_time_size){
         this->priv_size_traits().increase(count);
      }
   }
# 874 "/usr/include/boost/intrusive/slist.hpp" 3 4
   iterator insert(const_iterator p, reference value) noexcept
   { return this->insert_after(this->previous(p), value); }
# 891 "/usr/include/boost/intrusive/slist.hpp" 3 4
   template<class Iterator>
   void insert(const_iterator p, Iterator b, Iterator e) noexcept
   { return this->insert_after(this->previous(p), b, e); }
# 907 "/usr/include/boost/intrusive/slist.hpp" 3 4
   iterator erase_after(const_iterator prev) noexcept
   { return this->erase_after_and_dispose(prev, detail::null_disposer()); }
# 923 "/usr/include/boost/intrusive/slist.hpp" 3 4
   iterator erase_after(const_iterator before_f, const_iterator l) noexcept
   {
      if constexpr(safemode_or_autounlink || constant_time_size){
         return this->erase_after_and_dispose(before_f, l, detail::null_disposer());
      }
      else{
         const node_ptr bfp = before_f.pointed_node();
         const node_ptr lp = l.pointed_node();
         if constexpr(cache_last){
            if(lp == this->get_end_node()){
               this->set_last_node(bfp);
            }
         }
         node_algorithms::unlink_after(bfp, lp);
         return l.unconst();
      }
   }
# 955 "/usr/include/boost/intrusive/slist.hpp" 3 4
   iterator erase_after(const_iterator before_f, const_iterator l, size_type n) noexcept
   {
      (static_cast <bool> (node_algorithms::distance((++const_iterator(before_f)).pointed_node(), l.pointed_node()) == n) ? void (0) : __assert_fail ("node_algorithms::distance((++const_iterator(before_f)).pointed_node(), l.pointed_node()) == n", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      (void)n;
      if constexpr(safemode_or_autounlink){
         return this->erase_after(before_f, l);
      }
      else{
         const node_ptr bfp = before_f.pointed_node();
         const node_ptr lp = l.pointed_node();
         if constexpr(cache_last){
            if((lp == this->get_end_node())){
               this->set_last_node(bfp);
            }
         }
         node_algorithms::unlink_after(bfp, lp);
         if constexpr(constant_time_size){
            this->priv_size_traits().decrease(n);
         }
         return l.unconst();
      }
   }
# 990 "/usr/include/boost/intrusive/slist.hpp" 3 4
   iterator erase(const_iterator i) noexcept
   { return this->erase_after(this->previous(i)); }
# 1007 "/usr/include/boost/intrusive/slist.hpp" 3 4
   iterator erase(const_iterator f, const_iterator l) noexcept
   { return this->erase_after(this->previous(f), l); }
# 1024 "/usr/include/boost/intrusive/slist.hpp" 3 4
   iterator erase(const_iterator f, const_iterator l, size_type n) noexcept
   { return this->erase_after(this->previous(f), l, n); }
# 1041 "/usr/include/boost/intrusive/slist.hpp" 3 4
   template<class Disposer>
   iterator erase_after_and_dispose(const_iterator prev, Disposer disposer) noexcept
   {
      const_iterator it(prev);
      ++it;
      node_ptr to_erase(it.pointed_node());
      ++it;
      node_ptr prev_n(prev.pointed_node());
      node_algorithms::unlink_after(prev_n);
      if(cache_last && (to_erase == this->get_last_node())){
         this->set_last_node(prev_n);
      }
      if constexpr(safemode_or_autounlink)
         node_algorithms::init(to_erase);
      disposer(priv_value_traits().to_value_ptr(to_erase));
      this->priv_size_traits().decrement();
      return it.unconst();
   }



   static iterator s_insert_after(const_iterator const prev_p, reference value) noexcept
   {
      static_assert(((!cache_last)&&(!constant_time_size)&&(!stateful_value_traits)), "((!cache_last)&&(!constant_time_size)&&(!stateful_value_traits))");
      node_ptr const n = value_traits::to_node_ptr(value);
      (static_cast <bool> (!safemode_or_autounlink || node_algorithms::inited(n)) ? void (0) : __assert_fail ("!safemode_or_autounlink || node_algorithms::inited(n)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      node_algorithms::link_after(prev_p.pointed_node(), n);
      return iterator (n, const_value_traits_ptr());
   }

   template<class Disposer>
   static iterator s_erase_after_and_dispose(const_iterator prev, Disposer disposer) noexcept
   {
      static_assert(((!cache_last)&&(!constant_time_size)&&(!stateful_value_traits)), "((!cache_last)&&(!constant_time_size)&&(!stateful_value_traits))");
      const_iterator it(prev);
      ++it;
      node_ptr to_erase(it.pointed_node());
      ++it;
      node_ptr prev_n(prev.pointed_node());
      node_algorithms::unlink_after(prev_n);
      if constexpr(safemode_or_autounlink)
         node_algorithms::init(to_erase);
      disposer(value_traits::to_value_ptr(to_erase));
      return it.unconst();
   }

   template<class Disposer>
   static iterator s_erase_after_and_dispose(const_iterator before_f, const_iterator l, Disposer disposer) noexcept
   {
      static_assert(((!cache_last)&&(!constant_time_size)&&(!stateful_value_traits)), "((!cache_last)&&(!constant_time_size)&&(!stateful_value_traits))");
      node_ptr bfp(before_f.pointed_node()), lp(l.pointed_node());
      node_ptr fp(node_traits::get_next(bfp));
      node_algorithms::unlink_after(bfp, lp);
      while(fp != lp){
         node_ptr to_erase(fp);
         fp = node_traits::get_next(fp);
         if constexpr(safemode_or_autounlink)
            node_algorithms::init(to_erase);
         disposer(value_traits::to_value_ptr(to_erase));
      }
      return l.unconst();
   }

   static iterator s_erase_after(const_iterator prev) noexcept
   { return s_erase_after_and_dispose(prev, detail::null_disposer()); }
# 1123 "/usr/include/boost/intrusive/slist.hpp" 3 4
   template<class Disposer>
   iterator erase_after_and_dispose(const_iterator before_f, const_iterator l, Disposer disposer) noexcept
   {
      node_ptr bfp(before_f.pointed_node()), lp(l.pointed_node());
      node_ptr fp(node_traits::get_next(bfp));
      node_algorithms::unlink_after(bfp, lp);
      while(fp != lp){
         node_ptr to_erase(fp);
         fp = node_traits::get_next(fp);
         if constexpr(safemode_or_autounlink)
            node_algorithms::init(to_erase);
         disposer(priv_value_traits().to_value_ptr(to_erase));
         this->priv_size_traits().decrement();
      }
      if(cache_last && (node_traits::get_next(bfp) == this->get_end_node())){
         this->set_last_node(bfp);
      }
      return l.unconst();
   }
# 1158 "/usr/include/boost/intrusive/slist.hpp" 3 4
   template<class Disposer>
   iterator erase_and_dispose(const_iterator i, Disposer disposer) noexcept
   { return this->erase_after_and_dispose(this->previous(i), disposer); }


   template<class Disposer>
   iterator erase_and_dispose(iterator i, Disposer disposer) noexcept
   { return this->erase_and_dispose(const_iterator(i), disposer); }
# 1185 "/usr/include/boost/intrusive/slist.hpp" 3 4
   template<class Disposer>
   iterator erase_and_dispose(const_iterator f, const_iterator l, Disposer disposer) noexcept
   { return this->erase_after_and_dispose(this->previous(f), l, disposer); }
# 1204 "/usr/include/boost/intrusive/slist.hpp" 3 4
   template<class Iterator>
   void assign(Iterator b, Iterator e)
   {
      this->clear();
      this->insert_after(this->cbefore_begin(), b, e);
   }
# 1227 "/usr/include/boost/intrusive/slist.hpp" 3 4
   template<class Iterator, class Disposer>
   void dispose_and_assign(Disposer disposer, Iterator b, Iterator e)
   {
      this->clear_and_dispose(disposer);
      this->insert_after(this->cbefore_begin(), b, e, disposer);
   }
# 1255 "/usr/include/boost/intrusive/slist.hpp" 3 4
   void splice_after(const_iterator prev, slist_impl &x, const_iterator *l = 0) noexcept
   {
      if(x.empty()){
         if(l) *l = prev;
      }
      else if(linear && this->empty()){
         this->swap(x);
         if(l) *l = this->previous(this->cend());
      }
      else{
         const_iterator last_x(x.previous(x.end()));
         node_ptr prev_n(prev.pointed_node());
         node_ptr last_x_n(last_x.pointed_node());
         if constexpr(cache_last){
            x.set_last_node(x.get_root_node());
            if(node_traits::get_next(prev_n) == this->get_end_node()){
               this->set_last_node(last_x_n);
            }
         }
         node_algorithms::transfer_after( prev_n, x.before_begin().pointed_node(), last_x_n);
         this->priv_size_traits().increase(x.priv_size_traits().get_size());
         x.priv_size_traits().set_size(size_type(0));
         if(l) *l = last_x;
      }
   }
# 1294 "/usr/include/boost/intrusive/slist.hpp" 3 4
   void splice_after(const_iterator prev_pos, slist_impl &x, const_iterator prev_ele) noexcept
   {
      const_iterator elem = prev_ele;
      this->splice_after(prev_pos, x, prev_ele, ++elem, 1);
   }
# 1315 "/usr/include/boost/intrusive/slist.hpp" 3 4
   void splice_after(const_iterator prev_pos, slist_impl &x, const_iterator before_f, const_iterator before_l) noexcept
   {
      if constexpr(constant_time_size)
         this->splice_after(prev_pos, x, before_f, before_l, node_algorithms::distance(before_f.pointed_node(), before_l.pointed_node()));
      else
         this->priv_splice_after
            (prev_pos.pointed_node(), x, before_f.pointed_node(), before_l.pointed_node());
   }
# 1338 "/usr/include/boost/intrusive/slist.hpp" 3 4
   void splice_after(const_iterator prev_pos, slist_impl &x, const_iterator before_f, const_iterator before_l, size_type n) noexcept
   {
      (static_cast <bool> (node_algorithms::distance(before_f.pointed_node(), before_l.pointed_node()) == n) ? void (0) : __assert_fail ("node_algorithms::distance(before_f.pointed_node(), before_l.pointed_node()) == n", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      (void)n;
      this->priv_splice_after
         (prev_pos.pointed_node(), x, before_f.pointed_node(), before_l.pointed_node());
      if constexpr(constant_time_size){
         this->priv_size_traits().increase(n);
         x.priv_size_traits().decrease(n);
      }
   }
# 1371 "/usr/include/boost/intrusive/slist.hpp" 3 4
   void splice(const_iterator it, slist_impl &x, const_iterator *l = 0) noexcept
   { this->splice_after(this->previous(it), x, l); }
# 1388 "/usr/include/boost/intrusive/slist.hpp" 3 4
   void splice(const_iterator pos, slist_impl &x, const_iterator elem) noexcept
   { return this->splice_after(this->previous(pos), x, x.previous(elem)); }
# 1408 "/usr/include/boost/intrusive/slist.hpp" 3 4
   void splice(const_iterator pos, slist_impl &x, const_iterator f, const_iterator l) noexcept
   { return this->splice_after(this->previous(pos), x, x.previous(f), x.previous(l)); }
# 1427 "/usr/include/boost/intrusive/slist.hpp" 3 4
   void splice(const_iterator pos, slist_impl &x, const_iterator f, const_iterator l, size_type n) noexcept
   { return this->splice_after(this->previous(pos), x, x.previous(f), x.previous(l), n); }
# 1441 "/usr/include/boost/intrusive/slist.hpp" 3 4
   template<class Predicate>
   void sort(Predicate p)
   {
      if (node_traits::get_next(node_traits::get_next(this->get_root_node()))
         != this->get_root_node()) {

         slist_impl carry(this->priv_value_traits());
         detail::array_initializer<slist_impl, 64> counter(this->priv_value_traits());
         int fill = 0;
         const_iterator last_inserted;
         while(!this->empty()){
            last_inserted = this->cbegin();
            carry.splice_after(carry.cbefore_begin(), *this, this->cbefore_begin());
            int i = 0;
            while(i < fill && !counter[i].empty()) {
               carry.swap(counter[i]);
               carry.merge(counter[i++], p, &last_inserted);
            }
            (static_cast <bool> (counter[i].empty()) ? void (0) : __assert_fail ("counter[i].empty()", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
            const_iterator last_element(carry.previous(last_inserted, carry.end()));

            if constexpr(constant_time_size){
               counter[i].splice_after( counter[i].cbefore_begin(), carry
                                    , carry.cbefore_begin(), last_element
                                    , carry.size());
            }
            else{
               counter[i].splice_after( counter[i].cbefore_begin(), carry
                                    , carry.cbefore_begin(), last_element);
            }
            if(i == fill)
               ++fill;
         }

         for (int i = 1; i < fill; ++i)
            counter[i].merge(counter[i-1], p, &last_inserted);
         --fill;
         const_iterator last_element(counter[fill].previous(last_inserted, counter[fill].end()));
         if constexpr(constant_time_size){
            this->splice_after( cbefore_begin(), counter[fill], counter[fill].cbefore_begin()
                              , last_element, counter[fill].size());
         }
         else{
            this->splice_after( cbefore_begin(), counter[fill], counter[fill].cbefore_begin()
                              , last_element);
         }
      }
   }
# 1506 "/usr/include/boost/intrusive/slist.hpp" 3 4
   void sort()
   { this->sort(value_less<value_type>()); }
# 1528 "/usr/include/boost/intrusive/slist.hpp" 3 4
   template<class Predicate>
   void merge(slist_impl& x, Predicate p, const_iterator *l = 0)
   {
      const_iterator e(this->cend()), ex(x.cend()), bb(this->cbefore_begin()),
                     bb_next;
      if(l) *l = e.unconst();
      while(!x.empty()){
         const_iterator ibx_next(x.cbefore_begin()), ibx(ibx_next++);
         while (++(bb_next = bb) != e && !p(*ibx_next, *bb_next)){
            bb = bb_next;
         }
         if(bb_next == e){

            this->splice_after(bb, x, l);
            break;
         }
         else{
            size_type n(0);
            do{
               ibx = ibx_next; ++n;
            } while(++(ibx_next = ibx) != ex && p(*ibx_next, *bb_next));
            this->splice_after(bb, x, x.before_begin(), ibx, n);
            if(l) *l = ibx;
         }
      }
   }
# 1566 "/usr/include/boost/intrusive/slist.hpp" 3 4
   void merge(slist_impl& x)
   { this->merge(x, value_less<value_type>()); }
# 1576 "/usr/include/boost/intrusive/slist.hpp" 3 4
   void reverse() noexcept
   {
      if(cache_last && !this->empty()){
         this->set_last_node(node_traits::get_next(this->get_root_node()));
      }
      this->priv_reverse(detail::bool_<linear>());
   }
# 1594 "/usr/include/boost/intrusive/slist.hpp" 3 4
   void remove(const_reference value) noexcept
   { this->remove_if(detail::equal_to_value<const_reference>(value)); }
# 1608 "/usr/include/boost/intrusive/slist.hpp" 3 4
   template<class Disposer>
   void remove_and_dispose(const_reference value, Disposer disposer) noexcept
   { this->remove_and_dispose_if(detail::equal_to_value<const_reference>(value), disposer); }
# 1621 "/usr/include/boost/intrusive/slist.hpp" 3 4
   template<class Pred>
   void remove_if(Pred pred)
   {
      const node_ptr bbeg = this->get_root_node();
      typename node_algorithms::stable_partition_info info;
      node_algorithms::stable_partition
         (bbeg, this->get_end_node(), detail::key_nodeptr_comp<Pred, value_traits>(pred, &this->priv_value_traits()), info);

      if constexpr(cache_last){
         this->set_last_node(info.new_last_node);
      }

      this->erase_after( const_iterator(bbeg, this->priv_value_traits_ptr())
                       , const_iterator(info.beg_2st_partition, this->priv_value_traits_ptr())
                       , info.num_1st_partition);
   }
# 1650 "/usr/include/boost/intrusive/slist.hpp" 3 4
   template<class Pred, class Disposer>
   void remove_and_dispose_if(Pred pred, Disposer disposer)
   {
      const node_ptr bbeg = this->get_root_node();
      typename node_algorithms::stable_partition_info info;
      node_algorithms::stable_partition
         (bbeg, this->get_end_node(), detail::key_nodeptr_comp<Pred, value_traits>(pred, &this->priv_value_traits()), info);

      if constexpr(cache_last){
         this->set_last_node(info.new_last_node);
      }

      this->erase_after_and_dispose( const_iterator(bbeg, this->priv_value_traits_ptr())
                                   , const_iterator(info.beg_2st_partition, this->priv_value_traits_ptr())
                                   , disposer);
   }
# 1676 "/usr/include/boost/intrusive/slist.hpp" 3 4
   void unique()
   { this->unique_and_dispose(value_equal<value_type>(), detail::null_disposer()); }
# 1689 "/usr/include/boost/intrusive/slist.hpp" 3 4
   template<class BinaryPredicate>
   void unique(BinaryPredicate pred)
   { this->unique_and_dispose(pred, detail::null_disposer()); }
# 1705 "/usr/include/boost/intrusive/slist.hpp" 3 4
   template<class Disposer>
   void unique_and_dispose(Disposer disposer)
   { this->unique(value_equal<value_type>(), disposer); }
# 1721 "/usr/include/boost/intrusive/slist.hpp" 3 4
   template<class BinaryPredicate, class Disposer>
   void unique_and_dispose(BinaryPredicate pred, Disposer disposer)
   {
      const_iterator end_n(this->cend());
      const_iterator bcur(this->cbegin());
      if(bcur != end_n){
         const_iterator cur(bcur);
         ++cur;
         while(cur != end_n) {
            if (pred(*bcur, *cur)){
               cur = this->erase_after_and_dispose(bcur, disposer);
            }
            else{
               bcur = cur;
               ++cur;
            }
         }
         if constexpr(cache_last){
            this->set_last_node(bcur.pointed_node());
         }
      }
   }
# 1755 "/usr/include/boost/intrusive/slist.hpp" 3 4
   static iterator s_iterator_to(reference value) noexcept
   {
      static_assert((!stateful_value_traits), "(!stateful_value_traits)");
      return iterator (value_traits::to_node_ptr(value), const_value_traits_ptr());
   }
# 1772 "/usr/include/boost/intrusive/slist.hpp" 3 4
   static const_iterator s_iterator_to(const_reference value) noexcept
   {
      static_assert((!stateful_value_traits), "(!stateful_value_traits)");
      reference r =*detail::uncast(pointer_traits<const_pointer>::pointer_to(value));
      return const_iterator(value_traits::to_node_ptr(r), const_value_traits_ptr());
   }
# 1788 "/usr/include/boost/intrusive/slist.hpp" 3 4
   iterator iterator_to(reference value) noexcept
   {
      (static_cast <bool> (linear || !node_algorithms::inited(this->priv_value_traits().to_node_ptr(value))) ? void (0) : __assert_fail ("linear || !node_algorithms::inited(this->priv_value_traits().to_node_ptr(value))", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      return iterator (this->priv_value_traits().to_node_ptr(value), this->priv_value_traits_ptr());
   }
# 1803 "/usr/include/boost/intrusive/slist.hpp" 3 4
   const_iterator iterator_to(const_reference value) const noexcept
   {
      reference r =*detail::uncast(pointer_traits<const_pointer>::pointer_to(value));
      (static_cast <bool> (linear || !node_algorithms::inited(this->priv_value_traits().to_node_ptr(r))) ? void (0) : __assert_fail ("linear || !node_algorithms::inited(this->priv_value_traits().to_node_ptr(r))", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      return const_iterator(this->priv_value_traits().to_node_ptr(r), this->priv_value_traits_ptr());
   }
# 1818 "/usr/include/boost/intrusive/slist.hpp" 3 4
   iterator previous(iterator i) noexcept
   { return this->previous(this->cbefore_begin(), i); }
# 1829 "/usr/include/boost/intrusive/slist.hpp" 3 4
   const_iterator previous(const_iterator i) const noexcept
   { return this->previous(this->cbefore_begin(), i); }
# 1841 "/usr/include/boost/intrusive/slist.hpp" 3 4
   iterator previous(const_iterator prev_from, iterator i) noexcept
   { return this->previous(prev_from, const_iterator(i)).unconst(); }
# 1853 "/usr/include/boost/intrusive/slist.hpp" 3 4
   const_iterator previous(const_iterator prev_from, const_iterator i) const noexcept
   {
      if(cache_last && (i.pointed_node() == this->get_end_node())){
         return const_iterator(detail::uncast(this->get_last_node()), this->priv_value_traits_ptr());
      }
      return const_iterator
         (node_algorithms::get_previous_node
            (prev_from.pointed_node(), i.pointed_node()), this->priv_value_traits_ptr());
   }
# 1881 "/usr/include/boost/intrusive/slist.hpp" 3 4
   void incorporate_after(const_iterator prev_pos, node_ptr f, node_ptr before_l) noexcept
   {
      if constexpr(constant_time_size)
         this->incorporate_after(prev_pos, f, before_l, node_algorithms::distance(f.pointed_node(), before_l.pointed_node())+1);
      else
         this->priv_incorporate_after(prev_pos.pointed_node(), f, before_l);
   }
# 1905 "/usr/include/boost/intrusive/slist.hpp" 3 4
   void incorporate_after(const_iterator prev_pos, node_ptr f, node_ptr before_l, size_type n) noexcept
   {
      if(n){
         (static_cast <bool> (n > 0) ? void (0) : __assert_fail ("n > 0", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
         (static_cast <bool> (size_type(boost::intrusive::iterator_distance ( iterator(f, this->priv_value_traits_ptr()) , iterator(before_l, this->priv_value_traits_ptr()))) +1 == n) ? void (0) : __assert_fail ("size_type(boost::intrusive::iterator_distance ( iterator(f, this->priv_value_traits_ptr()) , iterator(before_l, this->priv_value_traits_ptr()))) +1 == n", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));




         this->priv_incorporate_after(prev_pos.pointed_node(), f, before_l);
         if constexpr(constant_time_size){
            this->priv_size_traits().increase(n);
         }
      }
   }
# 1929 "/usr/include/boost/intrusive/slist.hpp" 3 4
   void check() const
   {
      const_node_ptr header_ptr = get_root_node();

      (static_cast <bool> (node_traits::get_next(header_ptr)) ? void (0) : __assert_fail ("node_traits::get_next(header_ptr)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      if (node_traits::get_next(header_ptr) == header_ptr)
      {
         (static_cast <bool> (!constant_time_size || this->priv_size_traits().get_size() == 0) ? void (0) : __assert_fail ("!constant_time_size || this->priv_size_traits().get_size() == 0", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
         return;
      }
      size_t node_count = 0; (void)node_count;
      const_node_ptr p = header_ptr;
      while (true)
      {
         const_node_ptr next_p = node_traits::get_next(p);
         if constexpr(!linear)
         {
            (static_cast <bool> (next_p) ? void (0) : __assert_fail ("next_p", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
         }
         else
         {
            (static_cast <bool> (next_p != header_ptr) ? void (0) : __assert_fail ("next_p != header_ptr", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
         }
         if ((!linear && next_p == header_ptr) || (linear && !next_p))
         {
            (static_cast <bool> (!cache_last || get_last_node() == p) ? void (0) : __assert_fail ("!cache_last || get_last_node() == p", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
            break;
         }
         p = next_p;
         ++node_count;
      }
      (static_cast <bool> (!constant_time_size || this->priv_size_traits().get_size() == node_count) ? void (0) : __assert_fail ("!constant_time_size || this->priv_size_traits().get_size() == node_count", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
   }


   friend bool operator==(const slist_impl &x, const slist_impl &y)
   {
      if(constant_time_size && x.size() != y.size()){
         return false;
      }
      return ::boost::intrusive::algo_equal(x.cbegin(), x.cend(), y.cbegin(), y.cend());
   }

   friend bool operator!=(const slist_impl &x, const slist_impl &y)
   { return !(x == y); }

   friend bool operator<(const slist_impl &x, const slist_impl &y)
   { return ::boost::intrusive::algo_lexicographical_compare(x.begin(), x.end(), y.begin(), y.end()); }

   friend bool operator>(const slist_impl &x, const slist_impl &y)
   { return y < x; }

   friend bool operator<=(const slist_impl &x, const slist_impl &y)
   { return !(y < x); }

   friend bool operator>=(const slist_impl &x, const slist_impl &y)
   { return !(x < y); }

   friend void swap(slist_impl &x, slist_impl &y)
   { x.swap(y); }

   private:
   void priv_splice_after(node_ptr prev_pos_n, slist_impl &x, node_ptr before_f_n, node_ptr before_l_n)
   {
      if (cache_last && (before_f_n != before_l_n)){
         if(prev_pos_n == this->get_last_node()){
            this->set_last_node(before_l_n);
         }
         if(&x != this && node_traits::get_next(before_l_n) == x.get_end_node()){
            x.set_last_node(before_f_n);
         }
      }
      node_algorithms::transfer_after(prev_pos_n, before_f_n, before_l_n);
   }

   void priv_incorporate_after(node_ptr prev_pos_n, node_ptr first_n, node_ptr before_l_n)
   {
      if constexpr(cache_last){
         if(prev_pos_n == this->get_last_node()){
            this->set_last_node(before_l_n);
         }
      }
      node_algorithms::incorporate_after(prev_pos_n, first_n, before_l_n);
   }

   void priv_reverse(detail::bool_<false>)
   { node_algorithms::reverse(this->get_root_node()); }

   void priv_reverse(detail::bool_<true>)
   {
      node_ptr new_first = node_algorithms::reverse
         (node_traits::get_next(this->get_root_node()));
      node_traits::set_next(this->get_root_node(), new_first);
   }

   void priv_shift_backwards(size_type n, detail::bool_<false>)
   {
      node_ptr l = node_algorithms::move_forward(this->get_root_node(), (std::size_t)n);
      if(cache_last && l){
         this->set_last_node(l);
      }
   }

   void priv_shift_backwards(size_type n, detail::bool_<true>)
   {
      typename node_algorithms::node_pair ret(
         node_algorithms::move_first_n_forward
            (node_traits::get_next(this->get_root_node()), (std::size_t)n));
      if(ret.first){
         node_traits::set_next(this->get_root_node(), ret.first);
         if constexpr(cache_last){
            this->set_last_node(ret.second);
         }
      }
   }

   void priv_shift_forward(size_type n, detail::bool_<false>)
   {
      node_ptr l = node_algorithms::move_backwards(this->get_root_node(), (std::size_t)n);
      if(cache_last && l){
         this->set_last_node(l);
      }
   }

   void priv_shift_forward(size_type n, detail::bool_<true>)
   {
      typename node_algorithms::node_pair ret(
         node_algorithms::move_first_n_backwards
         (node_traits::get_next(this->get_root_node()), (std::size_t)n));
      if(ret.first){
         node_traits::set_next(this->get_root_node(), ret.first);
         if constexpr(cache_last){
            this->set_last_node(ret.second);
         }
      }
   }

   static void priv_swap_cache_last(slist_impl *this_impl, slist_impl *other_impl)
   {
      bool other_was_empty = false;
      if(this_impl->empty()){

         if(other_impl->empty())
            return;

         slist_impl *tmp = this_impl;
         this_impl = other_impl;
         other_impl = tmp;
         other_was_empty = true;
      }
      else{
         other_was_empty = other_impl->empty();
      }


      node_ptr other_old_last(other_impl->get_last_node());
      node_ptr other_bfirst(other_impl->get_root_node());
      node_ptr this_bfirst(this_impl->get_root_node());
      node_ptr this_old_last(this_impl->get_last_node());


      node_algorithms::transfer_after(other_bfirst, this_bfirst, this_old_last);
      other_impl->set_last_node(this_old_last);

      if(other_was_empty){
         this_impl->set_last_node(this_bfirst);
      }
      else{

         node_algorithms::transfer_after(this_bfirst, this_old_last, other_old_last);
         this_impl->set_last_node(other_old_last);
      }
   }


   static void priv_swap_lists(node_ptr this_node, node_ptr other_node, detail::bool_<false>)
   { node_algorithms::swap_nodes(this_node, other_node); }


   static void priv_swap_lists(node_ptr this_node, node_ptr other_node, detail::bool_<true>)
   { node_algorithms::swap_trailing_nodes(this_node, other_node); }

   static slist_impl &priv_container_from_end_iterator(const const_iterator &end_iterator)
   {


      static_assert(!linear, "!linear");
      static_assert((has_container_from_iterator), "(has_container_from_iterator)");
      node_ptr p = end_iterator.pointed_node();
      header_holder_type* h = header_holder_type::get_holder(p);
      header_holder_plus_last_t* hpl = detail::parent_from_member< header_holder_plus_last_t, header_holder_type>
                                         (h, &header_holder_plus_last_t::header_holder_);
      root_plus_size* r = static_cast< root_plus_size* >(hpl);
      data_t *d = detail::parent_from_member<data_t, root_plus_size>
         ( r, &data_t::root_plus_size_);
      slist_impl *s = detail::parent_from_member<slist_impl, data_t>(d, &slist_impl::data_);
      return *s;
   }
};




template<class T, class ...Options>



struct make_slist
{

   typedef typename pack_options
      < slist_defaults,



         Options...

      >::type packed_options;

   typedef typename detail::get_value_traits
      <T, typename packed_options::proto_value_traits>::type value_traits;
   typedef slist_impl
      < value_traits
      , typename packed_options::size_type
      , (std::size_t(packed_options::linear)*slist_bool_flags::linear_pos)
        |(std::size_t(packed_options::constant_time_size)*slist_bool_flags::constant_time_size_pos)
        |(std::size_t(packed_options::cache_last)*slist_bool_flags::cache_last_pos)
      , typename packed_options::header_holder_type
      > implementation_defined;

   typedef implementation_defined type;
};







template<class T, class ...Options>

class slist
   : public make_slist<T,



         Options...

      >::type
{
   typedef typename make_slist
      <T,



      Options...

      >::type Base;

   static_assert((detail::is_same<typename Base::value_traits::value_type, T>::value), "(detail::is_same<typename Base::value_traits::value_type, T>::value)");
   public: slist(slist const &) = delete; slist& operator=(slist const &) = delete; public: typedef int boost_move_no_copy_constructor_or_assign; private: public: typedef int boost_move_emulation_t; private:

   public:
   typedef typename Base::value_traits value_traits;
   typedef typename Base::iterator iterator;
   typedef typename Base::const_iterator const_iterator;
   typedef typename Base::size_type size_type;
   typedef typename Base::node_ptr node_ptr;

   inline __attribute__ ((__always_inline__)) slist()
      : Base()
   {}

   inline __attribute__ ((__always_inline__)) explicit slist(const value_traits &v_traits)
      : Base(v_traits)
   {}

   struct incorporate_t{};

   inline __attribute__ ((__always_inline__)) slist( node_ptr f, node_ptr before_l
             , size_type n, const value_traits &v_traits = value_traits())
      : Base(f, before_l, n, v_traits)
   {}

   template<class Iterator>
   inline __attribute__ ((__always_inline__)) slist(Iterator b, Iterator e, const value_traits &v_traits = value_traits())
      : Base(b, e, v_traits)
   {}

   inline __attribute__ ((__always_inline__)) slist(slist && x)
      : Base(::boost::move((Base&)(x)))
   {}

   inline __attribute__ ((__always_inline__)) slist& operator=(slist && x)
   { return static_cast<slist &>(this->Base::operator=(::boost::move((Base&)(x)))); }

   template <class Cloner, class Disposer>
   inline __attribute__ ((__always_inline__)) void clone_from(const slist &src, Cloner cloner, Disposer disposer)
   { Base::clone_from(src, cloner, disposer); }

   template <class Cloner, class Disposer>
   inline __attribute__ ((__always_inline__)) void clone_from(slist && src, Cloner cloner, Disposer disposer)
   { Base::clone_from(::boost::move((Base&)(src)), cloner, disposer); }

   inline __attribute__ ((__always_inline__)) static slist &container_from_end_iterator(iterator end_iterator) noexcept
   { return static_cast<slist &>(Base::container_from_end_iterator(end_iterator)); }

   inline __attribute__ ((__always_inline__)) static const slist &container_from_end_iterator(const_iterator end_iterator) noexcept
   { return static_cast<const slist &>(Base::container_from_end_iterator(end_iterator)); }
};



}
}

# 1 "/usr/include/boost/intrusive/detail/config_end.hpp" 1 3 4
# 2246 "/usr/include/boost/intrusive/slist.hpp" 2 3 4
# 45 "/home/avi/scylla-maint/seastar/include/seastar/core/iostream.hh" 2







namespace bi = boost::intrusive;

namespace seastar {



namespace net { class packet; }

class data_source_impl {
public:
    virtual ~data_source_impl() {}
    virtual future<temporary_buffer<char>> get() = 0;
    virtual future<temporary_buffer<char>> skip(uint64_t n);
    virtual future<> close() { return make_ready_future<>(); }
};

class data_source {
    std::unique_ptr<data_source_impl> _dsi;
protected:
    data_source_impl* impl() const { return _dsi.get(); }
public:
    using tmp_buf = temporary_buffer<char>;

    data_source() noexcept = default;
    explicit data_source(std::unique_ptr<data_source_impl> dsi) noexcept : _dsi(std::move(dsi)) {}
    data_source(data_source&& x) noexcept = default;
    data_source& operator=(data_source&& x) noexcept = default;

    future<tmp_buf> get() noexcept {
        try {
            return _dsi->get();
        } catch (...) {
            return current_exception_as_future<tmp_buf>();
        }
    }
    future<tmp_buf> skip(uint64_t n) noexcept {
        try {
            return _dsi->skip(n);
        } catch (...) {
            return current_exception_as_future<tmp_buf>();
        }
    }
    future<> close() noexcept {
        try {
            return _dsi->close();
        } catch (...) {
            return current_exception_as_future<>();
        }
    }
};

class data_sink_impl {
public:
    virtual ~data_sink_impl() {}
    virtual temporary_buffer<char> allocate_buffer(size_t size) {
        return temporary_buffer<char>(size);
    }
    virtual future<> put(net::packet data) = 0;
    virtual future<> put(std::vector<temporary_buffer<char>> data) {
        net::packet p;
        p.reserve(data.size());
        for (auto& buf : data) {
            p = net::packet(std::move(p), net::fragment{buf.get_write(), buf.size()}, buf.release());
        }
        return put(std::move(p));
    }
    virtual future<> put(temporary_buffer<char> buf) {
        return put(net::packet(net::fragment{buf.get_write(), buf.size()}, buf.release()));
    }
    virtual future<> flush() {
        return make_ready_future<>();
    }
    virtual future<> close() = 0;





    virtual size_t buffer_size() const noexcept {
        (static_cast <bool> (false && "Data sink must have the buffer_size() method overload") ? void (0) : __assert_fail ("false && \"Data sink must have the buffer_size() method overload\"", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        return 0;
    }





    virtual bool can_batch_flushes() const noexcept {
        return false;
    }

    virtual void on_batch_flush_error() noexcept {
        (static_cast <bool> (false && "Data sink must implement on_batch_flush_error() method") ? void (0) : __assert_fail ("false && \"Data sink must implement on_batch_flush_error() method\"", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
    }
};

class data_sink {
    std::unique_ptr<data_sink_impl> _dsi;
public:
    data_sink() noexcept = default;
    explicit data_sink(std::unique_ptr<data_sink_impl> dsi) noexcept : _dsi(std::move(dsi)) {}
    data_sink(data_sink&& x) noexcept = default;
    data_sink& operator=(data_sink&& x) noexcept = default;
    temporary_buffer<char> allocate_buffer(size_t size) {
        return _dsi->allocate_buffer(size);
    }
    future<> put(std::vector<temporary_buffer<char>> data) noexcept {
      try {
        return _dsi->put(std::move(data));
      } catch (...) {
        return current_exception_as_future();
      }
    }
    future<> put(temporary_buffer<char> data) noexcept {
      try {
        return _dsi->put(std::move(data));
      } catch (...) {
        return current_exception_as_future();
      }
    }
    future<> put(net::packet p) noexcept {
      try {
        return _dsi->put(std::move(p));
      } catch (...) {
        return current_exception_as_future();
      }
    }
    future<> flush() noexcept {
      try {
        return _dsi->flush();
      } catch (...) {
        return current_exception_as_future();
      }
    }
    future<> close() noexcept {
        try {
            return _dsi->close();
        } catch (...) {
            return current_exception_as_future();
        }
    }

    size_t buffer_size() const noexcept { return _dsi->buffer_size(); }
    bool can_batch_flushes() const noexcept { return _dsi->can_batch_flushes(); }
    void on_batch_flush_error() noexcept { _dsi->on_batch_flush_error(); }
};

struct continue_consuming {};

template <typename CharType>
class stop_consuming {
public:
    using tmp_buf = temporary_buffer<CharType>;
    explicit stop_consuming(tmp_buf buf) : _buf(std::move(buf)) {}

    tmp_buf& get_buffer() { return _buf; }
    const tmp_buf& get_buffer() const { return _buf; }
private:
    tmp_buf _buf;
};

class skip_bytes {
public:
    explicit skip_bytes(uint64_t v) : _value(v) {}
    uint64_t get_value() const { return _value; }
private:
    uint64_t _value;
};

template <typename CharType>
class consumption_result {
public:
    using stop_consuming_type = stop_consuming<CharType>;
    using consumption_variant = std::variant<continue_consuming, stop_consuming_type, skip_bytes>;
    using tmp_buf = typename stop_consuming_type::tmp_buf;

                       consumption_result(std::optional<tmp_buf> opt_buf) {
        if (opt_buf) {
            _result = stop_consuming_type{std::move(opt_buf.value())};
        }
    }

    consumption_result(const continue_consuming&) {}
    consumption_result(stop_consuming_type&& stop) : _result(std::move(stop)) {}
    consumption_result(skip_bytes&& skip) : _result(std::move(skip)) {}

    consumption_variant& get() { return _result; }
    const consumption_variant& get() const { return _result; }

private:
    consumption_variant _result;
};
# 265 "/home/avi/scylla-maint/seastar/include/seastar/core/iostream.hh"
template <typename Consumer, typename CharType>
concept InputStreamConsumer = requires (Consumer c) {
    { c(temporary_buffer<CharType>{}) } -> std::same_as<future<consumption_result<CharType>>>;
};

template <typename Consumer, typename CharType>
concept ObsoleteInputStreamConsumer = requires (Consumer c) {
    { c(temporary_buffer<CharType>{}) } -> std::same_as<future<std::optional<temporary_buffer<CharType>>>>;
};





template <typename CharType>
class input_stream final {
    static_assert(sizeof(CharType) == 1, "must buffer stream of bytes");
    data_source _fd;
    temporary_buffer<CharType> _buf;
    bool _eof = false;
private:
    using tmp_buf = temporary_buffer<CharType>;
    size_t available() const noexcept { return _buf.size(); }
protected:
    void reset() noexcept { _buf = {}; }
    data_source* fd() noexcept { return &_fd; }
public:
    using consumption_result_type = consumption_result<CharType>;

    using unconsumed_remainder = std::optional<tmp_buf>;
    using char_type = CharType;
    input_stream() noexcept = default;
    explicit input_stream(data_source fd) noexcept : _fd(std::move(fd)), _buf() {}
    input_stream(input_stream&&) = default;
    input_stream& operator=(input_stream&&) = default;
# 310 "/home/avi/scylla-maint/seastar/include/seastar/core/iostream.hh"
    future<temporary_buffer<CharType>> read_exactly(size_t n) noexcept;
    template <typename Consumer>
    requires InputStreamConsumer<Consumer, CharType> || ObsoleteInputStreamConsumer<Consumer, CharType>
    future<> consume(Consumer&& c) noexcept(std::is_nothrow_move_constructible_v<Consumer>);
    template <typename Consumer>
    requires InputStreamConsumer<Consumer, CharType> || ObsoleteInputStreamConsumer<Consumer, CharType>
    future<> consume(Consumer& c) noexcept(std::is_nothrow_move_constructible_v<Consumer>);





    bool eof() const noexcept { return _eof; }


    future<tmp_buf> read() noexcept;


    future<tmp_buf> read_up_to(size_t n) noexcept;
# 338 "/home/avi/scylla-maint/seastar/include/seastar/core/iostream.hh"
    future<> close() noexcept {
        return _fd.close();
    }

    future<> skip(uint64_t n) noexcept;
# 355 "/home/avi/scylla-maint/seastar/include/seastar/core/iostream.hh"
    data_source detach() &&;
private:
    future<temporary_buffer<CharType>> read_exactly_part(size_t n) noexcept;
};

struct output_stream_options {
    bool trim_to_size = false;

    bool batch_flushes = false;
};
# 377 "/home/avi/scylla-maint/seastar/include/seastar/core/iostream.hh"
template <typename CharType>
class output_stream final {
    static_assert(sizeof(CharType) == 1, "must buffer stream of bytes");
    data_sink _fd;
    temporary_buffer<CharType> _buf;
    net::packet _zc_bufs = net::packet::make_null_packet();
    size_t _size = 0;
    size_t _begin = 0;
    size_t _end = 0;
    bool _trim_to_size = false;
    bool _batch_flushes = false;
    std::optional<promise<>> _in_batch;
    bool _flush = false;
    bool _flushing = false;
    std::exception_ptr _ex;
    bi::slist_member_hook<> _in_poller;

private:
    size_t available() const noexcept { return _end - _begin; }
    future<> split_and_put(temporary_buffer<CharType> buf) noexcept;
    future<> put(temporary_buffer<CharType> buf) noexcept;
    void poll_flush() noexcept;
    future<> do_flush() noexcept;
    future<> zero_copy_put(net::packet p) noexcept;
    future<> zero_copy_split_and_put(net::packet p) noexcept;
    [[gnu::noinline]]
    future<> slow_write(const CharType* buf, size_t n) noexcept;
public:
    using char_type = CharType;
    output_stream() noexcept = default;
    output_stream(data_sink fd, size_t size, output_stream_options opts = {}) noexcept
        : _fd(std::move(fd)), _size(size), _trim_to_size(opts.trim_to_size), _batch_flushes(opts.batch_flushes && _fd.can_batch_flushes()) {}
    [[deprecated("use output_stream_options instead of booleans")]]
    output_stream(data_sink fd, size_t size, bool trim_to_size, bool batch_flushes = false) noexcept
        : _fd(std::move(fd)), _size(size), _trim_to_size(trim_to_size), _batch_flushes(batch_flushes && _fd.can_batch_flushes()) {}
    output_stream(data_sink fd) noexcept
        : _fd(std::move(fd)), _size(_fd.buffer_size()), _trim_to_size(true) {}
    output_stream(output_stream&&) noexcept = default;
    output_stream& operator=(output_stream&&) noexcept = default;
    ~output_stream() {
        if (_batch_flushes) {
            (static_cast <bool> (!_in_batch && "Was this stream properly closed?") ? void (0) : __assert_fail ("!_in_batch && \"Was this stream properly closed?\"", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        } else {
            (static_cast <bool> (!_end && !_zc_bufs && "Was this stream properly closed?") ? void (0) : __assert_fail ("!_end && !_zc_bufs && \"Was this stream properly closed?\"", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        }
    }
    future<> write(const char_type* buf, size_t n) noexcept;
    future<> write(const char_type* buf) noexcept;

    template <typename StringChar, typename SizeType, SizeType MaxSize, bool NulTerminate>
    future<> write(const basic_sstring<StringChar, SizeType, MaxSize, NulTerminate>& s) noexcept;
    future<> write(const std::basic_string<char_type>& s) noexcept;

    future<> write(net::packet p) noexcept;
    future<> write(scattered_message<char_type> msg) noexcept;
    future<> write(temporary_buffer<char_type>) noexcept;
    future<> flush() noexcept;




    future<> close() noexcept;
# 451 "/home/avi/scylla-maint/seastar/include/seastar/core/iostream.hh"
    data_sink detach() &&;

    using batch_flush_list_t = bi::slist<output_stream,
            bi::constant_time_size<false>, bi::cache_last<true>,
            bi::member_hook<output_stream, bi::slist_member_hook<>, &output_stream::_in_poller>>;
private:
    friend class reactor;
};




template <typename CharType>
future<> copy(input_stream<CharType>&, output_stream<CharType>&);


}

# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/iostream-impl.hh" 1
# 26 "/home/avi/scylla-maint/seastar/include/seastar/core/iostream-impl.hh"
# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/coroutine.hh" 1
# 26 "/home/avi/scylla-maint/seastar/include/seastar/core/coroutine.hh"
# 1 "/home/avi/scylla-maint/seastar/include/seastar/coroutine/exception.hh" 1
# 25 "/home/avi/scylla-maint/seastar/include/seastar/coroutine/exception.hh"
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/coroutine" 1 3
# 33 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/coroutine" 3


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 36 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/coroutine" 2 3
# 60 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/coroutine" 3
namespace std __attribute__ ((__visibility__ ("default")))
{


  inline namespace __n4861 {






  template <typename _Result, typename... _ArgTypes>
    struct coroutine_traits;

  template <typename _Result, typename = void>
   struct __coroutine_traits_impl {};

  template <typename _Result>

    requires requires { typename _Result::promise_type; }
    struct __coroutine_traits_impl<_Result, void>




    {
      using promise_type = typename _Result::promise_type;
    };

  template <typename _Result, typename... _ArgTypes>
    struct coroutine_traits : __coroutine_traits_impl<_Result> {};



  template <typename _Promise = void>
    struct coroutine_handle;

  template <> struct
    coroutine_handle<void>
    {
    public:

      constexpr coroutine_handle() noexcept : _M_fr_ptr(0) {}

      constexpr coroutine_handle(std::nullptr_t __h) noexcept
 : _M_fr_ptr(__h)
      {}

      coroutine_handle& operator=(std::nullptr_t) noexcept
      {
 _M_fr_ptr = nullptr;
 return *this;
      }

    public:

      constexpr void* address() const noexcept { return _M_fr_ptr; }

      constexpr static coroutine_handle from_address(void* __a) noexcept
      {
 coroutine_handle __self;
 __self._M_fr_ptr = __a;
 return __self;
      }

    public:

      constexpr explicit operator bool() const noexcept
      {
 return bool(_M_fr_ptr);
      }

      bool done() const noexcept { return __builtin_coro_done(_M_fr_ptr); }


      void operator()() const { resume(); }

      void resume() const { __builtin_coro_resume(_M_fr_ptr); }

      void destroy() const { __builtin_coro_destroy(_M_fr_ptr); }

    protected:
      void* _M_fr_ptr;
  };



  constexpr bool
  operator==(coroutine_handle<> __a, coroutine_handle<> __b) noexcept
  {
    return __a.address() == __b.address();
  }


  constexpr strong_ordering
  operator<=>(coroutine_handle<> __a, coroutine_handle<> __b) noexcept
  {
    return std::compare_three_way()(__a.address(), __b.address());
  }
# 192 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/coroutine" 3
  template <typename _Promise>
    struct coroutine_handle
    {


      constexpr coroutine_handle() noexcept { }

      constexpr coroutine_handle(nullptr_t) noexcept { }

      static coroutine_handle
      from_promise(_Promise& __p)
      {
 coroutine_handle __self;
 __self._M_fr_ptr
   = __builtin_coro_promise((char*) &__p, __alignof(_Promise), true);
 return __self;
      }

      coroutine_handle& operator=(nullptr_t) noexcept
      {
 _M_fr_ptr = nullptr;
 return *this;
      }



      constexpr void* address() const noexcept { return _M_fr_ptr; }

      constexpr static coroutine_handle from_address(void* __a) noexcept
      {
 coroutine_handle __self;
 __self._M_fr_ptr = __a;
 return __self;
      }


      constexpr operator coroutine_handle<>() const noexcept
      { return coroutine_handle<>::from_address(address()); }


      constexpr explicit operator bool() const noexcept
      {
 return bool(_M_fr_ptr);
      }

      bool done() const noexcept { return __builtin_coro_done(_M_fr_ptr); }


      void operator()() const { resume(); }

      void resume() const { __builtin_coro_resume(_M_fr_ptr); }

      void destroy() const { __builtin_coro_destroy(_M_fr_ptr); }


      _Promise& promise() const
      {
 void* __t
   = __builtin_coro_promise (_M_fr_ptr, __alignof(_Promise), false);
 return *static_cast<_Promise*>(__t);
      }

    private:
      void* _M_fr_ptr = nullptr;
    };


  struct noop_coroutine_promise
  {
  };



  template <>
    struct coroutine_handle<noop_coroutine_promise>
    {



      constexpr operator coroutine_handle<>() const noexcept
      { return coroutine_handle<>::from_address(address()); }


      constexpr explicit operator bool() const noexcept { return true; }

      constexpr bool done() const noexcept { return false; }


      void operator()() const noexcept {}

      void resume() const noexcept {}

      void destroy() const noexcept {}


      noop_coroutine_promise& promise() const noexcept
      { return _S_fr.__p; }


      constexpr void* address() const noexcept { return _M_fr_ptr; }

    private:
      friend coroutine_handle noop_coroutine() noexcept;

      struct __frame
      {
 static void __dummy_resume_destroy() { }

 void (*__r)() = __dummy_resume_destroy;
 void (*__d)() = __dummy_resume_destroy;
 struct noop_coroutine_promise __p;
      };

      static __frame _S_fr;

      explicit coroutine_handle() noexcept = default;

      void* _M_fr_ptr = &_S_fr;
    };

  using noop_coroutine_handle = coroutine_handle<noop_coroutine_promise>;

  inline noop_coroutine_handle::__frame
  noop_coroutine_handle::_S_fr{};

  inline noop_coroutine_handle noop_coroutine() noexcept
  {
    return noop_coroutine_handle();
  }



  struct suspend_always
  {
    constexpr bool await_ready() const noexcept { return false; }

    constexpr void await_suspend(coroutine_handle<>) const noexcept {}

    constexpr void await_resume() const noexcept {}
  };

  struct suspend_never
  {
    constexpr bool await_ready() const noexcept { return true; }

    constexpr void await_suspend(coroutine_handle<>) const noexcept {}

    constexpr void await_resume() const noexcept {}
  };

  }

  template<typename _Tp> struct hash;

  template<typename _Promise>
    struct hash<coroutine_handle<_Promise>>
    {
      size_t
      operator()(const coroutine_handle<_Promise>& __h) const noexcept
      {
 return reinterpret_cast<size_t>(__h.address());
      }
    };


}
# 26 "/home/avi/scylla-maint/seastar/include/seastar/coroutine/exception.hh" 2


namespace seastar {

namespace internal {

struct exception_awaiter {
    std::exception_ptr eptr;

    explicit exception_awaiter(std::exception_ptr&& eptr) noexcept : eptr(std::move(eptr)) {}

    exception_awaiter(const exception_awaiter&) = delete;
    exception_awaiter(exception_awaiter&&) = delete;

    bool await_ready() const noexcept {
        return false;
    }

    template<typename U>
    void await_suspend(std::coroutine_handle<U> hndl) noexcept {
        hndl.promise().set_exception(std::move(eptr));
        hndl.destroy();
    }

    void await_resume() noexcept {}
};

}

namespace coroutine {
# 71 "/home/avi/scylla-maint/seastar/include/seastar/coroutine/exception.hh"
struct exception {
    std::exception_ptr eptr;
    explicit exception(std::exception_ptr eptr) noexcept : eptr(std::move(eptr)) {}
};
# 91 "/home/avi/scylla-maint/seastar/include/seastar/coroutine/exception.hh"
[[deprecated("Use co_await coroutine::return_exception_ptr or co_return coroutine::exception instead")]]
[[nodiscard]]
inline exception make_exception(std::exception_ptr ex) noexcept {
    return exception(std::move(ex));
}

template<typename T>
[[deprecated("Use co_await coroutine::return_exception_ptr or co_return coroutine::exception instead")]]
[[nodiscard]]
exception make_exception(T&& t) noexcept {
    log_exception_trace();
    return exception(std::make_exception_ptr(std::forward<T>(t)));
}
# 125 "/home/avi/scylla-maint/seastar/include/seastar/coroutine/exception.hh"
[[nodiscard]]
inline exception return_exception_ptr(std::exception_ptr ex) noexcept {
    return exception(std::move(ex));
}
# 142 "/home/avi/scylla-maint/seastar/include/seastar/coroutine/exception.hh"
[[deprecated("Use co_await coroutine::return_exception_ptr instead")]]
[[nodiscard]]
inline exception return_exception(std::exception_ptr ex) noexcept {
    return exception(std::move(ex));
}

template<typename T>
[[nodiscard]]
exception return_exception(T&& t) noexcept {
    log_exception_trace();
    return exception(std::make_exception_ptr(std::forward<T>(t)));
}

}

inline auto operator co_await(coroutine::exception ex) noexcept {
    return internal::exception_awaiter(std::move(ex.eptr));
}

}
# 27 "/home/avi/scylla-maint/seastar/include/seastar/core/coroutine.hh" 2








namespace seastar {

namespace internal {

template <typename T = void>
class coroutine_traits_base {
public:
    class promise_type final : public seastar::task {
        seastar::promise<T> _promise;
    public:
        promise_type() = default;
        promise_type(promise_type&&) = delete;
        promise_type(const promise_type&) = delete;

        template<typename... U>
        void return_value(U&&... value) {
            _promise.set_value(std::forward<U>(value)...);
        }

        void return_value(coroutine::exception ce) noexcept {
            _promise.set_exception(std::move(ce.eptr));
        }

        void set_exception(std::exception_ptr&& eptr) noexcept {
            _promise.set_exception(std::move(eptr));
        }

        [[deprecated("Forwarding coroutine returns are deprecated as too dangerous. Use 'co_return co_await ...' until explicit syntax is available.")]]
        void return_value(future<T>&& fut) noexcept {
            fut.forward_to(std::move(_promise));
        }

        void unhandled_exception() noexcept {
            _promise.set_exception(std::current_exception());
        }

        seastar::future<T> get_return_object() noexcept {
            return _promise.get_future();
        }

        std::suspend_never initial_suspend() noexcept { return { }; }
        std::suspend_never final_suspend() noexcept { return { }; }

        virtual void run_and_dispose() noexcept override {
            auto handle = std::coroutine_handle<promise_type>::from_promise(*this);
            handle.resume();
        }

        task* waiting_task() noexcept override { return _promise.waiting_task(); }

        scheduling_group set_scheduling_group(scheduling_group sg) noexcept {
            return std::exchange(this->_sg, sg);
        }
    };
};

template <>
class coroutine_traits_base<> {
public:
   class promise_type final : public seastar::task {
        seastar::promise<> _promise;
    public:
        promise_type() = default;
        promise_type(promise_type&&) = delete;
        promise_type(const promise_type&) = delete;

        void return_void() noexcept {
            _promise.set_value();
        }

        void set_exception(std::exception_ptr&& eptr) noexcept {
            _promise.set_exception(std::move(eptr));
        }

        void unhandled_exception() noexcept {
            _promise.set_exception(std::current_exception());
        }

        seastar::future<> get_return_object() noexcept {
            return _promise.get_future();
        }

        std::suspend_never initial_suspend() noexcept { return { }; }
        std::suspend_never final_suspend() noexcept { return { }; }

        virtual void run_and_dispose() noexcept override {
            auto handle = std::coroutine_handle<promise_type>::from_promise(*this);
            handle.resume();
        }

        task* waiting_task() noexcept override { return _promise.waiting_task(); }

        scheduling_group set_scheduling_group(scheduling_group new_sg) noexcept {
            return task::set_scheduling_group(new_sg);
        }
    };
};

template<bool CheckPreempt, typename T>
struct awaiter {
    seastar::future<T> _future;
public:
    explicit awaiter(seastar::future<T>&& f) noexcept : _future(std::move(f)) { }

    awaiter(const awaiter&) = delete;
    awaiter(awaiter&&) = delete;

    bool await_ready() const noexcept {
        return _future.available() && (!CheckPreempt || !need_preempt());
    }

    template<typename U>
    void await_suspend(std::coroutine_handle<U> hndl) noexcept {
        if (!CheckPreempt || !_future.available()) {
            _future.set_coroutine(hndl.promise());
        } else {
            schedule(&hndl.promise());
        }
    }

    T await_resume() { return _future.get(); }
};

template<bool CheckPreempt>
struct awaiter<CheckPreempt, void> {
    seastar::future<> _future;
public:
    explicit awaiter(seastar::future<>&& f) noexcept : _future(std::move(f)) { }

    awaiter(const awaiter&) = delete;
    awaiter(awaiter&&) = delete;

    bool await_ready() const noexcept {
        return _future.available() && (!CheckPreempt || !need_preempt());
    }

    template<typename U>
    void await_suspend(std::coroutine_handle<U> hndl) noexcept {
        if (!CheckPreempt || !_future.available()) {
            _future.set_coroutine(hndl.promise());
        } else {
            schedule(&hndl.promise());
        }
    }

    void await_resume() { _future.get(); }
};

}



template<typename T>
auto operator co_await(future<T> f) noexcept {
    return internal::awaiter<true, T>(std::move(f));
}

namespace coroutine {





template<typename T> struct [[nodiscard]] without_preemption_check : public seastar::future<T> {
    explicit without_preemption_check(seastar::future<T>&& f) noexcept : seastar::future<T>(std::move(f)) {}
};
# 222 "/home/avi/scylla-maint/seastar/include/seastar/core/coroutine.hh"
template <typename Func>
class lambda {
    Func* _func;
public:


    explicit lambda(Func&& func) : _func(&func) {}

    template <typename... Args>
    decltype(auto) operator()(Args&&... args) const {
        return std::invoke(*_func, std::forward<Args>(args)...);
    }
};

}




template<typename T>
auto operator co_await(coroutine::without_preemption_check<T> f) noexcept {
    return internal::awaiter<false, T>(std::move(f));
}



}


namespace std {


template<typename T, typename... Args>
class coroutine_traits<seastar::future<T>, Args...> : public seastar::internal::coroutine_traits_base<T> {
};

}
# 27 "/home/avi/scylla-maint/seastar/include/seastar/core/iostream-impl.hh" 2
# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/do_with.hh" 1
# 32 "/home/avi/scylla-maint/seastar/include/seastar/core/do_with.hh"
namespace seastar {




namespace internal {

template <typename HeldState, typename Future>
class do_with_state final : public continuation_base_from_future<Future>::type {
    HeldState _held;
    typename Future::promise_type _pr;
public:
    template<typename... T>
    explicit do_with_state(T&&... args) : _held(std::forward<T>(args)...) {}
    virtual void run_and_dispose() noexcept override {
        _pr.set_urgent_state(std::move(this->_state));
        delete this;
    }
    task* waiting_task() noexcept override {
        return _pr.waiting_task();
    }
    HeldState& data() {
        return _held;
    }
    Future get_future() {
        return _pr.get_future();
    }
};

}


namespace internal {
template <typename Tuple, size_t... Idx>
inline
auto
cherry_pick_tuple(std::index_sequence<Idx...>, Tuple&& tuple) {
    return std::forward_as_tuple(std::get<Idx>(std::forward<Tuple>(tuple))...);
}

template <typename Tuple, typename Seq>
struct subtuple;

template <typename Tuple, size_t... Idx>
struct subtuple<Tuple, std::index_sequence<Idx...>> {
    using type = std::tuple<std::decay_t<std::tuple_element_t<Idx, Tuple>>...>;
};

template <typename T1, typename T2, typename... More>
inline
auto
do_with_impl(T1&& rv1, T2&& rv2, More&&... more) {
    auto all = std::forward_as_tuple(
            std::forward<T1>(rv1),
            std::forward<T2>(rv2),
            std::forward<More>(more)...);
    constexpr size_t nr = std::tuple_size<decltype(all)>::value - 1;
    using idx = std::make_index_sequence<nr>;
    auto&& just_values = cherry_pick_tuple(idx(), std::move(all));
    auto&& just_func = std::move(std::get<nr>(std::move(all)));
    using value_tuple = typename subtuple<decltype(all), idx>::type;
    using ret_type = decltype(std::apply(just_func, std::declval<value_tuple&>()));
    auto task = std::apply(
        [](auto&&... x) {
            return std::make_unique<internal::do_with_state<value_tuple, ret_type>>(std::forward<decltype(x)>(x)...);
        },
        std::move(just_values));
    auto fut = std::apply(just_func, task->data());
    if (fut.available()) {
        return fut;
    }
    auto ret = task->get_future();
    internal::set_callback(std::move(fut), task.release());
    return ret;
}
}
# 132 "/home/avi/scylla-maint/seastar/include/seastar/core/do_with.hh"
template <typename T1, typename T2, typename... More>
inline
auto
do_with(T1&& rv1, T2&& rv2, More&&... more) noexcept {
    auto func = internal::do_with_impl<T1, T2, More...>;
    return futurize_invoke(func, std::forward<T1>(rv1), std::forward<T2>(rv2), std::forward<More>(more)...);
}
# 147 "/home/avi/scylla-maint/seastar/include/seastar/core/do_with.hh"
template<typename Lock, typename Func>
inline
auto with_lock(Lock& lock, Func&& func) {
    return lock.lock().then([&lock, func = std::forward<Func>(func)] () mutable {
        return futurize_invoke(func).finally([&lock] {
            lock.unlock();
        });
    });
}





}
# 28 "/home/avi/scylla-maint/seastar/include/seastar/core/iostream-impl.hh" 2
# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/loop.hh" 1
# 26 "/home/avi/scylla-maint/seastar/include/seastar/core/loop.hh"
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 1 3
# 42 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 3


# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 45 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 2 3
# 27 "/home/avi/scylla-maint/seastar/include/seastar/core/loop.hh" 2
# 38 "/home/avi/scylla-maint/seastar/include/seastar/core/loop.hh"
# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/semaphore.hh" 1
# 26 "/home/avi/scylla-maint/seastar/include/seastar/core/semaphore.hh"
# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/chunked_fifo.hh" 1
# 30 "/home/avi/scylla-maint/seastar/include/seastar/core/chunked_fifo.hh"
namespace seastar {
# 89 "/home/avi/scylla-maint/seastar/include/seastar/core/chunked_fifo.hh"
template <typename T, size_t items_per_chunk = 128>
class chunked_fifo {
    static_assert((items_per_chunk & (items_per_chunk - 1)) == 0,
            "chunked_fifo chunk size must be power of two");
    union maybe_item {
        maybe_item() noexcept {}
        ~maybe_item() {}
        T data;
    };
    struct chunk {
        maybe_item items[items_per_chunk];
        struct chunk* next;

        unsigned begin;
        unsigned end;
    };



    chunk* _front_chunk = nullptr;
    chunk* _back_chunk = nullptr;







    size_t _nchunks = 0;




    chunk* _free_chunks = nullptr;
    size_t _nfree_chunks = 0;
public:
    using value_type = T;
    using size_type = size_t;
    using reference = T&;
    using pointer = T*;
    using const_reference = const T&;
    using const_pointer = const T*;

private:
    template <bool IsConst>
    class basic_iterator {
        friend class chunked_fifo;

    public:
        using iterator_category = std::forward_iterator_tag;
        using difference_type = std::ptrdiff_t;
        using value_type = std::conditional_t<IsConst, const T, T>;
        using pointer = value_type*;
        using reference = value_type&;

    private:
        using chunk_t = std::conditional_t<IsConst, const chunk, chunk>;
        chunk_t* _chunk = nullptr;
        size_t _item_index = 0;

    protected:
        inline explicit basic_iterator(chunk_t* c) noexcept;
        inline basic_iterator(chunk_t* c, size_t item_index) noexcept;

    public:
        basic_iterator() noexcept = default;
        template<bool OtherIsConst, std::enable_if_t<IsConst && !OtherIsConst, int> = 0>
        inline basic_iterator(const basic_iterator<OtherIsConst>& o) noexcept
   : basic_iterator{o._chunk, o._item_index} {}
        inline bool operator==(const basic_iterator& o) const noexcept;
        inline bool operator!=(const basic_iterator& o) const noexcept;
        inline pointer operator->() const noexcept;
        inline reference operator*() const noexcept;
        inline basic_iterator operator++(int) noexcept;
        basic_iterator& operator++() noexcept;
    };

public:
    using iterator = basic_iterator<false>;
    using const_iterator = basic_iterator<true>;

public:
    chunked_fifo() noexcept = default;
    chunked_fifo(chunked_fifo&& x) noexcept;
    chunked_fifo(const chunked_fifo& X) = delete;
    ~chunked_fifo();
    chunked_fifo& operator=(const chunked_fifo&) = delete;
    chunked_fifo& operator=(chunked_fifo&&) noexcept;
    inline void push_back(const T& data);
    inline void push_back(T&& data);
    T& back() noexcept;
    const T& back() const noexcept;
    template <typename... A>
    inline void emplace_back(A&&... args);
    inline T& front() const noexcept;
    inline void pop_front() noexcept;
    inline bool empty() const noexcept;
    inline size_t size() const noexcept;
    void clear() noexcept;






    void reserve(size_t n);


    void shrink_to_fit() noexcept;
    inline iterator begin() noexcept;
    inline iterator end() noexcept;
    inline const_iterator begin() const noexcept;
    inline const_iterator end() const noexcept;
    inline const_iterator cbegin() const noexcept;
    inline const_iterator cend() const noexcept;
private:
    void back_chunk_new();
    void front_chunk_delete() noexcept;
    inline void ensure_room_back();
    void undo_room_back() noexcept;
    static inline size_t mask(size_t idx) noexcept;

};

template <typename T, size_t items_per_chunk>
template <bool IsConst>
inline
chunked_fifo<T, items_per_chunk>::basic_iterator<IsConst>::basic_iterator(chunk_t* c) noexcept : _chunk(c), _item_index(_chunk ? _chunk->begin : 0) {
}

template <typename T, size_t items_per_chunk>
template <bool IsConst>
inline
chunked_fifo<T, items_per_chunk>::basic_iterator<IsConst>::basic_iterator(chunk_t* c, size_t item_index) noexcept : _chunk(c), _item_index(item_index) {
}

template <typename T, size_t items_per_chunk>
template <bool IsConst>
inline bool
chunked_fifo<T, items_per_chunk>::basic_iterator<IsConst>::operator==(const basic_iterator& o) const noexcept {
    return _chunk == o._chunk && _item_index == o._item_index;
}

template <typename T, size_t items_per_chunk>
template <bool IsConst>
inline bool
chunked_fifo<T, items_per_chunk>::basic_iterator<IsConst>::operator!=(const basic_iterator& o) const noexcept {
    return !(*this == o);
}

template <typename T, size_t items_per_chunk>
template <bool IsConst>
inline typename chunked_fifo<T, items_per_chunk>::template basic_iterator<IsConst>::pointer
chunked_fifo<T, items_per_chunk>::basic_iterator<IsConst>::operator->() const noexcept {
    return &_chunk->items[chunked_fifo::mask(_item_index)].data;
}

template <typename T, size_t items_per_chunk>
template <bool IsConst>
inline typename chunked_fifo<T, items_per_chunk>::template basic_iterator<IsConst>::reference
chunked_fifo<T, items_per_chunk>::basic_iterator<IsConst>::operator*() const noexcept {
    return _chunk->items[chunked_fifo::mask(_item_index)].data;
}

template <typename T, size_t items_per_chunk>
template <bool IsConst>
inline typename chunked_fifo<T, items_per_chunk>::template basic_iterator<IsConst>
chunked_fifo<T, items_per_chunk>::basic_iterator<IsConst>::operator++(int) noexcept {
    auto it = *this;
    ++(*this);
    return it;
}

template <typename T, size_t items_per_chunk>
template <bool IsConst>
typename chunked_fifo<T, items_per_chunk>::template basic_iterator<IsConst>&
chunked_fifo<T, items_per_chunk>::basic_iterator<IsConst>::operator++() noexcept {
    ++_item_index;
    if (_item_index == _chunk->end) {
        _chunk = _chunk->next;
        _item_index = _chunk ? _chunk->begin : 0;
    }
    return *this;
}

template <typename T, size_t items_per_chunk>
inline
chunked_fifo<T, items_per_chunk>::chunked_fifo(chunked_fifo&& x) noexcept
        : _front_chunk(x._front_chunk)
        , _back_chunk(x._back_chunk)
        , _nchunks(x._nchunks)
        , _free_chunks(x._free_chunks)
        , _nfree_chunks(x._nfree_chunks) {
    x._front_chunk = nullptr;
    x._back_chunk = nullptr;
    x._nchunks = 0;
    x._free_chunks = nullptr;
    x._nfree_chunks = 0;
}

template <typename T, size_t items_per_chunk>
inline
chunked_fifo<T, items_per_chunk>&
chunked_fifo<T, items_per_chunk>::operator=(chunked_fifo&& x) noexcept {
    if (&x != this) {
        this->~chunked_fifo();
        new (this) chunked_fifo(std::move(x));
    }
    return *this;
}

template <typename T, size_t items_per_chunk>
inline size_t
chunked_fifo<T, items_per_chunk>::mask(size_t idx) noexcept {
    return idx & (items_per_chunk - 1);
}

template <typename T, size_t items_per_chunk>
inline bool
chunked_fifo<T, items_per_chunk>::empty() const noexcept {
    return _front_chunk == nullptr;
}

template <typename T, size_t items_per_chunk>
inline size_t
chunked_fifo<T, items_per_chunk>::size() const noexcept{
    if (_front_chunk == nullptr) {
        return 0;
    } else if (_back_chunk == _front_chunk) {

        return _front_chunk->end - _front_chunk->begin;
    } else {
        return _front_chunk->end - _front_chunk->begin
                +_back_chunk->end - _back_chunk->begin
                + (_nchunks - 2) * items_per_chunk;
    }
}

template <typename T, size_t items_per_chunk>
void chunked_fifo<T, items_per_chunk>::clear() noexcept {

    while (!empty()) {
        pop_front();
    }
# 370 "/home/avi/scylla-maint/seastar/include/seastar/core/chunked_fifo.hh"
}

template <typename T, size_t items_per_chunk> void
chunked_fifo<T, items_per_chunk>::shrink_to_fit() noexcept {
    while (_free_chunks) {
        auto next = _free_chunks->next;
        delete _free_chunks;
        _free_chunks = next;
    }
    _nfree_chunks = 0;
}

template <typename T, size_t items_per_chunk>
chunked_fifo<T, items_per_chunk>::~chunked_fifo() {
    clear();
    shrink_to_fit();
}

template <typename T, size_t items_per_chunk>
void
chunked_fifo<T, items_per_chunk>::back_chunk_new() {
    chunk *old = _back_chunk;
    if (_free_chunks) {
        _back_chunk = _free_chunks;
        _free_chunks = _free_chunks->next;
        --_nfree_chunks;
    } else {
        _back_chunk = new chunk;
    }
    _back_chunk->next = nullptr;
    _back_chunk->begin = 0;
    _back_chunk->end = 0;
    if (old) {
        old->next = _back_chunk;
    }
    if (_front_chunk == nullptr) {
        _front_chunk = _back_chunk;
    }
    _nchunks++;
}


template <typename T, size_t items_per_chunk>
inline void
chunked_fifo<T, items_per_chunk>::ensure_room_back() {

    if (_back_chunk == nullptr ||
            (_back_chunk->end - _back_chunk->begin) == items_per_chunk) {
        back_chunk_new();
    }
}

template <typename T, size_t items_per_chunk>
void
chunked_fifo<T, items_per_chunk>::undo_room_back() noexcept {




    if (_back_chunk->begin == _back_chunk->end) {
        delete _back_chunk;
        --_nchunks;
        if (_nchunks == 0) {
            _back_chunk = nullptr;
            _front_chunk = nullptr;
        } else {



            chunk *old = _back_chunk;
            _back_chunk = _front_chunk;
            while (_back_chunk->next != old) {
                _back_chunk = _back_chunk->next;
            }
            _back_chunk->next = nullptr;
        }
    }

}

template <typename T, size_t items_per_chunk>
template <typename... Args>
inline void
chunked_fifo<T, items_per_chunk>::emplace_back(Args&&... args) {
    ensure_room_back();
    auto p = &_back_chunk->items[mask(_back_chunk->end)].data;
    try {
        new(p) T(std::forward<Args>(args)...);
    } catch(...) {
        undo_room_back();
        throw;
    }
    ++_back_chunk->end;
}

template <typename T, size_t items_per_chunk>
inline void
chunked_fifo<T, items_per_chunk>::push_back(const T& data) {
    ensure_room_back();
    auto p = &_back_chunk->items[mask(_back_chunk->end)].data;
    try {
        new(p) T(data);
    } catch(...) {
        undo_room_back();
        throw;
    }
    ++_back_chunk->end;
}

template <typename T, size_t items_per_chunk>
inline void
chunked_fifo<T, items_per_chunk>::push_back(T&& data) {
    ensure_room_back();
    auto p = &_back_chunk->items[mask(_back_chunk->end)].data;
    try {
        new(p) T(std::move(data));
    } catch(...) {
        undo_room_back();
        throw;
    }
    ++_back_chunk->end;
}

template <typename T, size_t items_per_chunk>
inline
T&
chunked_fifo<T, items_per_chunk>::back() noexcept {
    return _back_chunk->items[mask(_back_chunk->end - 1)].data;
}

template <typename T, size_t items_per_chunk>
inline
const T&
chunked_fifo<T, items_per_chunk>::back() const noexcept {
    return _back_chunk->items[mask(_back_chunk->end - 1)].data;
}

template <typename T, size_t items_per_chunk>
inline T&
chunked_fifo<T, items_per_chunk>::front() const noexcept {
    return _front_chunk->items[mask(_front_chunk->begin)].data;
}

template <typename T, size_t items_per_chunk>
inline void
chunked_fifo<T, items_per_chunk>::front_chunk_delete() noexcept {
    chunk *next = _front_chunk->next;
# 528 "/home/avi/scylla-maint/seastar/include/seastar/core/chunked_fifo.hh"
    static constexpr int save_free_chunks = 1;
    if (_nfree_chunks < save_free_chunks) {
        _front_chunk->next = _free_chunks;
        _free_chunks = _front_chunk;
        ++_nfree_chunks;
    } else {
        delete _front_chunk;
    }

    if (_back_chunk == _front_chunk) {
        _back_chunk = nullptr;
    }
    _front_chunk = next;
    --_nchunks;
}

template <typename T, size_t items_per_chunk>
inline void
chunked_fifo<T, items_per_chunk>::pop_front() noexcept {
    front().~T();


    if (++_front_chunk->begin == _front_chunk->end) {
        front_chunk_delete();
    }
}

template <typename T, size_t items_per_chunk>
void chunked_fifo<T, items_per_chunk>::reserve(size_t n) {


    if (n <= size()) {
        return;
    }
    size_t need = n - size();


    if (_back_chunk) {
        size_t back_chunk_n = items_per_chunk - (_back_chunk->end - _back_chunk->begin);
        need -= std::min(back_chunk_n, need);
    }
    size_t needed_chunks = (need + items_per_chunk - 1) / items_per_chunk;


    if (needed_chunks <= _nfree_chunks) {
        return;
    }
    needed_chunks -= _nfree_chunks;
    while (needed_chunks--) {
        chunk *c = new chunk;
        c->next = _free_chunks;
        _free_chunks = c;
        ++_nfree_chunks;
    }
}

template <typename T, size_t items_per_chunk>
inline typename chunked_fifo<T, items_per_chunk>::iterator
chunked_fifo<T, items_per_chunk>::begin() noexcept {
    return iterator(_front_chunk);
}

template <typename T, size_t items_per_chunk>
inline typename chunked_fifo<T, items_per_chunk>::iterator
chunked_fifo<T, items_per_chunk>::end() noexcept {
    return iterator(nullptr);
}

template <typename T, size_t items_per_chunk>
inline typename chunked_fifo<T, items_per_chunk>::const_iterator
chunked_fifo<T, items_per_chunk>::begin() const noexcept {
    return const_iterator(_front_chunk);
}

template <typename T, size_t items_per_chunk>
inline typename chunked_fifo<T, items_per_chunk>::const_iterator
chunked_fifo<T, items_per_chunk>::end() const noexcept {
    return const_iterator(nullptr);
}

template <typename T, size_t items_per_chunk>
inline typename chunked_fifo<T, items_per_chunk>::const_iterator
chunked_fifo<T, items_per_chunk>::cbegin() const noexcept {
    return const_iterator(_front_chunk);
}

template <typename T, size_t items_per_chunk>
inline typename chunked_fifo<T, items_per_chunk>::const_iterator
chunked_fifo<T, items_per_chunk>::cend() const noexcept {
    return const_iterator(nullptr);
}

}
# 27 "/home/avi/scylla-maint/seastar/include/seastar/core/semaphore.hh" 2
# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/timer.hh" 1
# 26 "/home/avi/scylla-maint/seastar/include/seastar/core/timer.hh"
# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/timer-set.hh" 1
# 16 "/home/avi/scylla-maint/seastar/include/seastar/core/timer-set.hh"
# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/bitset-iter.hh" 1
# 17 "/home/avi/scylla-maint/seastar/include/seastar/core/bitset-iter.hh"
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bitset" 1 3
# 46 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bitset" 3
# 62 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bitset" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 63 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bitset" 2 3








namespace std __attribute__ ((__visibility__ ("default")))
{
# 81 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bitset" 3
  template<size_t _Nw>
    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); }

      constexpr _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)]; }


      constexpr const _WordT*
      _M_getdata() const noexcept
      { return _M_w; }


      constexpr _WordT&
      _M_hiword() noexcept
      { return _M_w[_Nw - 1]; }

      constexpr _WordT
      _M_hiword() const noexcept
      { return _M_w[_Nw - 1]; }

      constexpr 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];
      }

      constexpr 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];
      }

      constexpr 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];
      }

      constexpr void
      _M_do_left_shift(size_t __shift) noexcept;

      constexpr void
      _M_do_right_shift(size_t __shift) noexcept;

      constexpr void
      _M_do_flip() noexcept
      {
 for (size_t __i = 0; __i < _Nw; __i++)
   _M_w[__i] = ~_M_w[__i];
      }

      constexpr void
      _M_do_set() noexcept
      {

 if (__builtin_is_constant_evaluated())
   {
     for (_WordT& __w : _M_w)
       __w = ~static_cast<_WordT>(0);;
     return;
   }

 __builtin_memset(_M_w, 0xFF, _Nw * sizeof(_WordT));
      }

      constexpr void
      _M_do_reset() noexcept
      {

 if (__builtin_is_constant_evaluated())
   {
     for (_WordT& __w : _M_w)
       __w = 0;
     return;
   }

 __builtin_memset(_M_w, 0, _Nw * sizeof(_WordT));
      }

      constexpr 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<size_t _Nb>
        constexpr 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));
 }

      constexpr 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;
      }

      constexpr 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;
      }

      constexpr unsigned long
      _M_do_to_ulong() const;


      constexpr unsigned long long
      _M_do_to_ullong() const;



      constexpr size_t
      _M_do_find_first(size_t) const noexcept;


      constexpr size_t
      _M_do_find_next(size_t, size_t) const noexcept;
    };


  template<size_t _Nw>
    constexpr 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<size_t _Nw>
    constexpr 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<size_t _Nw>
    constexpr 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<size_t _Nw>
    constexpr unsigned long long
    _Base_bitset<_Nw>::_M_do_to_ullong() const
    {

      return _M_do_to_ulong();
# 340 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bitset" 3
    }


  template<size_t _Nw>
    constexpr 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 _Nw>
    constexpr 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); }

      constexpr _WordT&
      _M_getword(size_t) noexcept
      { return _M_w; }

      constexpr _WordT
      _M_getword(size_t) const noexcept
      { return _M_w; }


      constexpr const _WordT*
      _M_getdata() const noexcept
      { return &_M_w; }


      constexpr _WordT&
      _M_hiword() noexcept
      { return _M_w; }

      constexpr _WordT
      _M_hiword() const noexcept
      { return _M_w; }

      constexpr void
      _M_do_and(const _Base_bitset<1>& __x) noexcept
      { _M_w &= __x._M_w; }

      constexpr void
      _M_do_or(const _Base_bitset<1>& __x) noexcept
      { _M_w |= __x._M_w; }

      constexpr void
      _M_do_xor(const _Base_bitset<1>& __x) noexcept
      { _M_w ^= __x._M_w; }

      constexpr void
      _M_do_left_shift(size_t __shift) noexcept
      { _M_w <<= __shift; }

      constexpr void
      _M_do_right_shift(size_t __shift) noexcept
      { _M_w >>= __shift; }

      constexpr void
      _M_do_flip() noexcept
      { _M_w = ~_M_w; }

      constexpr void
      _M_do_set() noexcept
      { _M_w = ~static_cast<_WordT>(0); }

      constexpr void
      _M_do_reset() noexcept
      { _M_w = 0; }

      constexpr bool
      _M_is_equal(const _Base_bitset<1>& __x) const noexcept
      { return _M_w == __x._M_w; }

      template<size_t _Nb>
        constexpr bool
        _M_are_all() const noexcept
        { return _M_w == (~static_cast<_WordT>(0)
     >> ((8 * 8) - _Nb)); }

      constexpr bool
      _M_is_any() const noexcept
      { return _M_w != 0; }

      constexpr size_t
      _M_do_count() const noexcept
      { return __builtin_popcountl(_M_w); }

      constexpr unsigned long
      _M_do_to_ulong() const noexcept
      { return _M_w; }


      constexpr unsigned long long
      _M_do_to_ullong() const noexcept
      { return _M_w; }


      constexpr 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;
      }


      constexpr 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); }







      __attribute__((__noreturn__))
      _WordT&
      _M_getword(size_t) noexcept
      { __throw_out_of_range(("_Base_bitset::_M_getword")); }

      constexpr _WordT
      _M_getword(size_t) const noexcept
      { return 0; }

      constexpr _WordT
      _M_hiword() const noexcept
      { return 0; }

      constexpr void
      _M_do_and(const _Base_bitset<0>&) noexcept
      { }

      constexpr void
      _M_do_or(const _Base_bitset<0>&) noexcept
      { }

      constexpr void
      _M_do_xor(const _Base_bitset<0>&) noexcept
      { }

      constexpr void
      _M_do_left_shift(size_t) noexcept
      { }

      constexpr void
      _M_do_right_shift(size_t) noexcept
      { }

      constexpr void
      _M_do_flip() noexcept
      { }

      constexpr void
      _M_do_set() noexcept
      { }

      constexpr void
      _M_do_reset() noexcept
      { }




      constexpr bool
      _M_is_equal(const _Base_bitset<0>&) const noexcept
      { return true; }

      template<size_t _Nb>
        constexpr bool
        _M_are_all() const noexcept
        { return true; }

      constexpr bool
      _M_is_any() const noexcept
      { return false; }

      constexpr size_t
      _M_do_count() const noexcept
      { return 0; }

      constexpr unsigned long
      _M_do_to_ulong() const noexcept
      { return 0; }


      constexpr unsigned long long
      _M_do_to_ullong() const noexcept
      { return 0; }




      constexpr size_t
      _M_do_find_first(size_t) const noexcept
      { return 0; }

      constexpr size_t
      _M_do_find_next(size_t, size_t) const noexcept
      { return 0; }
    };



  template<size_t _Extrabits>
    struct _Sanitize
    {
      typedef unsigned long _WordT;

      static constexpr void
      _S_do_sanitize(_WordT& __val) noexcept
      { __val &= ~((~static_cast<_WordT>(0)) << _Extrabits); }
    };

  template<>
    struct _Sanitize<0>
    {
      typedef unsigned long _WordT;

      static constexpr void
      _S_do_sanitize(_WordT) noexcept { }
    };


  template<size_t _Nb, bool = (_Nb < (8 * 8))>
    struct _Sanitize_val
    {
      static constexpr unsigned long long
      _S_do_sanitize_val(unsigned long long __val)
      { return __val; }
    };

  template<size_t _Nb>
    struct _Sanitize_val<_Nb, true>
    {
      static constexpr unsigned long long
      _S_do_sanitize_val(unsigned long long __val)
      { return __val & ~((~static_cast<unsigned long long>(0)) << _Nb); }
    };

  namespace __bitset
  {

    template<typename _CharT>
      using __string = std::basic_string<_CharT>;
# 737 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bitset" 3
  }
# 803 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bitset" 3
  template<size_t _Nb>
    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<class _CharT, class _Traits, class _Alloc>
      constexpr
      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());
      }


      constexpr
      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);
      }

      constexpr
      void
      _M_do_sanitize() noexcept
      {
 typedef _Sanitize<_Nb % (8 * 8)> __sanitize_type;
 __sanitize_type::_S_do_sanitize(this->_M_hiword());
      }


      friend struct std::hash<bitset>;


    public:
# 860 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bitset" 3
      class reference
      {
 friend class bitset;

 _WordT* _M_wp;
 size_t _M_bpos;


 reference();

      public:
 constexpr
 reference(bitset& __b, size_t __pos) noexcept
 {
   _M_wp = &__b._M_getword(__pos);
   _M_bpos = _Base::_S_whichbit(__pos);
 }


 reference(const reference&) = default;



 constexpr

 ~reference() noexcept
 { }


 constexpr
 reference&
 operator=(bool __x) noexcept
 {
   if (__x)
     *_M_wp |= _Base::_S_maskbit(_M_bpos);
   else
     *_M_wp &= ~_Base::_S_maskbit(_M_bpos);
   return *this;
 }


 constexpr
 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;
 }


 constexpr
 bool
 operator~() const noexcept
 { return (*(_M_wp) & _Base::_S_maskbit(_M_bpos)) == 0; }


 constexpr
 operator bool() const noexcept
 { return (*(_M_wp) & _Base::_S_maskbit(_M_bpos)) != 0; }


 constexpr
 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)) { }
# 959 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bitset" 3
      template<class _CharT, class _Traits, class _Alloc>
 constexpr
 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'));
 }
# 982 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bitset" 3
      template<class _CharT, class _Traits, class _Alloc>
 constexpr
 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<class _CharT, class _Traits, class _Alloc>
 constexpr
 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);
 }
# 1016 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bitset" 3
      template<typename _CharT>
 [[__gnu__::__nonnull__]]
 constexpr
        explicit
 bitset(const _CharT* __str,
        typename __bitset::__string<_CharT>::size_type __n
   = __bitset::__string<_CharT>::npos,
        _CharT __zero = _CharT('0'), _CharT __one = _CharT('1'))
        : _Base()
        {

   if (!__str)
     __throw_logic_error(("bitset::bitset(const _CharT*, ...)"));

   using _Traits = typename __bitset::__string<_CharT>::traits_type;

   if (__n == __bitset::__string<_CharT>::npos)
     __n = _Traits::length(__str);
   _M_copy_from_ptr<_CharT, _Traits>(__str, __n, 0, __n, __zero, __one);
 }
# 1046 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bitset" 3
      constexpr
      bitset<_Nb>&
      operator&=(const bitset<_Nb>& __rhs) noexcept
      {
 this->_M_do_and(__rhs);
 return *this;
      }

      constexpr
      bitset<_Nb>&
      operator|=(const bitset<_Nb>& __rhs) noexcept
      {
 this->_M_do_or(__rhs);
 return *this;
      }

      constexpr
      bitset<_Nb>&
      operator^=(const bitset<_Nb>& __rhs) noexcept
      {
 this->_M_do_xor(__rhs);
 return *this;
      }
# 1078 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bitset" 3
      constexpr
      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;
      }

      constexpr
      bitset<_Nb>&
      operator>>=(size_t __position) noexcept
      {
 if (__builtin_expect(__position < _Nb, 1))
   this->_M_do_right_shift(__position);
 else
   this->_M_do_reset();
 return *this;
      }
# 1110 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bitset" 3
      constexpr
      bitset<_Nb>&
      _Unchecked_set(size_t __pos) noexcept
      {
 this->_M_getword(__pos) |= _Base::_S_maskbit(__pos);
 return *this;
      }

      constexpr
      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;
      }

      constexpr
      bitset<_Nb>&
      _Unchecked_reset(size_t __pos) noexcept
      {
 this->_M_getword(__pos) &= ~_Base::_S_maskbit(__pos);
 return *this;
      }

      constexpr
      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)); }






      constexpr
      bitset<_Nb>&
      set() noexcept
      {
 this->_M_do_set();
 this->_M_do_sanitize();
 return *this;
      }







      constexpr
      bitset<_Nb>&
      set(size_t __position, bool __val = true)
      {
 this->_M_check(__position, ("bitset::set"));
 return _Unchecked_set(__position, __val);
      }




      constexpr
      bitset<_Nb>&
      reset() noexcept
      {
 this->_M_do_reset();
 return *this;
      }
# 1196 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bitset" 3
      constexpr
      bitset<_Nb>&
      reset(size_t __position)
      {
 this->_M_check(__position, ("bitset::reset"));
 return _Unchecked_reset(__position);
      }




      constexpr
      bitset<_Nb>&
      flip() noexcept
      {
 this->_M_do_flip();
 this->_M_do_sanitize();
 return *this;
      }






      constexpr
      bitset<_Nb>&
      flip(size_t __position)
      {
 this->_M_check(__position, ("bitset::flip"));
 return _Unchecked_flip(__position);
      }


      constexpr
      bitset<_Nb>
      operator~() const noexcept
      { return bitset<_Nb>(*this).flip(); }
# 1250 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bitset" 3
      constexpr
      reference
      operator[](size_t __position)
      { return reference(*this, __position); }

      constexpr bool
      operator[](size_t __position) const
      { return _Unchecked_test(__position); }
# 1266 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bitset" 3
      constexpr
      unsigned long
      to_ulong() const
      { return this->_M_do_to_ulong(); }


      constexpr
      unsigned long long
      to_ullong() const
      { return this->_M_do_to_ullong(); }
# 1287 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bitset" 3
      template<class _CharT, class _Traits, class _Alloc>
 constexpr
 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<class _CharT, class _Traits, class _Alloc>
 constexpr
 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<class _CharT, class _Traits>
 constexpr
 std::basic_string<_CharT, _Traits, std::allocator<_CharT> >
 to_string() const
 { return to_string<_CharT, _Traits, std::allocator<_CharT> >(); }



      template<class _CharT, class _Traits>
 constexpr
 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<class _CharT>
 constexpr
 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<class _CharT>
 constexpr
 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);
 }

      constexpr
      std::basic_string<char, std::char_traits<char>, std::allocator<char> >
      to_string() const
      {
 return to_string<char, std::char_traits<char>,
                  std::allocator<char> >();
      }

      constexpr
      std::basic_string<char, std::char_traits<char>, std::allocator<char> >
      to_string(char __zero, char __one = '1') const
      {
 return to_string<char, std::char_traits<char>,
                  std::allocator<char> >(__zero, __one);
      }



      constexpr
      size_t
      count() const noexcept
      { return this->_M_do_count(); }


      constexpr size_t
      size() const noexcept
      { return _Nb; }



      constexpr
      bool
      operator==(const bitset<_Nb>& __rhs) const noexcept
      { return this->_M_is_equal(__rhs); }
# 1395 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bitset" 3
      constexpr
      bool
      test(size_t __position) const
      {
 this->_M_check(__position, ("bitset::test"));
 return _Unchecked_test(__position);
      }







      constexpr
      bool
      all() const noexcept
      { return this->template _M_are_all<_Nb>(); }





      constexpr
      bool
      any() const noexcept
      { return this->_M_is_any(); }





      constexpr
      bool
      none() const noexcept
      { return !this->_M_is_any(); }



      constexpr
      bitset<_Nb>
      operator<<(size_t __position) const noexcept
      { return bitset<_Nb>(*this) <<= __position; }

      constexpr
      bitset<_Nb>
      operator>>(size_t __position) const noexcept
      { return bitset<_Nb>(*this) >>= __position; }
# 1451 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bitset" 3
      constexpr
      size_t
      _Find_first() const noexcept
      { return this->_M_do_find_first(_Nb); }
# 1463 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bitset" 3
      constexpr
      size_t
      _Find_next(size_t __prev) const noexcept
      { return this->_M_do_find_next(__prev, _Nb); }

    private:

      template<class _CharT, class _Traits>
 constexpr
        void
        _M_copy_from_ptr(const _CharT*, size_t, size_t, size_t,
    _CharT, _CharT);


      template<class _CharT, class _Traits, class _Alloc>
 constexpr
 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<class _CharT, class _Traits, class _Alloc>
 constexpr
 void
        _M_copy_to_string(std::basic_string<_CharT, _Traits, _Alloc>&,
     _CharT, _CharT) const;

      template<class _CharT, class _Traits, size_t _Nb2>
 friend std::basic_istream<_CharT, _Traits>&
 operator>>(std::basic_istream<_CharT, _Traits>&, bitset<_Nb2>&);

      template <class _CharT, class _Traits, size_t _Nb2>
 friend std::basic_ostream<_CharT, _Traits>&
 operator<<(std::basic_ostream<_CharT, _Traits>&, const bitset<_Nb2>&);

    };


  template<size_t _Nb>
    template<class _CharT, class _Traits>
      constexpr
      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<size_t _Nb>
    template<class _CharT, class _Traits, class _Alloc>
      constexpr
      void
      bitset<_Nb>::
      _M_copy_to_string(std::basic_string<_CharT, _Traits, _Alloc>& __s,
   _CharT __zero, _CharT __one) const
      {
 __s.assign(_Nb, __zero);
 size_t __n = this->_Find_first();
 while (__n < _Nb)
   {
     __s[_Nb - __n - 1] = __one;
     __n = _Find_next(__n);
   }
      }
# 1554 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bitset" 3
  template<size_t _Nb>
    constexpr
    inline bitset<_Nb>
    operator&(const bitset<_Nb>& __x, const bitset<_Nb>& __y) noexcept
    {
      bitset<_Nb> __result(__x);
      __result &= __y;
      return __result;
    }

  template<size_t _Nb>
    constexpr
    inline bitset<_Nb>
    operator|(const bitset<_Nb>& __x, const bitset<_Nb>& __y) noexcept
    {
      bitset<_Nb> __result(__x);
      __result |= __y;
      return __result;
    }

  template <size_t _Nb>
    constexpr
    inline bitset<_Nb>
    operator^(const bitset<_Nb>& __x, const bitset<_Nb>& __y) noexcept
    {
      bitset<_Nb> __result(__x);
      __result ^= __y;
      return __result;
    }
# 1595 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bitset" 3
  template<class _CharT, class _Traits, size_t _Nb>
    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;

      struct _Buffer
      {
 static constexpr bool _S_use_alloca() { return _Nb <= 256; }

 explicit _Buffer(_CharT* __p) : _M_ptr(__p) { }

 ~_Buffer()
 {
   if constexpr (!_S_use_alloca())
     delete[] _M_ptr;
 }

 _CharT* const _M_ptr;
      };
      _CharT* __ptr;
      if constexpr (_Buffer::_S_use_alloca())
 __ptr = (_CharT*)__builtin_alloca(_Nb);
      else
 __ptr = new _CharT[_Nb];
      const _Buffer __buf(__ptr);



      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))
   *__ptr++ = __zero;
        else if (_Traits::eq(__c2, __one))
   *__ptr++ = __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 constexpr (_Nb)
      {
 if (size_t __len = __ptr - __buf._M_ptr)
   __x.template _M_copy_from_ptr<_CharT, _Traits>(__buf._M_ptr, __len,
        0, __len,
        __zero, __one);
 else
   __state |= __ios_base::failbit;
      }
      if (__state)
 __is.setstate(__state);
      return __is;
    }

  template <class _CharT, class _Traits, size_t _Nb>
    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<ctype<_CharT> >(__os.getloc());
      __x._M_copy_to_string(__tmp, __ct.widen('0'), __ct.widen('1'));
      return __os << __tmp;
    }




}







namespace std __attribute__ ((__visibility__ ("default")))
{




  template<size_t _Nb>
    struct hash<std::bitset<_Nb>>
    : public __hash_base<size_t, std::bitset<_Nb>>
    {
      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<std::bitset<0>>
    : public __hash_base<size_t, std::bitset<0>>
    {
      size_t
      operator()(const std::bitset<0>&) const noexcept
      { return 0; }
    };


}
# 18 "/home/avi/scylla-maint/seastar/include/seastar/core/bitset-iter.hh" 2




namespace seastar {

namespace bitsets {

static constexpr int ulong_bits = std::numeric_limits<unsigned long>::digits;
# 37 "/home/avi/scylla-maint/seastar/include/seastar/core/bitset-iter.hh"
template<typename T>
size_t count_leading_zeros(T value) noexcept;
# 48 "/home/avi/scylla-maint/seastar/include/seastar/core/bitset-iter.hh"
template<typename T>
size_t count_trailing_zeros(T value) noexcept;

template<>
inline size_t count_leading_zeros<unsigned long>(unsigned long value) noexcept
{
    return __builtin_clzl(value);
}

template<>
inline size_t count_leading_zeros<long>(long value) noexcept
{
    return __builtin_clzl((unsigned long)value) - 1;
}

template<>
inline size_t count_leading_zeros<unsigned long long>(unsigned long long value) noexcept
{
    return __builtin_clzll(value);
}

template<>
inline size_t count_leading_zeros<long long>(long long value) noexcept
{
    return __builtin_clzll((unsigned long long)value) - 1;
}

template<>
inline
size_t count_trailing_zeros<unsigned long>(unsigned long value) noexcept
{
    return __builtin_ctzl(value);
}

template<>
inline
size_t count_trailing_zeros<long>(long value) noexcept
{
    return __builtin_ctzl((unsigned long)value);
}

template<>
inline
size_t count_trailing_zeros<unsigned long long>(unsigned long long value) noexcept
{
    return __builtin_ctzll(value);
}

template<>
inline
size_t count_trailing_zeros<long long>(long long value) noexcept
{
    return __builtin_ctzll((unsigned long long)value);
}





template<size_t N>
inline size_t get_first_set(const std::bitset<N>& bitset) noexcept
{
    static_assert(N <= ulong_bits, "bitset too large");
    return count_trailing_zeros(bitset.to_ulong());
}





template<size_t N>
inline size_t get_last_set(const std::bitset<N>& bitset) noexcept
{
    static_assert(N <= ulong_bits, "bitset too large");
    return ulong_bits - 1 - count_leading_zeros(bitset.to_ulong());
}



template<size_t N>
class set_iterator
{
private:
    void advance() noexcept
    {
        if (_bitset.none()) {
            _index = -1;
        } else {
            auto shift = get_first_set(_bitset) + 1;
            _index += shift;
            _bitset >>= shift;
        }
    }
public:
    using iterator_category = std::input_iterator_tag;
    using value_type = int;
    using difference_type = std::ptrdiff_t;
    using pointer = int*;
    using reference = int&;

    set_iterator(std::bitset<N> bitset, int offset = 0) noexcept
        : _bitset(bitset)
        , _index(offset - 1)
    {
        static_assert(N <= ulong_bits, "This implementation is inefficient for large bitsets");
        _bitset >>= offset;
        advance();
    }

    set_iterator& operator++() noexcept
    {
        advance();
        return *this;
    }

    set_iterator operator++(int) noexcept
    {
        auto ret = *this;
        advance();
        return ret;
    }

    int operator*() const noexcept
    {
        return _index;
    }

    bool operator==(const set_iterator& other) const noexcept
    {
        return _index == other._index;
    }

    bool operator!=(const set_iterator& other) const noexcept
    {
        return !(*this == other);
    }
private:
    std::bitset<N> _bitset;
    int _index;
};

template<size_t N>
class set_range
{
public:
    using iterator = set_iterator<N>;
    using value_type = int;

    constexpr set_range(std::bitset<N> bitset, int offset = 0) noexcept
        : _bitset(bitset)
        , _offset(offset)
    {
    }

    iterator begin() const noexcept { return iterator(_bitset, _offset); }
    iterator end() const noexcept { return iterator(0); }
private:
    std::bitset<N> _bitset;
    int _offset;
};

template<size_t N>
inline set_range<N> for_each_set(std::bitset<N> bitset, int offset = 0) noexcept
{
    return set_range<N>(bitset, offset);
}



}

}
# 17 "/home/avi/scylla-maint/seastar/include/seastar/core/timer-set.hh" 2
# 26 "/home/avi/scylla-maint/seastar/include/seastar/core/timer-set.hh"
namespace seastar {

namespace internal {
void log_timer_callback_exception(std::exception_ptr) noexcept;
}
# 43 "/home/avi/scylla-maint/seastar/include/seastar/core/timer-set.hh"
template<typename Timer, boost::intrusive::list_member_hook<> Timer::*link>
class timer_set {
public:
    using time_point = typename Timer::time_point;
    using timer_list_t = boost::intrusive::list<Timer, boost::intrusive::member_hook<Timer, boost::intrusive::list_member_hook<>, link>>;
private:
    using duration = typename Timer::duration;
    using timestamp_t = typename Timer::duration::rep;

    static constexpr timestamp_t max_timestamp = std::numeric_limits<timestamp_t>::max();
    static constexpr int timestamp_bits = std::numeric_limits<timestamp_t>::digits;


    static constexpr int n_buckets = timestamp_bits + 1;

    std::array<timer_list_t, n_buckets> _buckets;
    timestamp_t _last;
    timestamp_t _next;

    std::bitset<n_buckets> _non_empty_buckets;
private:
    static timestamp_t get_timestamp(time_point _time_point) noexcept
    {
        return _time_point.time_since_epoch().count();
    }

    static timestamp_t get_timestamp(Timer& timer) noexcept
    {
        return get_timestamp(timer.get_timeout());
    }

    int get_index(timestamp_t timestamp) const noexcept
    {
        if (timestamp <= _last) {
            return n_buckets - 1;
        }

        auto index = bitsets::count_leading_zeros(timestamp ^ _last);
        (static_cast <bool> (index < n_buckets - 1) ? void (0) : __assert_fail ("index < n_buckets - 1", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        return index;
    }

    int get_index(Timer& timer) const noexcept
    {
        return get_index(get_timestamp(timer));
    }

    int get_last_non_empty_bucket() const noexcept
    {
        return bitsets::get_last_set(_non_empty_buckets);
    }

public:
    timer_set() noexcept
        : _last(0)
        , _next(max_timestamp)
        , _non_empty_buckets(0)
    {
    }

    ~timer_set() {
        for (auto&& list : _buckets) {
            while (!list.empty()) {
                auto& timer = *list.begin();
                timer.cancel();
            }
        }
    }
# 129 "/home/avi/scylla-maint/seastar/include/seastar/core/timer-set.hh"
    bool insert(Timer& timer) noexcept
    {
        auto timestamp = get_timestamp(timer);
        auto index = get_index(timestamp);

        _buckets[index].push_back(timer);
        _non_empty_buckets[index] = true;

        if (timestamp < _next) {
            _next = timestamp;
            return true;
        }
        return false;
    }
# 155 "/home/avi/scylla-maint/seastar/include/seastar/core/timer-set.hh"
    void remove(Timer& timer) noexcept
    {
        auto index = get_index(timer);
        auto& list = _buckets[index];
        list.erase(list.iterator_to(timer));
        if (list.empty()) {
            _non_empty_buckets[index] = false;
        }
    }




    void remove(Timer& timer, timer_list_t& expired) noexcept
    {
        if (timer._expired) {
            expired.erase(expired.iterator_to(timer));
            timer._expired = false;
        } else {
            remove(timer);
        }
    }
# 192 "/home/avi/scylla-maint/seastar/include/seastar/core/timer-set.hh"
    timer_list_t expire(time_point now) noexcept
    {
        timer_list_t exp;
        auto timestamp = get_timestamp(now);

        if (timestamp < _last) {
            abort();
        }

        auto index = get_index(timestamp);

        for (int i : bitsets::for_each_set(_non_empty_buckets, index + 1)) {
            exp.splice(exp.end(), _buckets[i]);
            _non_empty_buckets[i] = false;
        }

        _last = timestamp;
        _next = max_timestamp;

        auto& list = _buckets[index];
        while (!list.empty()) {
            auto& timer = *list.begin();
            list.pop_front();
            if (timer.get_timeout() <= now) {
                exp.push_back(timer);
            } else {
                insert(timer);
            }
        }

        _non_empty_buckets[index] = !list.empty();

        if (_next == max_timestamp && _non_empty_buckets.any()) {
            for (auto& timer : _buckets[get_last_non_empty_bucket()]) {
                _next = std::min(_next, get_timestamp(timer));
            }
        }
        return exp;
    }

    template <typename EnableFunc>
    void complete(timer_list_t& expired_timers, EnableFunc&& enable_fn) noexcept(noexcept(enable_fn())) {
        expired_timers = expire(this->now());
        for (auto& t : expired_timers) {
            t._expired = true;
        }
        const auto prev_sg = current_scheduling_group();
        while (!expired_timers.empty()) {
            auto t = &*expired_timers.begin();
            expired_timers.pop_front();
            t->_queued = false;
            if (t->_armed) {
                t->_armed = false;
                if (t->_period) {
                    t->readd_periodic();
                }
                try {
                    *internal::current_scheduling_group_ptr() = t->_sg;
                    t->_callback();
                } catch (...) {
                    internal::log_timer_callback_exception(std::current_exception());
                }
            }
        }


        *internal::current_scheduling_group_ptr() = prev_sg;
        enable_fn();
    }







    time_point get_next_timeout() const noexcept
    {
        return time_point(duration(std::max(_last, _next)));
    }




    void clear() noexcept
    {
        for (int i : bitsets::for_each_set(_non_empty_buckets)) {
            _buckets[i].clear();
        }
    }

    size_t size() const noexcept
    {
        size_t res = 0;
        for (int i : bitsets::for_each_set(_non_empty_buckets)) {
            res += _buckets[i].size();
        }
        return res;
    }




    bool empty() const noexcept
    {
        return _non_empty_buckets.none();
    }

    time_point now() noexcept {
        return Timer::clock::now();
    }
};
}
# 27 "/home/avi/scylla-maint/seastar/include/seastar/core/timer.hh" 2
# 52 "/home/avi/scylla-maint/seastar/include/seastar/core/timer.hh"
namespace seastar {



using steady_clock_type = std::chrono::steady_clock;
# 82 "/home/avi/scylla-maint/seastar/include/seastar/core/timer.hh"
template <typename Clock = steady_clock_type>
class timer {
public:
    typedef typename Clock::time_point time_point;
    typedef typename Clock::duration duration;
    typedef Clock clock;
private:
    using callback_t = noncopyable_function<void()>;
    boost::intrusive::list_member_hook<> _link;
    scheduling_group _sg;
    callback_t _callback;
    time_point _expiry;
    std::optional<duration> _period;
    bool _armed = false;
    bool _queued = false;
    bool _expired = false;
    void readd_periodic() noexcept;
    void arm_state(time_point until, std::optional<duration> period) noexcept {
        (static_cast <bool> (!_armed) ? void (0) : __assert_fail ("!_armed", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        _period = period;
        _armed = true;
        _expired = false;
        _expiry = until;
        _queued = true;
    }
public:

    timer() noexcept {};





    timer(timer&& t) noexcept : _sg(t._sg), _callback(std::move(t._callback)), _expiry(std::move(t._expiry)), _period(std::move(t._period)),
            _armed(t._armed), _queued(t._queued), _expired(t._expired) {
        _link.swap_nodes(t._link);
        t._queued = false;
        t._armed = false;
    }




    timer(scheduling_group sg, noncopyable_function<void ()>&& callback) noexcept : _sg(sg), _callback{std::move(callback)} {
    }



    explicit timer(noncopyable_function<void ()>&& callback) noexcept : timer(current_scheduling_group(), std::move(callback)) {
    }

    ~timer();




    void set_callback(scheduling_group sg, noncopyable_function<void ()>&& callback) noexcept {
        _sg = sg;
        _callback = std::move(callback);
    }



    void set_callback(noncopyable_function<void ()>&& callback) noexcept {
        set_callback(current_scheduling_group(), std::move(callback));
    }
# 159 "/home/avi/scylla-maint/seastar/include/seastar/core/timer.hh"
    void arm(time_point until, std::optional<duration> period = {}) noexcept;







    void rearm(time_point until, std::optional<duration> period = {}) noexcept {
        if (_armed) {
            cancel();
        }
        arm(until, period);
    }
# 181 "/home/avi/scylla-maint/seastar/include/seastar/core/timer.hh"
    void arm(duration delta) noexcept {
        return arm(Clock::now() + delta);
    }




    void arm_periodic(duration delta) noexcept {
        arm(Clock::now() + delta, {delta});
    }





    void rearm_periodic(duration delta) noexcept {
        if (_armed) {
            cancel();
        }
        arm_periodic(delta);
    }



    bool armed() const noexcept { return _armed; }






    bool cancel() noexcept;




    time_point get_timeout() const noexcept {
        return _expiry;
    }

    friend class timer_set<timer, &timer::_link>;
    using set_t = timer_set<timer, &timer::_link>;
};

extern template class timer<steady_clock_type>;




}
# 28 "/home/avi/scylla-maint/seastar/include/seastar/core/semaphore.hh" 2
# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/abortable_fifo.hh" 1
# 24 "/home/avi/scylla-maint/seastar/include/seastar/core/abortable_fifo.hh"
# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/abort_source.hh" 1
# 26 "/home/avi/scylla-maint/seastar/include/seastar/core/abort_source.hh"
# 1 "/home/avi/scylla-maint/seastar/include/seastar/util/optimized_optional.hh" 1
# 32 "/home/avi/scylla-maint/seastar/include/seastar/util/optimized_optional.hh"
namespace seastar {

template<typename T>
concept OptimizableOptional =
    std::is_default_constructible_v<T>
        && std::is_nothrow_move_assignable_v<T>
        && requires(const T& obj) {
            { bool(obj) } noexcept;
        };






template<typename T>
class optimized_optional {
    T _object;
public:
    optimized_optional() = default;
    optimized_optional(std::nullopt_t) noexcept { }
    optimized_optional(const T& obj) : _object(obj) { }
    optimized_optional(T&& obj) noexcept : _object(std::move(obj)) { }
    optimized_optional(std::optional<T>&& obj) noexcept {
        if (obj) {
            _object = std::move(*obj);
        }
    }
    optimized_optional(const optimized_optional&) = default;
    optimized_optional(optimized_optional&&) = default;

    optimized_optional& operator=(std::nullopt_t) noexcept {
        _object = T();
        return *this;
    }
    template<typename U>
    std::enable_if_t<std::is_same_v<std::decay_t<U>, T>, optimized_optional&>
    operator=(U&& obj) noexcept {
        _object = std::forward<U>(obj);
        return *this;
    }
    optimized_optional& operator=(const optimized_optional&) = default;
    optimized_optional& operator=(optimized_optional&&) = default;

    explicit operator bool() const noexcept {
        return bool(_object);
    }

    T* operator->() noexcept { return &_object; }
    const T* operator->() const noexcept { return &_object; }

    T& operator*() noexcept { return _object; }
    const T& operator*() const noexcept { return _object; }

    bool operator==(const optimized_optional& other) const {
        return _object == other._object;
    }
    bool operator!=(const optimized_optional& other) const {
        return _object != other._object;
    }
    friend std::ostream& operator<<(std::ostream& out, const optimized_optional& opt) {
        if (!opt) {
            return out << "null";
        }
        return out << *opt;
    }
};

}

template <typename T>
struct fmt::formatter<seastar::optimized_optional<T>> : fmt::formatter<string_view> {
    auto format(const seastar::optimized_optional<T>& opt, fmt::format_context& ctx) const {
        if (opt) {
            return fmt::format_to(ctx.out(), "{}", *opt);
        }
        return fmt::format_to(ctx.out(), "null");
    }
};
# 27 "/home/avi/scylla-maint/seastar/include/seastar/core/abort_source.hh" 2
# 37 "/home/avi/scylla-maint/seastar/include/seastar/core/abort_source.hh"
namespace bi = boost::intrusive;

namespace seastar {
# 48 "/home/avi/scylla-maint/seastar/include/seastar/core/abort_source.hh"
class abort_requested_exception : public std::exception {
public:
    virtual const char* what() const noexcept override {
        return "abort requested";
    }
};




class abort_source {
    using subscription_callback_type = noncopyable_function<void (const std::optional<std::exception_ptr>&) noexcept>;
    using naive_subscription_callback_type = noncopyable_function<void() noexcept>;

public:



    class subscription : public bi::list_base_hook<bi::link_mode<bi::auto_unlink>> {
        friend class abort_source;

        subscription_callback_type _target;

        explicit subscription(abort_source& as, subscription_callback_type target)
                : _target(std::move(target)) {
            as._subscriptions.push_back(*this);
        }

        struct naive_cb_tag {};
        explicit subscription(naive_cb_tag, abort_source& as, naive_subscription_callback_type naive_cb)
                : _target([cb = std::move(naive_cb)] (const std::optional<std::exception_ptr>&) noexcept { cb(); }) {
            as._subscriptions.push_back(*this);
        }

        void on_abort(const std::optional<std::exception_ptr>& ex) noexcept {
            _target(ex);
        }

    public:
        subscription() = default;

        subscription(subscription&& other) noexcept(std::is_nothrow_move_constructible_v<subscription_callback_type>)
                : _target(std::move(other._target)) {
            subscription_list_type::node_algorithms::swap_nodes(other.this_ptr(), this_ptr());
        }

        subscription& operator=(subscription&& other) noexcept(std::is_nothrow_move_assignable_v<subscription_callback_type>) {
            if (this != &other) {
                _target = std::move(other._target);
                unlink();
                subscription_list_type::node_algorithms::swap_nodes(other.this_ptr(), this_ptr());
            }
            return *this;
        }

        explicit operator bool() const noexcept {
            return is_linked();
        }
    };

private:
    using subscription_list_type = bi::list<subscription, bi::constant_time_size<false>>;
    subscription_list_type _subscriptions;
    std::exception_ptr _ex;

    void do_request_abort(std::optional<std::exception_ptr> ex) noexcept {
        if (_ex) {
            return;
        }
        _ex = ex.value_or(get_default_exception());
        (static_cast <bool> (_ex) ? void (0) : __assert_fail ("_ex", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        auto subs = std::move(_subscriptions);
        while (!subs.empty()) {
            subscription& s = subs.front();
            s.unlink();
            s.on_abort(ex);
        }
    }

public:
    abort_source() = default;
    virtual ~abort_source() = default;

    abort_source(abort_source&&) = default;
    abort_source& operator=(abort_source&&) = default;





    template <typename Func>
        requires (std::is_nothrow_invocable_r_v<void, Func, const std::optional<std::exception_ptr>&> ||
                  std::is_nothrow_invocable_r_v<void, Func>)
    [[nodiscard]]
    optimized_optional<subscription> subscribe(Func&& f) {
        if (abort_requested()) {
            return { };
        }
        if constexpr (std::is_invocable_v<Func, std::exception_ptr>) {
            return { subscription(*this, std::forward<Func>(f)) };
        } else {
            return { subscription(subscription::naive_cb_tag{}, *this, std::forward<Func>(f)) };
        }
    }




    void request_abort() noexcept {
        do_request_abort(std::nullopt);
    }




    void request_abort_ex(std::exception_ptr ex) noexcept {
        do_request_abort(std::make_optional(std::move(ex)));
    }




    template <typename Exception>
    void request_abort_ex(Exception&& e) noexcept {
        do_request_abort(std::make_optional(std::make_exception_ptr(std::forward<Exception>(e))));
    }


    bool abort_requested() const noexcept {
        return bool(_ex);
    }



    void check() const {
        if (abort_requested()) {
            std::rethrow_exception(_ex);
        }
    }


    const std::exception_ptr& abort_requested_exception_ptr() const noexcept {
        return _ex;
    }



    virtual std::exception_ptr get_default_exception() const noexcept {
        return make_exception_ptr(abort_requested_exception());
    }
};





}
# 25 "/home/avi/scylla-maint/seastar/include/seastar/core/abortable_fifo.hh" 2
# 35 "/home/avi/scylla-maint/seastar/include/seastar/core/abortable_fifo.hh"
namespace seastar {

namespace internal {

template <typename Aborter, typename T>
concept aborter = std::is_nothrow_invocable_r_v<void, Aborter, T&>;


template<typename... T>
struct noop_aborter {
    void operator()(T...) noexcept {};
};
# 57 "/home/avi/scylla-maint/seastar/include/seastar/core/abortable_fifo.hh"
template <typename T, typename OnAbort = noop_aborter<T>>
requires aborter<OnAbort, T>
class abortable_fifo {
private:
    struct entry {
        std::optional<T> payload;
        optimized_optional<abort_source::subscription> sub;
        entry(T&& payload_) : payload(std::move(payload_)) {}
        entry(const T& payload_) : payload(payload_) {}
        entry(T payload_, abortable_fifo& ef, abort_source& as)
                : payload(std::move(payload_))
                , sub(as.subscribe([this, &ef] () noexcept {
                    ef._on_abort(*payload);
                    payload = std::nullopt;
                    --ef._size;
                    ef.drop_expired_front();
                })) {}
        entry() = default;
        entry(entry&& x) = delete;
        entry(const entry& x) = delete;
    };





    std::unique_ptr<entry> _front;


    chunked_fifo<entry> _list;
    OnAbort _on_abort;
    size_t _size = 0;


    void drop_expired_front() noexcept {
        while (!_list.empty() && !_list.front().payload) {
            _list.pop_front();
        }
        if (_front && !_front->payload) {
            _front.reset();
        }
    }
public:
    abortable_fifo() noexcept = default;
    abortable_fifo(OnAbort on_abort) noexcept(std::is_nothrow_move_constructible_v<OnAbort>) : _on_abort(std::move(on_abort)) {}

    abortable_fifo(abortable_fifo&& o) noexcept
            : abortable_fifo(std::move(o._on_abort)) {

        (static_cast <bool> (o._size == 0) ? void (0) : __assert_fail ("o._size == 0", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
    }

    abortable_fifo& operator=(abortable_fifo&& o) noexcept {
        if (this != &o) {
            this->~abortable_fifo();
            new (this) abortable_fifo(std::move(o));
        }
        return *this;
    }






    bool empty() const noexcept {
        return _size == 0;
    }


    explicit operator bool() const noexcept {
        return !empty();
    }



    T& front() noexcept {
        if (_front) {
            return *_front->payload;
        }
        return *_list.front().payload;
    }



    const T& front() const noexcept {
        if (_front) {
            return *_front->payload;
        }
        return *_list.front().payload;
    }




    size_t size() const noexcept {
        return _size;
    }





    void reserve(size_t size) {
        return _list.reserve(size);
    }



    void push_back(const T& payload) {
        if (_size == 0) {
            _front = std::make_unique<entry>(payload);
        } else {
            _list.emplace_back(payload);
        }
        ++_size;
    }



    void push_back(T&& payload) {
        if (_size == 0) {
            _front = std::make_unique<entry>(std::move(payload));
        } else {
            _list.emplace_back(std::move(payload));
        }
        ++_size;
    }



    void push_back(T&& payload, abort_source& as) {
        if (as.abort_requested()) {
            _on_abort(payload);
            return;
        }
        if (_size == 0) {
            _front = std::make_unique<entry>(std::move(payload), *this, as);
        } else {
            _list.emplace_back(std::move(payload), *this, as);
        }
        ++_size;
    }


    template<typename... U>
    T& emplace_back(U&&... args) {
        if (_size == 0) {
            _front = std::make_unique<entry>();
            _front->payload.emplace(std::forward<U>(args)...);
            _size = 1;
            return *_front->payload;
        } else {
            _list.emplace_back();
            _list.back().payload.emplace(std::forward<U>(args)...);
            ++_size;
            return *_list.back().payload;
        }
    }






    void make_back_abortable(abort_source& as) {
        entry* e = _front.get();
        if (!_list.empty()) {
            e = &_list.back();
        }
        (static_cast <bool> (!e->sub) ? void (0) : __assert_fail ("!e->sub", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        auto aborter = [this, e] () noexcept {
            _on_abort(*e->payload);
            e->payload = std::nullopt;
            --_size;
            drop_expired_front();
        };
        if (as.abort_requested()) {
            aborter();
            return;
        }
        e->sub = as.subscribe(std::move(aborter));
    }



    void pop_front() noexcept {
        if (_front) {
            _front.reset();
        } else {
            _list.pop_front();
        }
        --_size;
        drop_expired_front();
    }
};

}
}
# 29 "/home/avi/scylla-maint/seastar/include/seastar/core/semaphore.hh" 2
# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/timed_out_error.hh" 1
# 31 "/home/avi/scylla-maint/seastar/include/seastar/core/timed_out_error.hh"
namespace seastar {


class timed_out_error : public std::exception {
public:
    virtual const char* what() const noexcept {
        return "timedout";
    }
};


struct default_timeout_exception_factory {
    static auto timeout() {
        return timed_out_error();
    }
};

}
# 30 "/home/avi/scylla-maint/seastar/include/seastar/core/semaphore.hh" 2
# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/abort_on_expiry.hh" 1
# 26 "/home/avi/scylla-maint/seastar/include/seastar/core/abort_on_expiry.hh"
# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/lowres_clock.hh" 1
# 25 "/home/avi/scylla-maint/seastar/include/seastar/core/lowres_clock.hh"
# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/cacheline.hh" 1
# 29 "/home/avi/scylla-maint/seastar/include/seastar/core/cacheline.hh"
namespace seastar {




constexpr size_t cache_line_size =

    64;
# 49 "/home/avi/scylla-maint/seastar/include/seastar/core/cacheline.hh"
}
# 26 "/home/avi/scylla-maint/seastar/include/seastar/core/lowres_clock.hh" 2






namespace seastar {







class lowres_clock;
class lowres_system_clock;
# 56 "/home/avi/scylla-maint/seastar/include/seastar/core/lowres_clock.hh"
class lowres_clock final {
public:
    using rep = std::chrono::steady_clock::rep;
    using period = std::chrono::steady_clock::period;
    using duration = std::chrono::steady_clock::duration;
    using time_point = std::chrono::time_point<lowres_clock, duration>;
    static constexpr bool is_steady = true;
private:




    inline static thread_local time_point _now;

public:



    static time_point now() noexcept {
        return _now;
    }

    static void update() noexcept;
};
# 90 "/home/avi/scylla-maint/seastar/include/seastar/core/lowres_clock.hh"
class lowres_system_clock final {
public:
    using rep = std::chrono::system_clock::rep;
    using period = std::chrono::system_clock::period;
    using duration = std::chrono::system_clock::duration;
    using time_point = std::chrono::time_point<lowres_system_clock, duration>;
    static constexpr bool is_steady = false;
private:




    inline static thread_local time_point _now;

    friend class lowres_clock;
public:



    static time_point now() noexcept {
        return _now;
    }

    static std::time_t to_time_t(time_point t) noexcept {
        return std::chrono::duration_cast<std::chrono::seconds>(t.time_since_epoch()).count();
    }

    static time_point from_time_t(std::time_t t) noexcept {
        return time_point(std::chrono::duration_cast<duration>(std::chrono::seconds(t)));
    }
};

extern template class timer<lowres_clock>;


}
# 27 "/home/avi/scylla-maint/seastar/include/seastar/core/abort_on_expiry.hh" 2


namespace seastar {







template<typename Clock = lowres_clock>
class abort_on_expiry {
    timer<Clock> _tr;
    seastar::abort_source _as;
public:
    using clock = Clock;
    using time_point = typename Clock::time_point;



    abort_on_expiry(time_point timeout) : _tr([this] {
        _as.request_abort();
    }) {
        _tr.arm(timeout);
    }
    abort_on_expiry(abort_on_expiry&&) = delete;


    seastar::abort_source& abort_source() {
        return _as;
    }
};



}
# 31 "/home/avi/scylla-maint/seastar/include/seastar/core/semaphore.hh" 2


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 1 3
# 42 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 3


# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 45 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 2 3
# 34 "/home/avi/scylla-maint/seastar/include/seastar/core/semaphore.hh" 2






namespace seastar {

namespace internal {

template <typename T>
class has_broken {
    template <typename U> constexpr static bool check(decltype(&U::broken)) { return true; }
    template <typename U> constexpr static bool check(...) { return false; }

public:
    constexpr static bool value = check<T>(nullptr);
};

template <typename T>
class has_aborted {
    template <typename U> constexpr static bool check(decltype(&U::aborted)) { return true; }
    template <typename U> constexpr static bool check(...) { return false; }

public:
    constexpr static bool value = check<T>(nullptr);
};
}






class broken_semaphore : public std::exception {
public:

    virtual const char* what() const noexcept;
};





class semaphore_timed_out : public timed_out_error {
public:

    virtual const char* what() const noexcept;
};





class semaphore_aborted : public abort_requested_exception {
public:

    virtual const char* what() const noexcept;
};





struct semaphore_default_exception_factory {
    static semaphore_timed_out timeout() noexcept;
    static broken_semaphore broken() noexcept;
    static semaphore_aborted aborted() noexcept;
};

class named_semaphore_timed_out : public semaphore_timed_out {
    sstring _msg;
public:
    named_semaphore_timed_out(std::string_view msg) noexcept;
    virtual const char* what() const noexcept;
};

class broken_named_semaphore : public broken_semaphore {
    sstring _msg;
public:
    broken_named_semaphore(std::string_view msg) noexcept;
    virtual const char* what() const noexcept;
};

class named_semaphore_aborted : public semaphore_aborted {
    sstring _msg;
public:
    named_semaphore_aborted(std::string_view msg) noexcept;
    virtual const char* what() const noexcept;
};



struct named_semaphore_exception_factory {
    sstring name;
    named_semaphore_timed_out timeout() const noexcept;
    broken_named_semaphore broken() const noexcept;
    named_semaphore_aborted aborted() const noexcept;
};
# 153 "/home/avi/scylla-maint/seastar/include/seastar/core/semaphore.hh"
template<typename ExceptionFactory, typename Clock = typename timer<>::clock>
class basic_semaphore : private ExceptionFactory {
public:
    using duration = typename timer<Clock>::duration;
    using clock = typename timer<Clock>::clock;
    using time_point = typename timer<Clock>::time_point;
    using exception_factory = ExceptionFactory;
private:
    ssize_t _count;
    std::exception_ptr _ex;
    struct entry {
        promise<> pr;
        size_t nr;
        std::optional<abort_on_expiry<clock>> timer;
        entry(promise<>&& pr_, size_t nr_) noexcept : pr(std::move(pr_)), nr(nr_) {}
    };
    struct expiry_handler {
        basic_semaphore& sem;
        void operator()(entry& e) noexcept {
            if (e.timer) {
                try {
                    e.pr.set_exception(sem.timeout());
                } catch (...) {
                    e.pr.set_exception(semaphore_timed_out());
                }
            } else if (sem._ex) {
                e.pr.set_exception(sem._ex);
            } else {
                if constexpr (internal::has_aborted<exception_factory>::value) {
                    try {
                        e.pr.set_exception(static_cast<exception_factory>(sem).aborted());
                    } catch (...) {
                        e.pr.set_exception(semaphore_aborted());
                    }
                } else {
                    e.pr.set_exception(semaphore_aborted());
                }
            }
        }
    };
    internal::abortable_fifo<entry, expiry_handler> _wait_list;
# 216 "/home/avi/scylla-maint/seastar/include/seastar/core/semaphore.hh"
    struct used_flag {
        void use() noexcept {}
    };


    [[no_unique_address]] used_flag _used;

    bool has_available_units(size_t nr) const noexcept {
        return _count >= 0 && (static_cast<size_t>(_count) >= nr);
    }
    bool may_proceed(size_t nr) const noexcept {
        return has_available_units(nr) && _wait_list.empty();
    }
public:

    static constexpr size_t max_counter() noexcept {
        return std::numeric_limits<decltype(_count)>::max();
    }






    basic_semaphore(size_t count) noexcept(std::is_nothrow_default_constructible_v<exception_factory>)
        : exception_factory()
        , _count(count),
        _wait_list(expiry_handler{*this})
    {}
    basic_semaphore(size_t count, exception_factory&& factory) noexcept(std::is_nothrow_move_constructible_v<exception_factory>)
        : exception_factory(std::move(factory))
        , _count(count)
        , _wait_list(expiry_handler{*this})
    {
        static_assert(std::is_nothrow_move_constructible_v<expiry_handler>);
    }






    basic_semaphore(basic_semaphore&& other) noexcept(std::is_nothrow_move_constructible_v<exception_factory>)
        : exception_factory(other)
        , _count(other._count)
        , _ex(std::exchange(other._ex, std::exception_ptr()))
        , _wait_list(expiry_handler{*this})
        , _used(std::move(other._used))
    {

        (static_cast <bool> (other._wait_list.empty()) ? void (0) : __assert_fail ("other._wait_list.empty()", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
    }
# 276 "/home/avi/scylla-maint/seastar/include/seastar/core/semaphore.hh"
    basic_semaphore& operator=(basic_semaphore&& other) noexcept(std::is_nothrow_move_assignable_v<exception_factory>) {

        (static_cast <bool> (_wait_list.empty()) ? void (0) : __assert_fail ("_wait_list.empty()", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        (static_cast <bool> (other._wait_list.empty()) ? void (0) : __assert_fail ("other._wait_list.empty()", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        if (this != &other) {
            exception_factory::operator=(other);
            _count = other._count;
            _ex = std::exchange(other._ex, std::exception_ptr());
            _used = std::move(other._used);
        }
        return *this;
    }
# 299 "/home/avi/scylla-maint/seastar/include/seastar/core/semaphore.hh"
    future<> wait(size_t nr = 1) noexcept {
        return wait(time_point::max(), nr);
    }
# 315 "/home/avi/scylla-maint/seastar/include/seastar/core/semaphore.hh"
    future<> wait(time_point timeout, size_t nr = 1) noexcept {
        _used.use();
        if (may_proceed(nr)) {
            _count -= nr;
            return make_ready_future<>();
        }
        if (_ex) {
            return make_exception_future(_ex);
        }
        try {
            entry& e = _wait_list.emplace_back(promise<>(), nr);
            auto f = e.pr.get_future();
            if (timeout != time_point::max()) {
                e.timer.emplace(timeout);
                abort_source& as = e.timer->abort_source();
                _wait_list.make_back_abortable(as);
            }
            return f;
        } catch (...) {
            return make_exception_future(std::current_exception());
        }
    }
# 351 "/home/avi/scylla-maint/seastar/include/seastar/core/semaphore.hh"
    future<> wait(abort_source& as, size_t nr = 1) noexcept {
        _used.use();
        if (may_proceed(nr)) {
            _count -= nr;
            return make_ready_future<>();
        }
        if (_ex) {
            return make_exception_future(_ex);
        }
        try {
            entry& e = _wait_list.emplace_back(promise<>(), nr);

            auto f = e.pr.get_future();
            _wait_list.make_back_abortable(as);
            return f;
        } catch (...) {
            return make_exception_future(std::current_exception());
        }
    }
# 384 "/home/avi/scylla-maint/seastar/include/seastar/core/semaphore.hh"
    future<> wait(duration timeout, size_t nr = 1) noexcept {
        return wait(clock::now() + timeout, nr);
    }
# 396 "/home/avi/scylla-maint/seastar/include/seastar/core/semaphore.hh"
    void signal(size_t nr = 1) noexcept {
        if (_ex) {
            return;
        }
        _count += nr;
        while (!_wait_list.empty() && has_available_units(_wait_list.front().nr)) {
            auto& x = _wait_list.front();
            _count -= x.nr;
            x.pr.set_value();
            _wait_list.pop_front();
        }
    }
# 416 "/home/avi/scylla-maint/seastar/include/seastar/core/semaphore.hh"
    void consume(size_t nr = 1) noexcept {
        _used.use();
        if (_ex) {
            return;
        }
        _count -= nr;
    }
# 434 "/home/avi/scylla-maint/seastar/include/seastar/core/semaphore.hh"
    bool try_wait(size_t nr = 1) noexcept {
        _used.use();
        if (may_proceed(nr)) {
            _count -= nr;
            return true;
        } else {
            return false;
        }
    }



    size_t current() const noexcept { return std::max(_count, ssize_t(0)); }





    ssize_t available_units() const noexcept { return _count; }


    size_t waiters() const noexcept { return _wait_list.size(); }




    void broken() noexcept {
        std::exception_ptr ep;
        if constexpr (internal::has_broken<exception_factory>::value) {
            try {
                ep = std::make_exception_ptr(exception_factory::broken());
            } catch (...) {
                ep = std::make_exception_ptr(broken_semaphore());
            }
        } else {
            ep = std::make_exception_ptr(broken_semaphore());
        }
        broken(std::move(ep));
    }




    template <typename Exception>
    void broken(const Exception& ex) noexcept {
        broken(std::make_exception_ptr(ex));
    }




    void broken(std::exception_ptr ex) noexcept;


    void ensure_space_for_waiters(size_t n) {
        _wait_list.reserve(n);
    }
};


template<typename ExceptionFactory, typename Clock>
inline
void
basic_semaphore<ExceptionFactory, Clock>::broken(std::exception_ptr xp) noexcept {
    static_assert(std::is_nothrow_copy_constructible_v<std::exception_ptr>);
    _ex = xp;
    _count = 0;
    while (!_wait_list.empty()) {
        auto& x = _wait_list.front();
        x.pr.set_exception(xp);
        _wait_list.pop_front();
    }
}



template<typename ExceptionFactory = semaphore_default_exception_factory, typename Clock = typename timer<>::clock>
class semaphore_units {
    basic_semaphore<ExceptionFactory, Clock>* _sem;
    size_t _n;

    semaphore_units(basic_semaphore<ExceptionFactory, Clock>* sem, size_t n) noexcept : _sem(sem), _n(n) {}
public:
    semaphore_units() noexcept : semaphore_units(nullptr, 0) {}
    semaphore_units(basic_semaphore<ExceptionFactory, Clock>& sem, size_t n) noexcept : semaphore_units(&sem, n) {}
    semaphore_units(semaphore_units&& o) noexcept : _sem(o._sem), _n(std::exchange(o._n, 0)) {
    }
    semaphore_units& operator=(semaphore_units&& o) noexcept {
        if (this != &o) {
            return_all();
            _sem = o._sem;
            _n = std::exchange(o._n, 0);
        }
        return *this;
    }
    semaphore_units(const semaphore_units&) = delete;
    ~semaphore_units() noexcept {
        return_all();
    }







    size_t return_units(size_t units) {
        if (units > _n) {
            throw std::invalid_argument("Cannot take more units than those protected by the semaphore");
        }
        _n -= units;
        _sem->signal(units);
        return _n;
    }

    void return_all() noexcept {
        if (_n) {
            _sem->signal(_n);
            _n = 0;
        }
    }



    size_t release() noexcept {
        return std::exchange(_n, 0);
    }
# 569 "/home/avi/scylla-maint/seastar/include/seastar/core/semaphore.hh"
    semaphore_units split(size_t units) {
        if (units > _n) {
            throw std::invalid_argument("Cannot take more units than those protected by the semaphore");
        }
        _n -= units;
        return semaphore_units(_sem, units);
    }





    void adopt(semaphore_units&& other) noexcept {
        (static_cast <bool> (other._sem == _sem) ? void (0) : __assert_fail ("other._sem == _sem", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        _n += other.release();
    }


    size_t count() const noexcept {
        return _n;
    }


    explicit operator bool() const noexcept {
        return _n != 0;
    }
};
# 614 "/home/avi/scylla-maint/seastar/include/seastar/core/semaphore.hh"
template<typename ExceptionFactory, typename Clock = typename timer<>::clock>
future<semaphore_units<ExceptionFactory, Clock>>
get_units(basic_semaphore<ExceptionFactory, Clock>& sem, size_t units) noexcept {
    return sem.wait(units).then([&sem, units] {
        return semaphore_units<ExceptionFactory, Clock>{ sem, units };
    });
}
# 637 "/home/avi/scylla-maint/seastar/include/seastar/core/semaphore.hh"
template<typename ExceptionFactory, typename Clock = typename timer<>::clock>
future<semaphore_units<ExceptionFactory, Clock>>
get_units(basic_semaphore<ExceptionFactory, Clock>& sem, size_t units, typename basic_semaphore<ExceptionFactory, Clock>::time_point timeout) noexcept {
    return sem.wait(timeout, units).then([&sem, units] {
        return semaphore_units<ExceptionFactory, Clock>{ sem, units };
    });
}
# 661 "/home/avi/scylla-maint/seastar/include/seastar/core/semaphore.hh"
template<typename ExceptionFactory, typename Clock>
future<semaphore_units<ExceptionFactory, Clock>>
get_units(basic_semaphore<ExceptionFactory, Clock>& sem, size_t units, typename basic_semaphore<ExceptionFactory, Clock>::duration timeout) noexcept {
    return sem.wait(timeout, units).then([&sem, units] {
        return semaphore_units<ExceptionFactory, Clock>{ sem, units };
    });
}
# 685 "/home/avi/scylla-maint/seastar/include/seastar/core/semaphore.hh"
template<typename ExceptionFactory, typename Clock>
future<semaphore_units<ExceptionFactory, Clock>>
get_units(basic_semaphore<ExceptionFactory, Clock>& sem, size_t units, abort_source& as) noexcept {
    return sem.wait(as, units).then([&sem, units] {
        return semaphore_units<ExceptionFactory, Clock>{ sem, units };
    });
}
# 710 "/home/avi/scylla-maint/seastar/include/seastar/core/semaphore.hh"
template<typename ExceptionFactory, typename Clock = typename timer<>::clock>
std::optional<semaphore_units<ExceptionFactory, Clock>>
try_get_units(basic_semaphore<ExceptionFactory, Clock>& sem, size_t units) noexcept {
    if (!sem.try_wait(units)) {
        return std::nullopt;
    }
    return std::make_optional<semaphore_units<ExceptionFactory, Clock>>(sem, units);
}
# 731 "/home/avi/scylla-maint/seastar/include/seastar/core/semaphore.hh"
template<typename ExceptionFactory, typename Clock = typename timer<>::clock>
semaphore_units<ExceptionFactory, Clock>
consume_units(basic_semaphore<ExceptionFactory, Clock>& sem, size_t units) noexcept {
    sem.consume(units);
    return semaphore_units<ExceptionFactory, Clock>{ sem, units };
}
# 759 "/home/avi/scylla-maint/seastar/include/seastar/core/semaphore.hh"
template <typename ExceptionFactory, typename Func, typename Clock = typename timer<>::clock>
inline
futurize_t<std::invoke_result_t<Func>>
with_semaphore(basic_semaphore<ExceptionFactory, Clock>& sem, size_t units, Func&& func) noexcept {
    return get_units(sem, units).then([func = std::forward<Func>(func)] (auto units) mutable {
        return futurize_invoke(std::forward<Func>(func)).finally([units = std::move(units)] {});
    });
}
# 793 "/home/avi/scylla-maint/seastar/include/seastar/core/semaphore.hh"
template <typename ExceptionFactory, typename Clock, typename Func>
inline
futurize_t<std::invoke_result_t<Func>>
with_semaphore(basic_semaphore<ExceptionFactory, Clock>& sem, size_t units, typename basic_semaphore<ExceptionFactory, Clock>::duration timeout, Func&& func) noexcept {
    return get_units(sem, units, timeout).then([func = std::forward<Func>(func)] (auto units) mutable {
        return futurize_invoke(std::forward<Func>(func)).finally([units = std::move(units)] {});
    });
}



using semaphore = basic_semaphore<semaphore_default_exception_factory>;
using named_semaphore = basic_semaphore<named_semaphore_exception_factory>;





}
# 39 "/home/avi/scylla-maint/seastar/include/seastar/core/loop.hh" 2

namespace seastar {
# 51 "/home/avi/scylla-maint/seastar/include/seastar/core/loop.hh"
struct stop_iteration_tag { };
using stop_iteration = bool_class<stop_iteration_tag>;

namespace internal {

template <typename AsyncAction>
class repeater final : public continuation_base<stop_iteration> {
    promise<> _promise;
    AsyncAction _action;
public:
    explicit repeater(AsyncAction&& action) : _action(std::move(action)) {}
    future<> get_future() { return _promise.get_future(); }
    task* waiting_task() noexcept override { return _promise.waiting_task(); }
    virtual void run_and_dispose() noexcept override {
        if (_state.failed()) {
            _promise.set_exception(std::move(_state).get_exception());
            delete this;
            return;
        } else {
            if (_state.get() == stop_iteration::yes) {
                _promise.set_value();
                delete this;
                return;
            }
            _state = {};
        }
        try {
            do {
                auto f = futurize_invoke(_action);
                if (!f.available()) {
                    internal::set_callback(std::move(f), this);
                    return;
                }
                if (f.get() == stop_iteration::yes) {
                    _promise.set_value();
                    delete this;
                    return;
                }
            } while (!need_preempt());
        } catch (...) {
            _promise.set_exception(std::current_exception());
            delete this;
            return;
        }
        _state.set(stop_iteration::no);
        schedule(this);
    }
};

}



template<typename AsyncAction>
future<> repeat(const AsyncAction& action) noexcept = delete;
template<typename AsyncAction>
future<> repeat(AsyncAction& action) noexcept = delete;
# 118 "/home/avi/scylla-maint/seastar/include/seastar/core/loop.hh"
template<typename AsyncAction>
requires std::is_invocable_r_v<stop_iteration, AsyncAction> || std::is_invocable_r_v<future<stop_iteration>, AsyncAction>
inline
future<> repeat(AsyncAction&& action) noexcept {
    using futurator = futurize<std::invoke_result_t<AsyncAction>>;
    static_assert(std::is_same_v<future<stop_iteration>, typename futurator::type>, "bad AsyncAction signature");
    for (;;) {

        auto f = futurator::invoke(action);

        if (!f.available() || f.failed() || need_preempt()) {
            return [&] () noexcept {
                memory::scoped_critical_alloc_section _;
                auto repeater = new internal::repeater<AsyncAction>(std::move(action));
                auto ret = repeater->get_future();
                internal::set_callback(std::move(f), repeater);
                return ret;
            }();
        }

        if (f.get() == stop_iteration::yes) {
            return make_ready_future<>();
        }
    }
}



template <typename T>
struct repeat_until_value_type_helper;


template <typename T>
struct repeat_until_value_type_helper<future<std::optional<T>>> {

    using value_type = T;

    using optional_type = std::optional<T>;

    using future_type = future<value_type>;
};


template <typename AsyncAction>
using repeat_until_value_return_type
        = typename repeat_until_value_type_helper<typename futurize<std::invoke_result_t<AsyncAction>>::type>::future_type;



namespace internal {

template <typename AsyncAction, typename T>
class repeat_until_value_state final : public continuation_base<std::optional<T>> {
    promise<T> _promise;
    AsyncAction _action;
public:
    explicit repeat_until_value_state(AsyncAction action) : _action(std::move(action)) {}
    repeat_until_value_state(std::optional<T> st, AsyncAction action) : repeat_until_value_state(std::move(action)) {
        this->_state.set(std::move(st));
    }
    future<T> get_future() { return _promise.get_future(); }
    task* waiting_task() noexcept override { return _promise.waiting_task(); }
    virtual void run_and_dispose() noexcept override {
        if (this->_state.failed()) {
            _promise.set_exception(std::move(this->_state).get_exception());
            delete this;
            return;
        } else {
            auto v = std::move(this->_state).get();
            if (v) {
                _promise.set_value(std::move(*v));
                delete this;
                return;
            }
            this->_state = {};
        }
        try {
            do {
                auto f = futurize_invoke(_action);
                if (!f.available()) {
                    internal::set_callback(std::move(f), this);
                    return;
                }
                auto ret = f.get();
                if (ret) {
                    _promise.set_value(std::move(*ret));
                    delete this;
                    return;
                }
            } while (!need_preempt());
        } catch (...) {
            _promise.set_exception(std::current_exception());
            delete this;
            return;
        }
        this->_state.set(std::nullopt);
        schedule(this);
    }
};

}
# 231 "/home/avi/scylla-maint/seastar/include/seastar/core/loop.hh"
template<typename AsyncAction>
requires requires (AsyncAction aa) {
    bool(futurize_invoke(aa).get());
    futurize_invoke(aa).get().value();
}
repeat_until_value_return_type<AsyncAction>
repeat_until_value(AsyncAction action) noexcept {
    using futurator = futurize<std::invoke_result_t<AsyncAction>>;
    using type_helper = repeat_until_value_type_helper<typename futurator::type>;

    using value_type = typename type_helper::value_type;
    using optional_type = typename type_helper::optional_type;
    do {
        auto f = futurator::invoke(action);

        if (!f.available()) {
          return [&] () noexcept {
            memory::scoped_critical_alloc_section _;
            auto state = new internal::repeat_until_value_state<AsyncAction, value_type>(std::move(action));
            auto ret = state->get_future();
            internal::set_callback(std::move(f), state);
            return ret;
          }();
        }

        if (f.failed()) {
            return make_exception_future<value_type>(f.get_exception());
        }

        optional_type&& optional = std::move(f).get();
        if (optional) {
            return make_ready_future<value_type>(std::move(optional.value()));
        }
    } while (!need_preempt());

    try {
        auto state = new internal::repeat_until_value_state<AsyncAction, value_type>(std::nullopt, std::move(action));
        auto f = state->get_future();
        schedule(state);
        return f;
    } catch (...) {
        return make_exception_future<value_type>(std::current_exception());
    }
}

namespace internal {

template <typename StopCondition, typename AsyncAction>
class do_until_state final : public continuation_base<> {
    promise<> _promise;
    StopCondition _stop;
    AsyncAction _action;
public:
    explicit do_until_state(StopCondition stop, AsyncAction action) : _stop(std::move(stop)), _action(std::move(action)) {}
    future<> get_future() { return _promise.get_future(); }
    task* waiting_task() noexcept override { return _promise.waiting_task(); }
    virtual void run_and_dispose() noexcept override {
        if (_state.available()) {
            if (_state.failed()) {
                _promise.set_urgent_state(std::move(_state));
                delete this;
                return;
            }
            _state = {};
        }
        try {
            do {
                if (_stop()) {
                    _promise.set_value();
                    delete this;
                    return;
                }
                auto f = _action();
                if (!f.available()) {
                    internal::set_callback(std::move(f), this);
                    return;
                }
                if (f.failed()) {
                    f.forward_to(std::move(_promise));
                    delete this;
                    return;
                }
            } while (!need_preempt());
        } catch (...) {
            _promise.set_exception(std::current_exception());
            delete this;
            return;
        }
        schedule(this);
    }
};

}
# 336 "/home/avi/scylla-maint/seastar/include/seastar/core/loop.hh"
template<typename AsyncAction, typename StopCondition>
requires std::is_invocable_r_v<bool, StopCondition> && std::is_invocable_r_v<future<>, AsyncAction>
inline
future<> do_until(StopCondition stop_cond, AsyncAction action) noexcept {
    using namespace internal;
    for (;;) {
      try {
        if (stop_cond()) {
            return make_ready_future<>();
        }
      } catch (...) {
        return current_exception_as_future();
      }
        auto f = futurize_invoke(action);
        if (f.failed()) {
            return f;
        }
        if (!f.available() || need_preempt()) {
            return [&] () noexcept {
                memory::scoped_critical_alloc_section _;
                auto task = new do_until_state<StopCondition, AsyncAction>(std::move(stop_cond), std::move(action));
                auto ret = task->get_future();
                internal::set_callback(std::move(f), task);
                return ret;
            }();
        }
    }
}
# 372 "/home/avi/scylla-maint/seastar/include/seastar/core/loop.hh"
template<typename AsyncAction>
requires std::is_invocable_r_v<future<>, AsyncAction>
inline
future<> keep_doing(AsyncAction action) noexcept {
    return repeat([action = std::move(action)] () mutable {
        return action().then([] {
            return stop_iteration::no;
        });
    });
}

namespace internal {
template <typename Iterator, typename AsyncAction>
class do_for_each_state final : public continuation_base<> {
    Iterator _begin;
    Iterator _end;
    AsyncAction _action;
    promise<> _pr;

public:
    do_for_each_state(Iterator begin, Iterator end, AsyncAction action, future<>&& first_unavailable)
        : _begin(std::move(begin)), _end(std::move(end)), _action(std::move(action)) {
        internal::set_callback(std::move(first_unavailable), this);
    }
    virtual void run_and_dispose() noexcept override {
        std::unique_ptr<do_for_each_state> zis(this);
        if (_state.failed()) {
            _pr.set_urgent_state(std::move(_state));
            return;
        }
        while (_begin != _end) {
            auto f = futurize_invoke(_action, *_begin++);
            if (f.failed()) {
                f.forward_to(std::move(_pr));
                return;
            }
            if (!f.available() || need_preempt()) {
                _state = {};
                internal::set_callback(std::move(f), this);
                zis.release();
                return;
            }
        }
        _pr.set_value();
    }
    task* waiting_task() noexcept override {
        return _pr.waiting_task();
    }
    future<> get_future() {
        return _pr.get_future();
    }
};

template<typename Iterator, typename AsyncAction>
inline
future<> do_for_each_impl(Iterator begin, Iterator end, AsyncAction action) {
    while (begin != end) {
        auto f = futurize_invoke(action, *begin++);
        if (f.failed()) {
            return f;
        }
        if (!f.available() || need_preempt()) {
            auto* s = new internal::do_for_each_state<Iterator, AsyncAction>{
                std::move(begin), std::move(end), std::move(action), std::move(f)};
            return s->get_future();
        }
    }
    return make_ready_future<>();
}
}
# 457 "/home/avi/scylla-maint/seastar/include/seastar/core/loop.hh"
template<typename Iterator, typename AsyncAction>
requires requires (Iterator i, AsyncAction aa) {
    { futurize_invoke(aa, *i) } -> std::same_as<future<>>;
}
inline
future<> do_for_each(Iterator begin, Iterator end, AsyncAction action) noexcept {
    try {
        return internal::do_for_each_impl(std::move(begin), std::move(end), std::move(action));
    } catch (...) {
        return current_exception_as_future();
    }
}
# 481 "/home/avi/scylla-maint/seastar/include/seastar/core/loop.hh"
template<typename Container, typename AsyncAction>
requires requires (Container c, AsyncAction aa) {
    { futurize_invoke(aa, *std::begin(c)) } -> std::same_as<future<>>;
    std::end(c);
}
inline
future<> do_for_each(Container& c, AsyncAction action) noexcept {
    try {
        return internal::do_for_each_impl(std::begin(c), std::end(c), std::move(action));
    } catch (...) {
        return current_exception_as_future();
    }
}

namespace internal {

template <typename T, typename = void>
struct has_iterator_category : std::false_type {};

template <typename T>
struct has_iterator_category<T, std::void_t<typename std::iterator_traits<T>::iterator_category >> : std::true_type {};

template <typename Iterator, typename Sentinel, typename IteratorCategory>
inline
size_t
iterator_range_estimate_vector_capacity(Iterator begin, Sentinel end, IteratorCategory) {

    if constexpr (std::is_base_of_v<std::forward_iterator_tag, IteratorCategory>) {
        return std::distance(begin, end);
    }


    return 0;
}

}



class parallel_for_each_state final : private continuation_base<> {
    std::vector<future<>> _incomplete;
    promise<> _result;
    std::exception_ptr _ex;
private:



    void wait_for_one() noexcept;
    virtual void run_and_dispose() noexcept override;
    task* waiting_task() noexcept override { return _result.waiting_task(); }
public:
    parallel_for_each_state(size_t n);
    void add_future(future<>&& f);
    future<> get_future();
};
# 558 "/home/avi/scylla-maint/seastar/include/seastar/core/loop.hh"
template <typename Iterator, typename Sentinel, typename Func>
requires (requires (Func f, Iterator i) { { f(*i) } -> std::same_as<future<>>; { i++ }; } && (std::same_as<Sentinel, Iterator> || std::sentinel_for<Sentinel, Iterator>))



inline
future<>
parallel_for_each(Iterator begin, Sentinel end, Func&& func) noexcept {
    parallel_for_each_state* s = nullptr;




    while (begin != end) {
        auto f = futurize_invoke(std::forward<Func>(func), *begin);
        ++begin;
        memory::scoped_critical_alloc_section _;
        if (!f.available() || f.failed()) {
            if (!s) {
                using itraits = std::iterator_traits<Iterator>;
                size_t n{0U};
                if constexpr (internal::has_iterator_category<Iterator>::value) {


                    n = (internal::iterator_range_estimate_vector_capacity(begin, end, typename itraits::iterator_category{}) + 1);
                }
                s = new parallel_for_each_state(n);
            }
            s->add_future(std::move(f));
        }
    }


    if (s) {


        return s->get_future();
    }
    return make_ready_future<>();
}
# 619 "/home/avi/scylla-maint/seastar/include/seastar/core/loop.hh"
namespace internal {

template <typename Range, typename Func>
inline
future<>
parallel_for_each_impl(Range&& range, Func&& func) {
    return parallel_for_each(std::begin(range), std::end(range),
            std::forward<Func>(func));
}

}

template <typename Range, typename Func>
requires requires (Func f, Range r) {
    { f(*std::begin(r)) } -> std::same_as<future<>>;
    std::end(r);
}
inline
future<>
parallel_for_each(Range&& range, Func&& func) noexcept {
    auto impl = internal::parallel_for_each_impl<Range, Func>;
    return futurize_invoke(impl, std::forward<Range>(range), std::forward<Func>(func));
}
# 664 "/home/avi/scylla-maint/seastar/include/seastar/core/loop.hh"
template <typename Iterator, typename Sentinel, typename Func>
requires (requires (Func f, Iterator i) { { f(*i) } -> std::same_as<future<>>; { ++i }; } && (std::same_as<Sentinel, Iterator> || std::sentinel_for<Sentinel, Iterator>) )



inline
future<>
max_concurrent_for_each(Iterator begin, Sentinel end, size_t max_concurrent, Func&& func) noexcept {
    struct state {
        Iterator begin;
        Sentinel end;
        Func func;
        size_t max_concurrent;
        semaphore sem;
        std::exception_ptr err;

        state(Iterator begin_, Sentinel end_, size_t max_concurrent_, Func func_)
            : begin(std::move(begin_))
            , end(std::move(end_))
            , func(std::move(func_))
            , max_concurrent(max_concurrent_)
            , sem(max_concurrent_)
            , err()
        { }
    };

    (static_cast <bool> (max_concurrent > 0) ? void (0) : __assert_fail ("max_concurrent > 0", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));

    try {
        return do_with(state(std::move(begin), std::move(end), max_concurrent, std::forward<Func>(func)), [] (state& s) {
            return do_until([&s] { return s.begin == s.end; }, [&s] {
                return s.sem.wait().then([&s] () mutable noexcept {


                    (void)futurize_invoke(s.func, *s.begin).then_wrapped([&s] (future<> fut) {
                        if (fut.failed()) {
                            auto e = fut.get_exception();;
                            if (!s.err) {
                                s.err = std::move(e);
                            }
                        }
                        s.sem.signal();
                    });
                    ++s.begin;
                });
            }).then([&s] {


                return s.sem.wait(s.max_concurrent);
            }).then([&s] {
                if (!s.err) {
                    return make_ready_future<>();
                }
                return seastar::make_exception_future<>(std::move(s.err));
            });
        });
    } catch (...) {
        return current_exception_as_future();
    }
}
# 745 "/home/avi/scylla-maint/seastar/include/seastar/core/loop.hh"
template <typename Range, typename Func>
requires requires (Func f, Range r) {
    { f(*std::begin(r)) } -> std::same_as<future<>>;
    std::end(r);
}
inline
future<>
max_concurrent_for_each(Range&& range, size_t max_concurrent, Func&& func) noexcept {
    try {
        return max_concurrent_for_each(std::begin(range), std::end(range), max_concurrent, std::forward<Func>(func));
    } catch (...) {
        return current_exception_as_future();
    }
}





}
# 29 "/home/avi/scylla-maint/seastar/include/seastar/core/iostream-impl.hh" 2

# 1 "/home/avi/scylla-maint/seastar/include/seastar/util/variant_utils.hh" 1
# 26 "/home/avi/scylla-maint/seastar/include/seastar/util/variant_utils.hh"
namespace seastar {


namespace internal {

template<typename... Args>
struct variant_visitor : Args... {
    variant_visitor(Args&&... a) : Args(std::move(a))... {}
    using Args::operator()...;
};

template<typename... Args> variant_visitor(Args&&...) -> variant_visitor<Args...>;

}
# 51 "/home/avi/scylla-maint/seastar/include/seastar/util/variant_utils.hh"
template <typename... Args>
auto make_visitor(Args&&... args)
{
    return internal::variant_visitor<Args...>(std::forward<Args>(args)...);
}
# 67 "/home/avi/scylla-maint/seastar/include/seastar/util/variant_utils.hh"
template <typename Variant, typename... Args>
inline auto visit(Variant&& variant, Args&&... args)
{
    static_assert(sizeof...(Args) > 0, "At least one lambda must be provided for visitation");
    return std::visit(
        make_visitor(std::forward<Args>(args)...),
        variant);
}

namespace internal {
template<typename... Args>
struct castable_variant {
    std::variant<Args...> var;

    template<typename... SuperArgs>
    operator std::variant<SuperArgs...>() && {
        return std::visit([] (auto&& x) {
            return std::variant<SuperArgs...>(std::move(x));
        }, var);
    }
};
}

template<typename... Args>
internal::castable_variant<Args...> variant_cast(std::variant<Args...>&& var) {
    return {std::move(var)};
}

template<typename... Args>
internal::castable_variant<Args...> variant_cast(const std::variant<Args...>& var) {
    return {var};
}



}
# 31 "/home/avi/scylla-maint/seastar/include/seastar/core/iostream-impl.hh" 2

namespace seastar {

inline future<temporary_buffer<char>> data_source_impl::skip(uint64_t n)
{
    return do_with(uint64_t(n), [this] (uint64_t& n) {
        return repeat_until_value([&] {
            return get().then([&] (temporary_buffer<char> buffer) -> std::optional<temporary_buffer<char>> {
                if (buffer.empty()) {
                    return buffer;
                }
                if (buffer.size() >= n) {
                    buffer.trim_front(n);
                    return buffer;
                }
                n -= buffer.size();
                return { };
            });
        });
    });
}

template<typename CharType>
inline
future<> output_stream<CharType>::write(const char_type* buf) noexcept {
    return write(buf, strlen(buf));
}

template<typename CharType>
template<typename StringChar, typename SizeType, SizeType MaxSize, bool NulTerminate>
inline
future<> output_stream<CharType>::write(const basic_sstring<StringChar, SizeType, MaxSize, NulTerminate>& s) noexcept {
    return write(reinterpret_cast<const CharType *>(s.c_str()), s.size());
}

template<typename CharType>
inline
future<> output_stream<CharType>::write(const std::basic_string<CharType>& s) noexcept {
    return write(s.c_str(), s.size());
}

template<typename CharType>
future<> output_stream<CharType>::write(scattered_message<CharType> msg) noexcept {
    return write(std::move(msg).release());
}

template<typename CharType>
future<>
output_stream<CharType>::zero_copy_put(net::packet p) noexcept {

    _flush = false;
    if (_flushing) {

        return _in_batch.value().get_future().then([this, p = std::move(p)] () mutable {
            return _fd.put(std::move(p));
        });
    } else {
        return _fd.put(std::move(p));
    }
}


template <typename CharType>
future<>
output_stream<CharType>::zero_copy_split_and_put(net::packet p) noexcept {
    return repeat([this, p = std::move(p)] () mutable {
        if (p.len() < _size) {
            if (p.len()) {
                _zc_bufs = std::move(p);
            } else {
                _zc_bufs = net::packet::make_null_packet();
            }
            return make_ready_future<stop_iteration>(stop_iteration::yes);
        }
        auto chunk = p.share(0, _size);
        p.trim_front(_size);
        return zero_copy_put(std::move(chunk)).then([] {
            return stop_iteration::no;
        });
    });
}

template<typename CharType>
future<> output_stream<CharType>::write(net::packet p) noexcept {
    static_assert(std::is_same_v<CharType, char>, "packet works on char");
  try {
    if (p.len() != 0) {
        (static_cast <bool> (!_end && "Mixing buffered writes and zero-copy writes not supported yet") ? void (0) : __assert_fail ("!_end && \"Mixing buffered writes and zero-copy writes not supported yet\"", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));

        if (_zc_bufs) {
            _zc_bufs.append(std::move(p));
        } else {
            _zc_bufs = std::move(p);
        }

        if (_zc_bufs.len() >= _size) {
            if (_trim_to_size) {
                return zero_copy_split_and_put(std::move(_zc_bufs));
            } else {
                return zero_copy_put(std::move(_zc_bufs));
            }
        }
    }
    return make_ready_future<>();
  } catch (...) {
    return current_exception_as_future();
  }
}

template<typename CharType>
future<> output_stream<CharType>::write(temporary_buffer<CharType> p) noexcept {
  try {
    if (p.empty()) {
        return make_ready_future<>();
    }
    (static_cast <bool> (!_end && "Mixing buffered writes and zero-copy writes not supported yet") ? void (0) : __assert_fail ("!_end && \"Mixing buffered writes and zero-copy writes not supported yet\"", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
    return write(net::packet(std::move(p)));
  } catch (...) {
    return current_exception_as_future();
  }
}

template <typename CharType>
future<temporary_buffer<CharType>>
input_stream<CharType>::read_exactly_part(size_t n) noexcept {
    temporary_buffer<CharType> out(n);
    size_t completed{0U};
    while (completed < n) {
        size_t avail = available();
        if (avail) {
            auto now = std::min(n - completed, avail);
            std::copy_n(_buf.get(), now, out.get_write() + completed);
            _buf.trim_front(now);
            completed += now;
            if (completed == n) {
                break;
            }
        }


        temporary_buffer<CharType> buf = co_await _fd.get();
        if (buf.size() == 0) {
            _eof = true;
            out.trim(completed);
            break;
        }
        _buf = std::move(buf);
    }
    co_return out;
}

template <typename CharType>
future<temporary_buffer<CharType>>
input_stream<CharType>::read_exactly(size_t n) noexcept {
    if (_buf.size() == n) {

        return make_ready_future<tmp_buf>(std::move(_buf));
    } else if (_buf.size() > n) {

        auto front = _buf.share(0, n);
        _buf.trim_front(n);
        return make_ready_future<tmp_buf>(std::move(front));
    } else if (_buf.size() == 0) {

        return _fd.get().then([this, n] (auto buf) mutable {
            if (buf.size() == 0) {
                _eof = true;
                return make_ready_future<tmp_buf>(std::move(buf));
            }
            _buf = std::move(buf);
            return this->read_exactly(n);
        });
    } else {

        return read_exactly_part(n);
    }
}

template <typename CharType>
template <typename Consumer>
requires InputStreamConsumer<Consumer, CharType> || ObsoleteInputStreamConsumer<Consumer, CharType>
future<>
input_stream<CharType>::consume(Consumer&& consumer) noexcept(std::is_nothrow_move_constructible_v<Consumer>) {
    return repeat([consumer = std::move(consumer), this] () mutable {
        if (_buf.empty() && !_eof) {
            return _fd.get().then([this] (tmp_buf buf) {
                _buf = std::move(buf);
                _eof = _buf.empty();
                return make_ready_future<stop_iteration>(stop_iteration::no);
            });
        }
        return consumer(std::move(_buf)).then([this] (consumption_result_type result) {
            return seastar::visit(result.get(), [this] (const continue_consuming&) {




                return make_ready_future<stop_iteration>(stop_iteration(this->_eof));
            }, [this] (stop_consuming<CharType>& stop) {

                this->_buf = std::move(stop.get_buffer());
                return make_ready_future<stop_iteration>(stop_iteration::yes);
            }, [this] (const skip_bytes& skip) {
                return this->_fd.skip(skip.get_value()).then([this](tmp_buf buf) {
                    if (!buf.empty()) {
                        this->_buf = std::move(buf);
                    }
                    return make_ready_future<stop_iteration>(stop_iteration::no);
                });
            });
        });
    });
}

template <typename CharType>
template <typename Consumer>
requires InputStreamConsumer<Consumer, CharType> || ObsoleteInputStreamConsumer<Consumer, CharType>
future<>
input_stream<CharType>::consume(Consumer& consumer) noexcept(std::is_nothrow_move_constructible_v<Consumer>) {
    return consume(std::ref(consumer));
}

template <typename CharType>
future<temporary_buffer<CharType>>
input_stream<CharType>::read_up_to(size_t n) noexcept {
    using tmp_buf = temporary_buffer<CharType>;
    if (_buf.empty()) {
        if (_eof) {
            return make_ready_future<tmp_buf>();
        } else {
            return _fd.get().then([this, n] (tmp_buf buf) {
                _eof = buf.empty();
                _buf = std::move(buf);
                return read_up_to(n);
            });
        }
    } else if (_buf.size() <= n) {

        return make_ready_future<tmp_buf>(std::move(_buf));
    } else {
      try {

        auto front = _buf.share(0, n);
        _buf.trim_front(n);
        return make_ready_future<tmp_buf>(std::move(front));
      } catch (...) {
        return current_exception_as_future<tmp_buf>();
      }
    }
}

template <typename CharType>
future<temporary_buffer<CharType>>
input_stream<CharType>::read() noexcept {
    using tmp_buf = temporary_buffer<CharType>;
    if (_eof) {
        return make_ready_future<tmp_buf>();
    }
    if (_buf.empty()) {
        return _fd.get().then([this] (tmp_buf buf) {
            _eof = buf.empty();
            return make_ready_future<tmp_buf>(std::move(buf));
        });
    } else {
        return make_ready_future<tmp_buf>(std::move(_buf));
    }
}

template <typename CharType>
future<>
input_stream<CharType>::skip(uint64_t n) noexcept {
    auto skip_buf = std::min(n, _buf.size());
    _buf.trim_front(skip_buf);
    n -= skip_buf;
    if (!n) {
        return make_ready_future<>();
    }
    return _fd.skip(n).then([this] (temporary_buffer<CharType> buffer) {
        _buf = std::move(buffer);
    });
}

template <typename CharType>
data_source
input_stream<CharType>::detach() && {
    if (_buf) {
        throw std::logic_error("detach() called on a used input_stream");
    }

    return std::move(_fd);
}


template <typename CharType>
future<>
output_stream<CharType>::split_and_put(temporary_buffer<CharType> buf) noexcept {
    (static_cast <bool> (_end == 0) ? void (0) : __assert_fail ("_end == 0", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));

    return repeat([this, buf = std::move(buf)] () mutable {
        if (buf.size() < _size) {
            if (!_buf) {
                _buf = _fd.allocate_buffer(_size);
            }
            std::copy(buf.get(), buf.get() + buf.size(), _buf.get_write());
            _end = buf.size();
            return make_ready_future<stop_iteration>(stop_iteration::yes);
        }
        auto chunk = buf.share(0, _size);
        buf.trim_front(_size);
        return put(std::move(chunk)).then([] {
            return stop_iteration::no;
        });
    });
}

template <typename CharType>
future<>
output_stream<CharType>::write(const char_type* buf, size_t n) noexcept {
    if (__builtin_expect(!_buf || n > _size - _end, false)) {
        return slow_write(buf, n);
    }
    std::copy_n(buf, n, _buf.get_write() + _end);
    _end += n;
    return make_ready_future<>();
}

template <typename CharType>
future<>
output_stream<CharType>::slow_write(const char_type* buf, size_t n) noexcept {
  try {
    (static_cast <bool> (!_zc_bufs && "Mixing buffered writes and zero-copy writes not supported yet") ? void (0) : __assert_fail ("!_zc_bufs && \"Mixing buffered writes and zero-copy writes not supported yet\"", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
    auto bulk_threshold = _end ? (2 * _size - _end) : _size;
    if (n >= bulk_threshold) {
        if (_end) {
            auto now = _size - _end;
            std::copy(buf, buf + now, _buf.get_write() + _end);
            _end = _size;
            temporary_buffer<char> tmp = _fd.allocate_buffer(n - now);
            std::copy(buf + now, buf + n, tmp.get_write());
            _buf.trim(_end);
            _end = 0;
            return put(std::move(_buf)).then([this, tmp = std::move(tmp)]() mutable {
                if (_trim_to_size) {
                    return split_and_put(std::move(tmp));
                } else {
                    return put(std::move(tmp));
                }
            });
        } else {
            temporary_buffer<char> tmp = _fd.allocate_buffer(n);
            std::copy(buf, buf + n, tmp.get_write());
            if (_trim_to_size) {
                return split_and_put(std::move(tmp));
            } else {
                return put(std::move(tmp));
            }
        }
    }

    if (!_buf) {
        _buf = _fd.allocate_buffer(_size);
    }

    auto now = std::min(n, _size - _end);
    std::copy(buf, buf + now, _buf.get_write() + _end);
    _end += now;
    if (now == n) {
        return make_ready_future<>();
    } else {
        temporary_buffer<char> next = _fd.allocate_buffer(_size);
        std::copy(buf + now, buf + n, next.get_write());
        _end = n - now;
        std::swap(next, _buf);
        return put(std::move(next));
    }
  } catch (...) {
    return current_exception_as_future();
  }
}

namespace internal {
void add_to_flush_poller(output_stream<char>& x) noexcept;
}

template <typename CharType>
future<> output_stream<CharType>::do_flush() noexcept {
    if (_end) {
        _buf.trim(_end);
        _end = 0;
        return _fd.put(std::move(_buf)).then([this] {
            return _fd.flush();
        });
    } else if (_zc_bufs) {
        return _fd.put(std::move(_zc_bufs)).then([this] {
            return _fd.flush();
        });
    } else {
        return _fd.flush();
    }
}

template <typename CharType>
future<>
output_stream<CharType>::flush() noexcept {
    if (!_batch_flushes) {
        return do_flush();
    } else {
        if (_ex) {

            return make_exception_future<>(std::move(_ex));
        } else {
            _flush = true;
            if (!_in_batch) {
                internal::add_to_flush_poller(*this);
                _in_batch = promise<>();
            }
        }
    }
    return make_ready_future<>();
}

template <typename CharType>
future<>
output_stream<CharType>::put(temporary_buffer<CharType> buf) noexcept {

    _flush = false;
    if (_flushing) {

        return _in_batch.value().get_future().then([this, buf = std::move(buf)] () mutable {
            return _fd.put(std::move(buf));
        });
    } else {
        return _fd.put(std::move(buf));
    }
}

template <typename CharType>
void
output_stream<CharType>::poll_flush() noexcept {
    if (!_flush) {

        _flushing = false;
        _in_batch.value().set_value();
        _in_batch = std::nullopt;
        return;
    }

    _flush = false;
    _flushing = true;


    (void)do_flush().then_wrapped([this] (future<> f) {
        try {
            f.get();
        } catch (...) {
            _ex = std::current_exception();
            _fd.on_batch_flush_error();
        }

        poll_flush();
    });
}

template <typename CharType>
future<>
output_stream<CharType>::close() noexcept {
    return flush().finally([this] {
        if (_in_batch) {
            return _in_batch.value().get_future();
        } else {
            return make_ready_future();
        }
    }).then([this] {

        if (_ex) {
            std::rethrow_exception(_ex);
        }
    }).finally([this] {
        return _fd.close();
    });
}

template <typename CharType>
data_sink
output_stream<CharType>::detach() && {
    if (_buf) {
        throw std::logic_error("detach() called on a used output_stream");
    }

    return std::move(_fd);
}

namespace internal {


template <typename CharType>
struct stream_copy_consumer {
private:
    output_stream<CharType>& _os;
    using unconsumed_remainder = std::optional<temporary_buffer<CharType>>;
public:
    stream_copy_consumer(output_stream<CharType>& os) : _os(os) {
    }
    future<unconsumed_remainder> operator()(temporary_buffer<CharType> data) {
        if (data.empty()) {
            return make_ready_future<unconsumed_remainder>(std::move(data));
        }
        return _os.write(data.get(), data.size()).then([] () {
            return make_ready_future<unconsumed_remainder>();
        });
    }
};


}

extern template struct internal::stream_copy_consumer<char>;

template <typename CharType>
future<> copy(input_stream<CharType>& in, output_stream<CharType>& out) {
    return in.consume(internal::stream_copy_consumer<CharType>(out));
}

extern template future<> copy<char>(input_stream<char>&, output_stream<char>&);
}
# 470 "/home/avi/scylla-maint/seastar/include/seastar/core/iostream.hh" 2
# 40 "/home/avi/scylla-maint/seastar/include/seastar/net/api.hh" 2

# 1 "/home/avi/scylla-maint/seastar/include/seastar/util/program-options.hh" 1
# 31 "/home/avi/scylla-maint/seastar/include/seastar/util/program-options.hh"
# 1 "/usr/include/boost/any.hpp" 1 3 4
# 21 "/usr/include/boost/any.hpp" 3 4
# 1 "/usr/include/boost/any/bad_any_cast.hpp" 1 3 4
# 23 "/usr/include/boost/any/bad_any_cast.hpp" 3 4
namespace boost {



class __attribute__((__visibility__("default"))) bad_any_cast :

    public std::bad_cast



{
public:
    const char * what() const noexcept override
    {
        return "boost::bad_any_cast: "
               "failed conversion using boost::any_cast";
    }
};

}
# 22 "/usr/include/boost/any.hpp" 2 3 4
# 1 "/usr/include/boost/any/fwd.hpp" 1 3 4
# 20 "/usr/include/boost/any/fwd.hpp" 3 4
# 1 "/usr/include/boost/config/pragma_message.hpp" 1 3 4
# 21 "/usr/include/boost/any/fwd.hpp" 2 3 4
# 38 "/usr/include/boost/any/fwd.hpp" 3 4
# 1 "/usr/include/boost/type_traits/alignment_of.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/alignment_of.hpp" 3 4
# 1 "/usr/include/boost/type_traits/intrinsics.hpp" 1 3 4
# 16 "/usr/include/boost/type_traits/intrinsics.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/config.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/config.hpp" 3 4
# 1 "/usr/include/boost/version.hpp" 1 3 4
# 16 "/usr/include/boost/type_traits/detail/config.hpp" 2 3 4
# 17 "/usr/include/boost/type_traits/intrinsics.hpp" 2 3 4
# 16 "/usr/include/boost/type_traits/alignment_of.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/integral_constant.hpp" 1 3 4
# 31 "/usr/include/boost/type_traits/integral_constant.hpp" 3 4
namespace mpl_{

   template <bool B> struct bool_;
   template <class I, I val> struct integral_c;
   struct integral_c_tag;
}

namespace boost
{
   namespace mpl
   {
      using ::mpl_::bool_;
      using ::mpl_::integral_c;
      using ::mpl_::integral_c_tag;
   }
}



namespace boost{

   template <class T, T val>
   struct integral_constant
   {
      typedef mpl::integral_c_tag tag;
      typedef T value_type;
      typedef integral_constant<T, val> type;
      static const T value = val;

      operator const mpl::integral_c<T, val>& ()const
      {
         static const char data[sizeof(long)] = { 0 };
         static const void* pdata = data;
         return *(reinterpret_cast<const mpl::integral_c<T, val>*>(pdata));
      }
      constexpr operator T()const { return val; }
   };

   template <class T, T val>
   T const integral_constant<T, val>::value;

   template <bool val>
   struct integral_constant<bool, val>
   {
      typedef mpl::integral_c_tag tag;
      typedef bool value_type;
      typedef integral_constant<bool, val> type;
      static const bool value = val;

      operator const mpl::bool_<val>& ()const
      {
         static const char data[sizeof(long)] = { 0 };
         static const void* pdata = data;
         return *(reinterpret_cast<const mpl::bool_<val>*>(pdata));
      }
      constexpr operator bool()const { return val; }
   };

   template <bool val>
   bool const integral_constant<bool, val>::value;

   typedef integral_constant<bool, true> true_type;
   typedef integral_constant<bool, false> false_type;

}
# 17 "/usr/include/boost/type_traits/alignment_of.hpp" 2 3 4
# 26 "/usr/include/boost/type_traits/alignment_of.hpp" 3 4
namespace boost {

template <typename T> struct alignment_of;


namespace detail {





template <typename T>
struct alignment_of_hack
{
    char c;
    T t;
    alignment_of_hack();
};




template <unsigned A, unsigned S>
struct alignment_logic
{
    static const std::size_t value = A < S ? A : S;
};


template< typename T >
struct alignment_of_impl
{
# 82 "/usr/include/boost/type_traits/alignment_of.hpp" 3 4
   static const std::size_t value = __alignof(T);

};

}

template <class T> struct alignment_of : public integral_constant<std::size_t, ::boost::detail::alignment_of_impl<T>::value>{};



template <typename T> struct alignment_of<T&> : public alignment_of<T*>{};
# 102 "/usr/include/boost/type_traits/alignment_of.hpp" 3 4
template<> struct alignment_of<void> : integral_constant<std::size_t, 0>{};

template<> struct alignment_of<void const> : integral_constant<std::size_t, 0>{};
template<> struct alignment_of<void const volatile> : integral_constant<std::size_t, 0>{};
template<> struct alignment_of<void volatile> : integral_constant<std::size_t, 0>{};


}
# 39 "/usr/include/boost/any/fwd.hpp" 2 3 4


namespace boost {

class any;

namespace anys {

class unique_any;

template<std::size_t OptimizeForSize = sizeof(void*), std::size_t OptimizeForAlignment = boost::alignment_of<void*>::value>
class basic_any;

namespace detail {

    template <class T>
    struct is_basic_any: public boost::false_type {};

    template<std::size_t OptimizeForSize, std::size_t OptimizeForAlignment>
    struct is_basic_any<boost::anys::basic_any<OptimizeForSize, OptimizeForAlignment> > : public boost::true_type {};

    template <class T>
    struct is_some_any: public is_basic_any<T> {};

    template <>
    struct is_some_any<boost::any>: public boost::true_type {};

    template <>
    struct is_some_any<boost::anys::unique_any>: public boost::true_type {};

}

}

}
# 23 "/usr/include/boost/any.hpp" 2 3 4
# 1 "/usr/include/boost/any/detail/placeholder.hpp" 1 3 4
# 15 "/usr/include/boost/any/detail/placeholder.hpp" 3 4
# 1 "/usr/include/boost/type_index.hpp" 1 3 4
# 49 "/usr/include/boost/type_index.hpp" 3 4
# 1 "/usr/include/boost/type_index/stl_type_index.hpp" 1 3 4
# 22 "/usr/include/boost/type_index/stl_type_index.hpp" 3 4
# 1 "/usr/include/boost/type_index/type_index_facade.hpp" 1 3 4
# 13 "/usr/include/boost/type_index/type_index_facade.hpp" 3 4
# 1 "/usr/include/boost/container_hash/hash_fwd.hpp" 1 3 4
# 11 "/usr/include/boost/container_hash/hash_fwd.hpp" 3 4
namespace boost
{

namespace container_hash
{

template<class T> struct is_range;
template<class T> struct is_contiguous_range;
template<class T> struct is_unordered_range;
template<class T> struct is_described_class;
template<class T> struct is_tuple_like;

}

template<class T> struct hash;

template<class T> void hash_combine( std::size_t& seed, T const& v );

template<class It> void hash_range( std::size_t&, It, It );
template<class It> std::size_t hash_range( It, It );

template<class It> void hash_unordered_range( std::size_t&, It, It );
template<class It> std::size_t hash_unordered_range( It, It );

}
# 14 "/usr/include/boost/type_index/type_index_facade.hpp" 2 3 4

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 1 3 4
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 3


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 43 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 2 3
# 16 "/usr/include/boost/type_index/type_index_facade.hpp" 2 3 4
# 29 "/usr/include/boost/type_index/type_index_facade.hpp" 3 4
namespace boost { namespace typeindex {
# 61 "/usr/include/boost/type_index/type_index_facade.hpp" 3 4
template <class Derived, class TypeInfo>
class type_index_facade {
private:

    constexpr const Derived & derived() const noexcept {
      return *static_cast<Derived const*>(this);
    }

public:
    typedef TypeInfo type_info_t;



    inline const char* name() const noexcept {
        return derived().raw_name();
    }



    inline std::string pretty_name() const {
        return derived().name();
    }



    inline bool equal(const Derived& rhs) const noexcept {
        const char* const left = derived().raw_name();
        const char* const right = rhs.raw_name();
        return left == right || !std::strcmp(left, right);
    }



    inline bool before(const Derived& rhs) const noexcept {
        const char* const left = derived().raw_name();
        const char* const right = rhs.raw_name();
        return left != right && std::strcmp(left, right) < 0;
    }





    inline std::size_t hash_code() const noexcept {
        const char* const name_raw = derived().raw_name();
        return boost::hash_range(name_raw, name_raw + std::strlen(name_raw));
    }
# 150 "/usr/include/boost/type_index/type_index_facade.hpp" 3 4
};


template <class Derived, class TypeInfo>
constexpr inline bool operator == (const type_index_facade<Derived, TypeInfo>& lhs, const type_index_facade<Derived, TypeInfo>& rhs) noexcept {
    return static_cast<Derived const&>(lhs).equal(static_cast<Derived const&>(rhs));
}

template <class Derived, class TypeInfo>
constexpr inline bool operator < (const type_index_facade<Derived, TypeInfo>& lhs, const type_index_facade<Derived, TypeInfo>& rhs) noexcept {
    return static_cast<Derived const&>(lhs).before(static_cast<Derived const&>(rhs));
}



template <class Derived, class TypeInfo>
constexpr inline bool operator > (const type_index_facade<Derived, TypeInfo>& lhs, const type_index_facade<Derived, TypeInfo>& rhs) noexcept {
    return rhs < lhs;
}

template <class Derived, class TypeInfo>
constexpr inline bool operator <= (const type_index_facade<Derived, TypeInfo>& lhs, const type_index_facade<Derived, TypeInfo>& rhs) noexcept {
    return !(lhs > rhs);
}

template <class Derived, class TypeInfo>
constexpr inline bool operator >= (const type_index_facade<Derived, TypeInfo>& lhs, const type_index_facade<Derived, TypeInfo>& rhs) noexcept {
    return !(lhs < rhs);
}

template <class Derived, class TypeInfo>
constexpr inline bool operator != (const type_index_facade<Derived, TypeInfo>& lhs, const type_index_facade<Derived, TypeInfo>& rhs) noexcept {
    return !(lhs == rhs);
}


template <class Derived, class TypeInfo>
inline bool operator == (const TypeInfo& lhs, const type_index_facade<Derived, TypeInfo>& rhs) noexcept {
    return Derived(lhs) == rhs;
}

template <class Derived, class TypeInfo>
inline bool operator < (const TypeInfo& lhs, const type_index_facade<Derived, TypeInfo>& rhs) noexcept {
    return Derived(lhs) < rhs;
}

template <class Derived, class TypeInfo>
inline bool operator > (const TypeInfo& lhs, const type_index_facade<Derived, TypeInfo>& rhs) noexcept {
    return rhs < Derived(lhs);
}

template <class Derived, class TypeInfo>
inline bool operator <= (const TypeInfo& lhs, const type_index_facade<Derived, TypeInfo>& rhs) noexcept {
    return !(Derived(lhs) > rhs);
}

template <class Derived, class TypeInfo>
inline bool operator >= (const TypeInfo& lhs, const type_index_facade<Derived, TypeInfo>& rhs) noexcept {
    return !(Derived(lhs) < rhs);
}

template <class Derived, class TypeInfo>
inline bool operator != (const TypeInfo& lhs, const type_index_facade<Derived, TypeInfo>& rhs) noexcept {
    return !(Derived(lhs) == rhs);
}


template <class Derived, class TypeInfo>
inline bool operator == (const type_index_facade<Derived, TypeInfo>& lhs, const TypeInfo& rhs) noexcept {
    return lhs == Derived(rhs);
}

template <class Derived, class TypeInfo>
inline bool operator < (const type_index_facade<Derived, TypeInfo>& lhs, const TypeInfo& rhs) noexcept {
    return lhs < Derived(rhs);
}

template <class Derived, class TypeInfo>
inline bool operator > (const type_index_facade<Derived, TypeInfo>& lhs, const TypeInfo& rhs) noexcept {
    return Derived(rhs) < lhs;
}

template <class Derived, class TypeInfo>
inline bool operator <= (const type_index_facade<Derived, TypeInfo>& lhs, const TypeInfo& rhs) noexcept {
    return !(lhs > Derived(rhs));
}

template <class Derived, class TypeInfo>
inline bool operator >= (const type_index_facade<Derived, TypeInfo>& lhs, const TypeInfo& rhs) noexcept {
    return !(lhs < Derived(rhs));
}

template <class Derived, class TypeInfo>
inline bool operator != (const type_index_facade<Derived, TypeInfo>& lhs, const TypeInfo& rhs) noexcept {
    return !(lhs == Derived(rhs));
}
# 276 "/usr/include/boost/type_index/type_index_facade.hpp" 3 4
template <class CharT, class TriatT, class Derived, class TypeInfo>
inline std::basic_ostream<CharT, TriatT>& operator<<(
    std::basic_ostream<CharT, TriatT>& ostr,
    const type_index_facade<Derived, TypeInfo>& ind)
{
    ostr << static_cast<Derived const&>(ind).pretty_name();
    return ostr;
}





template <class Derived, class TypeInfo>
inline std::size_t hash_value(const type_index_facade<Derived, TypeInfo>& lhs) noexcept {
    return static_cast<Derived const&>(lhs).hash_code();
}

}}
# 23 "/usr/include/boost/type_index/stl_type_index.hpp" 2 3 4







# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 1 3 4
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 3


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 43 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 2 3
# 31 "/usr/include/boost/type_index/stl_type_index.hpp" 2 3 4


# 1 "/usr/include/boost/throw_exception.hpp" 1 3 4
# 21 "/usr/include/boost/throw_exception.hpp" 3 4
# 1 "/usr/include/boost/exception/exception.hpp" 1 3 4








# 1 "/usr/include/boost/assert/source_location.hpp" 1 3 4
# 10 "/usr/include/boost/assert/source_location.hpp" 3 4
# 1 "/usr/include/boost/current_function.hpp" 1 3 4
# 22 "/usr/include/boost/current_function.hpp" 3 4
namespace boost
{

namespace detail
{

inline void current_function_helper()
{
# 69 "/usr/include/boost/current_function.hpp" 3 4
}

}

}
# 11 "/usr/include/boost/assert/source_location.hpp" 2 3 4


# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 14 "/usr/include/boost/assert/source_location.hpp" 2 3 4


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdio" 1 3 4
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdio" 3
# 17 "/usr/include/boost/assert/source_location.hpp" 2 3 4
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 1 3 4
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 3


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 43 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 2 3
# 18 "/usr/include/boost/assert/source_location.hpp" 2 3 4





namespace boost
{

struct source_location
{
private:

    char const * file_;
    char const * function_;
    boost::uint_least32_t line_;
    boost::uint_least32_t column_;

public:

    constexpr source_location() noexcept: file_( "" ), function_( "" ), line_( 0 ), column_( 0 )
    {
    }

    constexpr source_location( char const * file, boost::uint_least32_t ln, char const * function, boost::uint_least32_t col = 0 ) noexcept: file_( file ), function_( function ), line_( ln ), column_( col )
    {
    }



    constexpr source_location( std::source_location const& loc ) noexcept: file_( loc.file_name() ), function_( loc.function_name() ), line_( loc.line() ), column_( loc.column() )
    {
    }



    constexpr char const * file_name() const noexcept
    {
        return file_;
    }

    constexpr char const * function_name() const noexcept
    {
        return function_;
    }

    constexpr boost::uint_least32_t line() const noexcept
    {
        return line_;
    }

    constexpr boost::uint_least32_t column() const noexcept
    {
        return column_;
    }
# 84 "/usr/include/boost/assert/source_location.hpp" 3 4
    std::string to_string() const
    {
        unsigned long ln = line();

        if( ln == 0 )
        {
            return "(unknown source location)";
        }

        std::string r = file_name();

        char buffer[ 16 ];

        std::snprintf(buffer, sizeof(buffer)/sizeof(buffer[0]), ":%lu", ln);
        r += buffer;

        unsigned long co = column();

        if( co )
        {
            std::snprintf(buffer, sizeof(buffer)/sizeof(buffer[0]), ":%lu", co);
            r += buffer;
        }

        char const* fn = function_name();

        if( *fn != 0 )
        {
            r += " in function '";
            r += fn;
            r += '\'';
        }

        return r;
    }







    inline friend bool operator==( source_location const& s1, source_location const& s2 ) noexcept
    {
        return std::strcmp( s1.file_, s2.file_ ) == 0 && std::strcmp( s1.function_, s2.function_ ) == 0 && s1.line_ == s2.line_ && s1.column_ == s2.column_;
    }

    inline friend bool operator!=( source_location const& s1, source_location const& s2 ) noexcept
    {
        return !( s1 == s2 );
    }
};

template<class E, class T> std::basic_ostream<E, T> & operator<<( std::basic_ostream<E, T> & os, source_location const & loc )
{
    os << loc.to_string();
    return os;
}

}
# 10 "/usr/include/boost/exception/exception.hpp" 2 3 4







namespace boost { template <class T> class shared_ptr; }
namespace boost { namespace exception_detail { using boost::shared_ptr; } }
# 24 "/usr/include/boost/exception/exception.hpp" 3
# 27 "/usr/include/boost/exception/exception.hpp" 3







namespace
boost
    {
    namespace
    exception_detail
        {
        template <class T>
        class
        refcount_ptr
            {
            public:

            refcount_ptr():
                px_(0)
                {
                }

            ~refcount_ptr()
                {
                release();
                }

            refcount_ptr( refcount_ptr const & x ):
                px_(x.px_)
                {
                add_ref();
                }

            refcount_ptr &
            operator=( refcount_ptr const & x )
                {
                adopt(x.px_);
                return *this;
                }

            void
            adopt( T * px )
                {
                release();
                px_=px;
                add_ref();
                }

            T *
            get() const
                {
                return px_;
                }

            private:

            T * px_;

            void
            add_ref()
                {
                if( px_ )
                    px_->add_ref();
                }

            void
            release()
                {
                if( px_ && px_->release() )
                    px_=0;
                }
            };
        }



    template <class Tag,class T>
    class error_info;

    typedef error_info<struct throw_function_,char const *> throw_function;
    typedef error_info<struct throw_file_,char const *> throw_file;
    typedef error_info<struct throw_line_,int> throw_line;
    typedef error_info<struct throw_column_,int> throw_column;

    template <>
    class
    error_info<throw_function_,char const *>
        {
        public:
        typedef char const * value_type;
        value_type v_;
        explicit
        error_info( value_type v ):
            v_(v)
            {
            }
        };

    template <>
    class
    error_info<throw_file_,char const *>
        {
        public:
        typedef char const * value_type;
        value_type v_;
        explicit
        error_info( value_type v ):
            v_(v)
            {
            }
        };

    template <>
    class
    error_info<throw_line_,int>
        {
        public:
        typedef int value_type;
        value_type v_;
        explicit
        error_info( value_type v ):
            v_(v)
            {
            }
        };

    template <>
    class
    error_info<throw_column_,int>
        {
        public:
        typedef int value_type;
        value_type v_;
        explicit
        error_info( value_type v ):
            v_(v)
            {
            }
        };

    class
    __attribute__((__visibility__("default")))
    exception;

    namespace
    exception_detail
        {
        class error_info_base;
        struct type_info_;

        struct
        error_info_container
            {
            virtual char const * diagnostic_information( char const * ) const = 0;
            virtual shared_ptr<error_info_base> get( type_info_ const & ) const = 0;
            virtual void set( shared_ptr<error_info_base> const &, type_info_ const & ) = 0;
            virtual void add_ref() const = 0;
            virtual bool release() const = 0;
            virtual refcount_ptr<exception_detail::error_info_container> clone() const = 0;

            protected:

            ~error_info_container() noexcept
                {
                }
            };

        template <class>
        struct get_info;

        template <>
        struct get_info<throw_function>;

        template <>
        struct get_info<throw_file>;

        template <>
        struct get_info<throw_line>;

        template <>
        struct get_info<throw_column>;

        template <class>
        struct set_info_rv;

        template <>
        struct set_info_rv<throw_function>;

        template <>
        struct set_info_rv<throw_file>;

        template <>
        struct set_info_rv<throw_line>;

        template <>
        struct set_info_rv<throw_column>;

        char const * get_diagnostic_information( exception const &, char const * );

        void copy_boost_exception( exception *, exception const * );

        template <class E,class Tag,class T>
        E const & set_info( E const &, error_info<Tag,T> const & );

        template <class E>
        E const & set_info( E const &, throw_function const & );

        template <class E>
        E const & set_info( E const &, throw_file const & );

        template <class E>
        E const & set_info( E const &, throw_line const & );

        template <class E>
        E const & set_info( E const &, throw_column const & );

        boost::source_location get_exception_throw_location( exception const & );
        }

    class
    __attribute__((__visibility__("default")))
    exception
        {

        public:
        template <class Tag> void set( typename Tag::type const & );
        template <class Tag> typename Tag::type const * get() const;


        protected:

        exception():
            throw_function_(0),
            throw_file_(0),
            throw_line_(-1),
            throw_column_(-1)
            {
            }
# 281 "/usr/include/boost/exception/exception.hpp" 3
        virtual ~exception() noexcept

            = 0

            ;




        private:

        template <class E>
        friend E const & exception_detail::set_info( E const &, throw_function const & );

        template <class E>
        friend E const & exception_detail::set_info( E const &, throw_file const & );

        template <class E>
        friend E const & exception_detail::set_info( E const &, throw_line const & );

        template <class E>
        friend E const & exception_detail::set_info( E const &, throw_column const & );

        template <class E,class Tag,class T>
        friend E const & exception_detail::set_info( E const &, error_info<Tag,T> const & );

        friend char const * exception_detail::get_diagnostic_information( exception const &, char const * );

        friend boost::source_location exception_detail::get_exception_throw_location( exception const & );

        template <class>
        friend struct exception_detail::get_info;
        friend struct exception_detail::get_info<throw_function>;
        friend struct exception_detail::get_info<throw_file>;
        friend struct exception_detail::get_info<throw_line>;
        friend struct exception_detail::get_info<throw_column>;
        template <class>
        friend struct exception_detail::set_info_rv;
        friend struct exception_detail::set_info_rv<throw_function>;
        friend struct exception_detail::set_info_rv<throw_file>;
        friend struct exception_detail::set_info_rv<throw_line>;
        friend struct exception_detail::set_info_rv<throw_column>;
        friend void exception_detail::copy_boost_exception( exception *, exception const * );

        mutable exception_detail::refcount_ptr<exception_detail::error_info_container> data_;
        mutable char const * throw_function_;
        mutable char const * throw_file_;
        mutable int throw_line_;
        mutable int throw_column_;
        };

    inline
    exception::
    ~exception() noexcept
        {
        }

    namespace
    exception_detail
        {
        template <class E>
        E const &
        set_info( E const & x, throw_function const & y )
            {
            x.throw_function_=y.v_;
            return x;
            }

        template <class E>
        E const &
        set_info( E const & x, throw_file const & y )
            {
            x.throw_file_=y.v_;
            return x;
            }

        template <class E>
        E const &
        set_info( E const & x, throw_line const & y )
            {
            x.throw_line_=y.v_;
            return x;
            }

        template <class E>
        E const &
        set_info( E const & x, throw_column const & y )
            {
            x.throw_column_=y.v_;
            return x;
            }



        template <>
        struct
        set_info_rv<throw_column>
            {
            template <class E>
            static
            E const &
            set( E const & x, throw_column && y )
                {
                x.throw_column_=y.v_;
                return x;
                }
            };



        inline boost::source_location get_exception_throw_location( exception const & x )
            {
            return boost::source_location(
                x.throw_file_? x.throw_file_: "",
                x.throw_line_ >= 0? x.throw_line_: 0,
                x.throw_function_? x.throw_function_: "",
                x.throw_column_ >= 0? x.throw_column_: 0
                );
            }
        }



    namespace
    exception_detail
        {
        template <class T>
        struct
        __attribute__((__visibility__("default")))
        error_info_injector:
            public T,
            public exception
            {
            explicit
            error_info_injector( T const & x ):
                T(x)
                {
                }

            ~error_info_injector() noexcept
                {
                }
            };

        struct large_size { char c[256]; };
        large_size dispatch_boost_exception( exception const * );

        struct small_size { };
        small_size dispatch_boost_exception( void const * );

        template <class,int>
        struct enable_error_info_helper;

        template <class T>
        struct
        enable_error_info_helper<T,sizeof(large_size)>
            {
            typedef T type;
            };

        template <class T>
        struct
        enable_error_info_helper<T,sizeof(small_size)>
            {
            typedef error_info_injector<T> type;
            };

        template <class T>
        struct
        enable_error_info_return_type
            {
            typedef typename enable_error_info_helper<T,sizeof(exception_detail::dispatch_boost_exception(static_cast<T *>(0)))>::type type;
            };
        }

    template <class T>
    inline
    typename
    exception_detail::enable_error_info_return_type<T>::type
    enable_error_info( T const & x )
        {
        typedef typename exception_detail::enable_error_info_return_type<T>::type rt;
        return rt(x);
        }






    namespace
    exception_detail
        {
        class
        __attribute__((__visibility__("default")))
        clone_base
            {
            public:

            virtual clone_base const * clone() const = 0;
            virtual void rethrow() const = 0;

            virtual
            ~clone_base() noexcept
                {
                }
            };

        inline
        void
        copy_boost_exception( exception * a, exception const * b )
            {
            refcount_ptr<error_info_container> data;
            if( error_info_container * d=b->data_.get() )
                data = d->clone();
            a->throw_file_ = b->throw_file_;
            a->throw_line_ = b->throw_line_;
            a->throw_function_ = b->throw_function_;
            a->throw_column_ = b->throw_column_;
            a->data_ = data;
            }

        inline
        void
        copy_boost_exception( void *, void const * )
            {
            }

        template <class T>
        class
        __attribute__((__visibility__("default")))
        clone_impl:
            public T,
            public virtual clone_base
            {
            struct clone_tag { };
            clone_impl( clone_impl const & x, clone_tag ):
                T(x)
                {
                copy_boost_exception(this,&x);
                }

            public:

            explicit
            clone_impl( T const & x ):
                T(x)
                {
                copy_boost_exception(this,&x);
                }

            ~clone_impl() noexcept
                {
                }

            private:

            clone_base const *
            clone() const
                {
                return new clone_impl(*this,clone_tag());
                }

            void
            rethrow() const
                {



                throw*this;

                }
            };
        }

    template <class T>
    inline
    exception_detail::clone_impl<T>
    enable_current_exception( T const & x )
        {
        return exception_detail::clone_impl<T>(x);
        }
    }
# 22 "/usr/include/boost/throw_exception.hpp" 2 3 4
# 36 "/usr/include/boost/throw_exception.hpp" 3 4
namespace boost
{
# 48 "/usr/include/boost/throw_exception.hpp" 3 4
namespace detail
{

typedef char (&wrapexcept_s1)[ 1 ];
typedef char (&wrapexcept_s2)[ 2 ];

template<class T> wrapexcept_s1 wrapexcept_is_convertible( T* );
template<class T> wrapexcept_s2 wrapexcept_is_convertible( void* );

template<class E, class B, std::size_t I = sizeof( wrapexcept_is_convertible<B>( static_cast< E* >( nullptr ) ) ) > struct wrapexcept_add_base;

template<class E, class B> struct wrapexcept_add_base<E, B, 1>
{
    struct type {};
};

template<class E, class B> struct wrapexcept_add_base<E, B, 2>
{
    typedef B type;
};

}

template<class E> struct __attribute__((__visibility__("default"))) wrapexcept:
    public detail::wrapexcept_add_base<E, boost::exception_detail::clone_base>::type,
    public E,
    public detail::wrapexcept_add_base<E, boost::exception>::type
{
private:

    struct deleter
    {
        wrapexcept * p_;
        ~deleter() { delete p_; }
    };

private:

    void copy_from( void const* )
    {
    }

    void copy_from( boost::exception const* p )
    {
        static_cast<boost::exception&>( *this ) = *p;
    }

public:

    explicit wrapexcept( E const & e ): E( e )
    {
        copy_from( &e );
    }

    explicit wrapexcept( E const & e, boost::source_location const & loc ): E( e )
    {
        copy_from( &e );

        set_info( *this, throw_file( loc.file_name() ) );
        set_info( *this, throw_line( static_cast<int>( loc.line() ) ) );
        set_info( *this, throw_function( loc.function_name() ) );
        set_info( *this, throw_column( static_cast<int>( loc.column() ) ) );
    }

    virtual boost::exception_detail::clone_base const * clone() const override
    {
        wrapexcept * p = new wrapexcept( *this );
        deleter del = { p };

        boost::exception_detail::copy_boost_exception( p, this );

        del.p_ = nullptr;
        return p;
    }

    virtual void rethrow() const override
    {






        throw *this;


    }
};




inline void throw_exception_assert_compatibility( std::exception const & ) {}
# 162 "/usr/include/boost/throw_exception.hpp" 3 4
template<class E> __attribute__ ((__noreturn__)) void throw_exception( E const & e )
{
    throw_exception_assert_compatibility( e );
    throw wrapexcept<E>( e );
}

template<class E> __attribute__ ((__noreturn__)) void throw_exception( E const & e, boost::source_location const & loc )
{
    throw_exception_assert_compatibility( e );
    throw wrapexcept<E>( e, loc );
}





}





namespace boost
{



namespace detail
{

struct __attribute__((__visibility__("default"))) throw_location
{
    boost::source_location location_;

    explicit throw_location( boost::source_location const & loc ): location_( loc )
    {
    }
};

template<class E> class __attribute__((__visibility__("default"))) with_throw_location: public E, public throw_location
{
public:

    with_throw_location( E const & e, boost::source_location const & loc ): E( e ), throw_location( loc )
    {
    }



    with_throw_location( E && e, boost::source_location const & loc ): E( std::move( e ) ), throw_location( loc )
    {
    }


};

}





template<class E> __attribute__ ((__noreturn__)) void throw_with_location( E && e, boost::source_location const & loc = ::boost::source_location(::std::source_location::current()) )
{
    throw_exception_assert_compatibility( e );
    throw detail::with_throw_location<typename std::decay<E>::type>( std::forward<E>( e ), loc );
}
# 251 "/usr/include/boost/throw_exception.hpp" 3 4
template<class E> boost::source_location get_throw_location( E const & e )
{







    if( detail::throw_location const* pl = dynamic_cast< detail::throw_location const* >( &e ) )
    {
        return pl->location_;
    }
    else if( boost::exception const* px = dynamic_cast< boost::exception const* >( &e ) )
    {
        return exception_detail::get_exception_throw_location( *px );
    }
    else
    {
        return boost::source_location();
    }


}

}
# 34 "/usr/include/boost/type_index/stl_type_index.hpp" 2 3 4
# 1 "/usr/include/boost/core/demangle.hpp" 1 3 4
# 32 "/usr/include/boost/core/demangle.hpp" 3 4
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cxxabi.h" 1 3 4
# 45 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cxxabi.h" 3

#pragma GCC visibility push(default)

# 1 "/usr/bin/../lib/clang/18/include/stddef.h" 1 3
# 72 "/usr/bin/../lib/clang/18/include/stddef.h" 3
# 1 "/usr/bin/../lib/clang/18/include/__stddef_ptrdiff_t.h" 1 3
# 18 "/usr/bin/../lib/clang/18/include/__stddef_ptrdiff_t.h" 3
typedef long int ptrdiff_t;
# 73 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3




# 1 "/usr/bin/../lib/clang/18/include/__stddef_size_t.h" 1 3
# 18 "/usr/bin/../lib/clang/18/include/__stddef_size_t.h" 3
typedef long unsigned int size_t;
# 78 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3
# 87 "/usr/bin/../lib/clang/18/include/stddef.h" 3
# 1 "/usr/bin/../lib/clang/18/include/__stddef_wchar_t.h" 1 3
# 88 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3




# 1 "/usr/bin/../lib/clang/18/include/__stddef_null.h" 1 3
# 93 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3




# 1 "/usr/bin/../lib/clang/18/include/__stddef_nullptr_t.h" 1 3
# 98 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3
# 112 "/usr/bin/../lib/clang/18/include/stddef.h" 3
# 1 "/usr/bin/../lib/clang/18/include/__stddef_offsetof.h" 1 3
# 113 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3
# 49 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cxxabi.h" 2 3

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/cxxabi_tweaks.h" 1 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/cxxabi_tweaks.h" 3
namespace __cxxabiv1
{
  extern "C"
  {
# 46 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/x86_64-redhat-linux/bits/cxxabi_tweaks.h" 3
  __extension__ typedef int __guard __attribute__((mode (__DI__)));


  typedef void __cxa_vec_ctor_return_type;


  typedef void __cxa_cdtor_return_type;


  }
}
# 51 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cxxabi.h" 2 3




namespace __cxxabiv1
{
  extern "C"
  {


  typedef __cxa_cdtor_return_type (*__cxa_cdtor_type)(void *);


  void*
  __cxa_vec_new(size_t __element_count, size_t __element_size,
  size_t __padding_size, __cxa_cdtor_type __constructor,
  __cxa_cdtor_type __destructor);

  void*
  __cxa_vec_new2(size_t __element_count, size_t __element_size,
   size_t __padding_size, __cxa_cdtor_type __constructor,
   __cxa_cdtor_type __destructor, void *(*__alloc) (size_t),
   void (*__dealloc) (void*));

  void*
  __cxa_vec_new3(size_t __element_count, size_t __element_size,
   size_t __padding_size, __cxa_cdtor_type __constructor,
   __cxa_cdtor_type __destructor, void *(*__alloc) (size_t),
   void (*__dealloc) (void*, size_t));


  __cxa_vec_ctor_return_type
  __cxa_vec_ctor(void* __array_address, size_t __element_count,
   size_t __element_size, __cxa_cdtor_type __constructor,
   __cxa_cdtor_type __destructor);

  __cxa_vec_ctor_return_type
  __cxa_vec_cctor(void* __dest_array, void* __src_array,
    size_t __element_count, size_t __element_size,
    __cxa_cdtor_return_type (*__constructor) (void*, void*),
    __cxa_cdtor_type __destructor);


  void
  __cxa_vec_dtor(void* __array_address, size_t __element_count,
   size_t __element_size, __cxa_cdtor_type __destructor);

  void
  __cxa_vec_cleanup(void* __array_address, size_t __element_count, size_t __s,
      __cxa_cdtor_type __destructor) noexcept;


  void
  __cxa_vec_delete(void* __array_address, size_t __element_size,
     size_t __padding_size, __cxa_cdtor_type __destructor);

  void
  __cxa_vec_delete2(void* __array_address, size_t __element_size,
      size_t __padding_size, __cxa_cdtor_type __destructor,
      void (*__dealloc) (void*));

  void
  __cxa_vec_delete3(void* __array_address, size_t __element_size,
      size_t __padding_size, __cxa_cdtor_type __destructor,
      void (*__dealloc) (void*, size_t));

  int
  __cxa_guard_acquire(__guard*);

  void
  __cxa_guard_release(__guard*) noexcept;

  void
  __cxa_guard_abort(__guard*) noexcept;


  int

  __cxa_atexit(void ( *)(void*), void*, void*) noexcept;




  void
  __cxa_finalize(void*);


  int

  __cxa_thread_atexit(void ( *)(void*), void*, void *) noexcept;





  void
  __cxa_pure_virtual(void) __attribute__ ((__noreturn__));

  void
  __cxa_deleted_virtual(void) __attribute__ ((__noreturn__));


  void
  __cxa_bad_cast() __attribute__((__noreturn__));

  void
  __cxa_bad_typeid() __attribute__((__noreturn__));

  void
  __cxa_throw_bad_array_new_length() __attribute__((__noreturn__));
# 203 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cxxabi.h" 3
  char*
  __cxa_demangle(const char* __mangled_name, char* __output_buffer,
   size_t* __length, int* __status);


  }
}






namespace __cxxabiv1
{

  class __fundamental_type_info : public std::type_info
  {
  public:
    explicit
    __fundamental_type_info(const char* __n) : std::type_info(__n) { }

    virtual
    ~__fundamental_type_info();
  };


  class __array_type_info : public std::type_info
  {
  public:
    explicit
    __array_type_info(const char* __n) : std::type_info(__n) { }

    virtual
    ~__array_type_info();
  };


  class __function_type_info : public std::type_info
  {
  public:
    explicit
    __function_type_info(const char* __n) : std::type_info(__n) { }

    virtual
    ~__function_type_info();

  protected:

    virtual bool
    __is_function_p() const;
  };


  class __enum_type_info : public std::type_info
  {
  public:
    explicit
    __enum_type_info(const char* __n) : std::type_info(__n) { }

    virtual
    ~__enum_type_info();
  };


  class __pbase_type_info : public std::type_info
  {
  public:
    unsigned int __flags;
    const std::type_info* __pointee;

    explicit
    __pbase_type_info(const char* __n, int __quals,
        const std::type_info* __type)
    : std::type_info(__n), __flags(__quals), __pointee(__type)
    { }

    virtual
    ~__pbase_type_info();


    enum __masks
      {
 __const_mask = 0x1,
 __volatile_mask = 0x2,
 __restrict_mask = 0x4,
 __incomplete_mask = 0x8,
 __incomplete_class_mask = 0x10,
 __transaction_safe_mask = 0x20,
 __noexcept_mask = 0x40
      };

  protected:
    __pbase_type_info(const __pbase_type_info&);

    __pbase_type_info&
    operator=(const __pbase_type_info&);


    virtual bool
    __do_catch(const std::type_info* __thr_type, void** __thr_obj,
        unsigned int __outer) const;

    inline virtual bool
    __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj,
      unsigned __outer) const;
  };

  inline bool __pbase_type_info::
  __pointer_catch (const __pbase_type_info *thrown_type,
     void **thr_obj,
     unsigned outer) const
  {
    return __pointee->__do_catch (thrown_type->__pointee, thr_obj, outer + 2);
  }


  class __pointer_type_info : public __pbase_type_info
  {
  public:
    explicit
    __pointer_type_info(const char* __n, int __quals,
   const std::type_info* __type)
    : __pbase_type_info (__n, __quals, __type) { }


    virtual
    ~__pointer_type_info();

  protected:

    virtual bool
    __is_pointer_p() const;

    virtual bool
    __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj,
      unsigned __outer) const;
  };

  class __class_type_info;


  class __pointer_to_member_type_info : public __pbase_type_info
  {
  public:
    __class_type_info* __context;

    explicit
    __pointer_to_member_type_info(const char* __n, int __quals,
      const std::type_info* __type,
      __class_type_info* __klass)
    : __pbase_type_info(__n, __quals, __type), __context(__klass) { }

    virtual
    ~__pointer_to_member_type_info();

  protected:
    __pointer_to_member_type_info(const __pointer_to_member_type_info&);

    __pointer_to_member_type_info&
    operator=(const __pointer_to_member_type_info&);


    virtual bool
    __pointer_catch(const __pbase_type_info* __thr_type, void** __thr_obj,
      unsigned __outer) const;
  };


  class __base_class_type_info
  {
  public:
    const __class_type_info* __base_type;



    long __offset_flags;


    enum __offset_flags_masks
      {
 __virtual_mask = 0x1,
 __public_mask = 0x2,
 __hwm_bit = 2,
 __offset_shift = 8
      };


    bool
    __is_virtual_p() const
    { return __offset_flags & __virtual_mask; }

    bool
    __is_public_p() const
    { return __offset_flags & __public_mask; }

    ptrdiff_t
    __offset() const
    {



      return static_cast<ptrdiff_t>(__offset_flags) >> __offset_shift;
    }
  };


  class __class_type_info : public std::type_info
  {
  public:
    explicit
    __class_type_info (const char *__n) : type_info(__n) { }

    virtual
    ~__class_type_info ();






    enum __sub_kind
      {

 __unknown = 0,



 __not_contained,


 __contained_ambig,


 __contained_virtual_mask = __base_class_type_info::__virtual_mask,


 __contained_public_mask = __base_class_type_info::__public_mask,


 __contained_mask = 1 << __base_class_type_info::__hwm_bit,

 __contained_private = __contained_mask,
 __contained_public = __contained_mask | __contained_public_mask
      };

    struct __upcast_result;
    struct __dyncast_result;

  protected:

    virtual bool
    __do_upcast(const __class_type_info* __dst_type, void**__obj_ptr) const;

    virtual bool
    __do_catch(const type_info* __thr_type, void** __thr_obj,
        unsigned __outer) const;

  public:


    virtual bool
    __do_upcast(const __class_type_info* __dst, const void* __obj,
  __upcast_result& __restrict __result) const;







    inline __sub_kind
    __find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
        const __class_type_info* __src_type,
        const void* __src_ptr) const;
# 486 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cxxabi.h" 3
    virtual bool
    __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path,
   const __class_type_info* __dst_type, const void* __obj_ptr,
   const __class_type_info* __src_type, const void* __src_ptr,
   __dyncast_result& __result) const;





    virtual __sub_kind
    __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
    const __class_type_info* __src_type,
    const void* __src_ptr) const;
  };


  class __si_class_type_info : public __class_type_info
  {
  public:
    const __class_type_info* __base_type;

    explicit
    __si_class_type_info(const char *__n, const __class_type_info *__base)
    : __class_type_info(__n), __base_type(__base) { }

    virtual
    ~__si_class_type_info();

  protected:
    __si_class_type_info(const __si_class_type_info&);

    __si_class_type_info&
    operator=(const __si_class_type_info&);


    virtual bool
    __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path,
   const __class_type_info* __dst_type, const void* __obj_ptr,
   const __class_type_info* __src_type, const void* __src_ptr,
   __dyncast_result& __result) const;

    virtual __sub_kind
    __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
    const __class_type_info* __src_type,
    const void* __sub_ptr) const;

    virtual bool
    __do_upcast(const __class_type_info*__dst, const void*__obj,
  __upcast_result& __restrict __result) const;
  };


  class __vmi_class_type_info : public __class_type_info
  {
  public:
    unsigned int __flags;
    unsigned int __base_count;




    __base_class_type_info __base_info[1];

    explicit
    __vmi_class_type_info(const char* __n, int ___flags)
    : __class_type_info(__n), __flags(___flags), __base_count(0) { }

    virtual
    ~__vmi_class_type_info();


    enum __flags_masks
      {
 __non_diamond_repeat_mask = 0x1,
 __diamond_shaped_mask = 0x2,
 __flags_unknown_mask = 0x10
      };

  protected:

    virtual bool
    __do_dyncast(ptrdiff_t __src2dst, __sub_kind __access_path,
   const __class_type_info* __dst_type, const void* __obj_ptr,
   const __class_type_info* __src_type, const void* __src_ptr,
   __dyncast_result& __result) const;

    virtual __sub_kind
    __do_find_public_src(ptrdiff_t __src2dst, const void* __obj_ptr,
    const __class_type_info* __src_type,
    const void* __src_ptr) const;

    virtual bool
    __do_upcast(const __class_type_info* __dst, const void* __obj,
  __upcast_result& __restrict __result) const;
  };


  struct __cxa_exception;
  struct __cxa_refcounted_exception;
  struct __cxa_dependent_exception;
  struct __cxa_eh_globals;

  extern "C"
  {
# 599 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cxxabi.h" 3
  void*
  __dynamic_cast(const void* __src_ptr,
   const __class_type_info* __src_type,
   const __class_type_info* __dst_type,
   ptrdiff_t __src2dst);
# 612 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cxxabi.h" 3
  __cxa_eh_globals*
  __cxa_get_globals() noexcept __attribute__ ((__const__));

  __cxa_eh_globals*
  __cxa_get_globals_fast() noexcept __attribute__ ((__const__));


  void
  __cxa_free_exception(void*) noexcept;


  void
  __cxa_throw(void*, std::type_info*, void ( *) (void *))
  __attribute__((__noreturn__));


  void*
  __cxa_get_exception_ptr(void*) noexcept __attribute__ ((__pure__));

  void*
  __cxa_begin_catch(void*) noexcept;

  void
  __cxa_end_catch();

  void
  __cxa_rethrow() __attribute__((__noreturn__));



  std::type_info*
  __cxa_current_exception_type() noexcept __attribute__ ((__pure__));




  __cxa_dependent_exception*
  __cxa_allocate_dependent_exception() noexcept;


  void
  __cxa_free_dependent_exception(__cxa_dependent_exception*) noexcept;

  }



  class __foreign_exception
  {
    virtual ~__foreign_exception() throw();
    virtual void __pure_dummy() = 0;
  };

}
# 687 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cxxabi.h" 3
namespace abi = __cxxabiv1;

namespace __gnu_cxx
{
# 704 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cxxabi.h" 3
  class recursive_init_error: public std::exception
  {
  public:
    recursive_init_error() noexcept;
    virtual ~recursive_init_error() noexcept;
  };
}


#pragma GCC visibility pop
# 33 "/usr/include/boost/core/demangle.hpp" 2 3 4






# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdlib" 1 3 4
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdlib" 3
# 40 "/usr/include/boost/core/demangle.hpp" 2 3 4




namespace boost
{

namespace core
{

inline char const * demangle_alloc( char const * name ) noexcept;
inline void demangle_free( char const * name ) noexcept;

class scoped_demangled_name
{
private:
    char const * m_p;

public:
    explicit scoped_demangled_name( char const * name ) noexcept :
        m_p( demangle_alloc( name ) )
    {
    }

    ~scoped_demangled_name() noexcept
    {
        demangle_free( m_p );
    }

    char const * get() const noexcept
    {
        return m_p;
    }

    scoped_demangled_name( scoped_demangled_name const& ) = delete;
    scoped_demangled_name& operator= ( scoped_demangled_name const& ) = delete;
};




inline char const * demangle_alloc( char const * name ) noexcept
{
    int status = 0;
    std::size_t size = 0;
    return abi::__cxa_demangle( name, __null, &size, &status );
}

inline void demangle_free( char const * name ) noexcept
{
    std::free( const_cast< char* >( name ) );
}

inline std::string demangle( char const * name )
{
    scoped_demangled_name demangled_name( name );
    char const * p = demangled_name.get();
    if( !p )
        p = name;
    return p;
}
# 120 "/usr/include/boost/core/demangle.hpp" 3 4
}

}
# 35 "/usr/include/boost/type_index/stl_type_index.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/conditional.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/conditional.hpp" 3 4
namespace boost {

template <bool b, class T, class U> struct conditional { typedef T type; };
template <class T, class U> struct conditional<false, T, U> { typedef U type; };



   template <bool b, class T, class U> using conditional_t = typename conditional<b, T, U>::type;



}
# 36 "/usr/include/boost/type_index/stl_type_index.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/is_const.hpp" 1 3 4
# 27 "/usr/include/boost/type_traits/is_const.hpp" 3 4
namespace boost {
# 36 "/usr/include/boost/type_traits/is_const.hpp" 3 4
   template <class T>
   struct is_const : public false_type {};
   template <class T> struct is_const<T const> : public true_type{};
   template <class T, std::size_t N> struct is_const<T const[N]> : public true_type{};
   template <class T> struct is_const<T const[]> : public true_type{};



}
# 37 "/usr/include/boost/type_index/stl_type_index.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/is_reference.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/is_reference.hpp" 3 4
# 1 "/usr/include/boost/type_traits/is_lvalue_reference.hpp" 1 3 4
# 26 "/usr/include/boost/type_traits/is_lvalue_reference.hpp" 3 4
namespace boost {





   template <class T> struct is_lvalue_reference : public false_type{};
   template <class T> struct is_lvalue_reference<T&> : public true_type{};
# 47 "/usr/include/boost/type_traits/is_lvalue_reference.hpp" 3 4
}
# 16 "/usr/include/boost/type_traits/is_reference.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/is_rvalue_reference.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/is_rvalue_reference.hpp" 3 4
namespace boost {

template <class T> struct is_rvalue_reference : public false_type {};

template <class T> struct is_rvalue_reference<T&&> : public true_type {};


}
# 17 "/usr/include/boost/type_traits/is_reference.hpp" 2 3 4

namespace boost {

template <class T> struct is_reference
   : public
   integral_constant<
      bool,
      ::boost::is_lvalue_reference<T>::value || ::boost::is_rvalue_reference<T>::value>
{};

}
# 38 "/usr/include/boost/type_index/stl_type_index.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/is_volatile.hpp" 1 3 4
# 27 "/usr/include/boost/type_traits/is_volatile.hpp" 3 4
namespace boost {
# 36 "/usr/include/boost/type_traits/is_volatile.hpp" 3 4
   template <class T>
   struct is_volatile : public false_type {};
   template <class T> struct is_volatile<T volatile> : public true_type{};
   template <class T, std::size_t N> struct is_volatile<T volatile[N]> : public true_type{};
   template <class T> struct is_volatile<T volatile[]> : public true_type{};



}
# 39 "/usr/include/boost/type_index/stl_type_index.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/remove_cv.hpp" 1 3 4
# 18 "/usr/include/boost/type_traits/remove_cv.hpp" 3 4
namespace boost {


template <class T> struct remove_cv{ typedef T type; };
template <class T> struct remove_cv<T const>{ typedef T type; };
template <class T> struct remove_cv<T volatile>{ typedef T type; };
template <class T> struct remove_cv<T const volatile>{ typedef T type; };


template <class T, std::size_t N> struct remove_cv<T const[N]>{ typedef T type[N]; };
template <class T, std::size_t N> struct remove_cv<T const volatile[N]>{ typedef T type[N]; };
template <class T, std::size_t N> struct remove_cv<T volatile[N]>{ typedef T type[N]; };

template <class T> struct remove_cv<T const[]>{ typedef T type[]; };
template <class T> struct remove_cv<T const volatile[]>{ typedef T type[]; };
template <class T> struct remove_cv<T volatile[]>{ typedef T type[]; };





   template <class T> using remove_cv_t = typename remove_cv<T>::type;



}
# 40 "/usr/include/boost/type_index/stl_type_index.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/remove_reference.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/remove_reference.hpp" 3 4
namespace boost {


namespace detail{




template <class T>
struct remove_rvalue_ref
{
   typedef T type;
};

template <class T>
struct remove_rvalue_ref<T&&>
{
   typedef T type;
};


}

template <class T> struct remove_reference{ typedef typename boost::detail::remove_rvalue_ref<T>::type type; };
template <class T> struct remove_reference<T&>{ typedef T type; };
# 53 "/usr/include/boost/type_traits/remove_reference.hpp" 3 4
   template <class T> using remove_reference_t = typename remove_reference<T>::type;



}
# 41 "/usr/include/boost/type_index/stl_type_index.hpp" 2 3 4






# 1 "/usr/include/boost/container_hash/hash.hpp" 1 3 4
# 14 "/usr/include/boost/container_hash/hash.hpp" 3 4
# 1 "/usr/include/boost/container_hash/detail/requires_cxx11.hpp" 1 3 4
# 15 "/usr/include/boost/container_hash/hash.hpp" 2 3 4
# 1 "/usr/include/boost/container_hash/is_range.hpp" 1 3 4
# 10 "/usr/include/boost/container_hash/is_range.hpp" 3 4
# 1 "/usr/include/boost/type_traits/is_integral.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/is_integral.hpp" 3 4
namespace boost {






template <class T> struct is_integral : public false_type {};
template <class T> struct is_integral<const T> : public is_integral<T> {};
template <class T> struct is_integral<volatile const T> : public is_integral<T>{};
template <class T> struct is_integral<volatile T> : public is_integral<T>{};




template<> struct is_integral<unsigned char> : public true_type {};
template<> struct is_integral<unsigned short> : public true_type{};
template<> struct is_integral<unsigned int> : public true_type{};
template<> struct is_integral<unsigned long> : public true_type{};

template<> struct is_integral<signed char> : public true_type{};
template<> struct is_integral<short> : public true_type{};
template<> struct is_integral<int> : public true_type{};
template<> struct is_integral<long> : public true_type{};

template<> struct is_integral<char> : public true_type{};
template<> struct is_integral<bool> : public true_type{};





template<> struct is_integral<wchar_t> : public true_type{};
# 67 "/usr/include/boost/type_traits/is_integral.hpp" 3 4
template<> struct is_integral< ::boost::ulong_long_type> : public true_type{};
template<> struct is_integral< ::boost::long_long_type> : public true_type{};






template<> struct is_integral<boost::int128_type> : public true_type{};
template<> struct is_integral<boost::uint128_type> : public true_type{};


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


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


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




}
# 11 "/usr/include/boost/container_hash/is_range.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/declval.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/declval.hpp" 3 4
# 1 "/usr/include/boost/type_traits/add_rvalue_reference.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/add_rvalue_reference.hpp" 3 4
# 1 "/usr/include/boost/type_traits/is_void.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/is_void.hpp" 3 4
namespace boost {

template <class T>
struct is_void : public false_type {};

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

}
# 16 "/usr/include/boost/type_traits/add_rvalue_reference.hpp" 2 3 4
# 31 "/usr/include/boost/type_traits/add_rvalue_reference.hpp" 3 4
namespace boost {

namespace type_traits_detail {

    template <typename T, bool b>
    struct add_rvalue_reference_helper
    { typedef T type; };


    template <typename T>
    struct add_rvalue_reference_helper<T, true>
    {
        typedef T&& type;
    };


    template <typename T>
    struct add_rvalue_reference_imp
    {
       typedef typename boost::type_traits_detail::add_rvalue_reference_helper
                  <T, (is_void<T>::value == false && is_reference<T>::value == false) >::type type;
    };

}

template <class T> struct add_rvalue_reference
{
   typedef typename boost::type_traits_detail::add_rvalue_reference_imp<T>::type type;
};



   template <class T> using add_rvalue_reference_t = typename add_rvalue_reference<T>::type;



}
# 16 "/usr/include/boost/type_traits/declval.hpp" 2 3 4
# 37 "/usr/include/boost/type_traits/declval.hpp" 3 4
namespace boost {

    template <typename T>
    typename add_rvalue_reference<T>::type declval() noexcept;

}
# 12 "/usr/include/boost/container_hash/is_range.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/is_same.hpp" 1 3 4
# 26 "/usr/include/boost/type_traits/is_same.hpp" 3 4
namespace boost {


   template <class T, class U> struct is_same : public false_type {};
   template <class T> struct is_same<T,T> : public true_type {};







}
# 13 "/usr/include/boost/container_hash/is_range.hpp" 2 3 4





namespace boost
{


namespace hash_detail
{

template<class T, class It>
    integral_constant< bool, !is_same<typename remove_cv<T>::type, typename std::iterator_traits<It>::value_type>::value >
        is_range_check( It first, It last );

template<class T> decltype( is_range_check<T>( declval<T const&>().begin(), declval<T const&>().end() ) ) is_range_( int );
template<class T> false_type is_range_( ... );

}

namespace container_hash
{

template<class T> struct is_range: decltype( hash_detail::is_range_<T>( 0 ) )
{
};

}
# 72 "/usr/include/boost/container_hash/is_range.hpp" 3 4
}
# 16 "/usr/include/boost/container_hash/hash.hpp" 2 3 4
# 1 "/usr/include/boost/container_hash/is_contiguous_range.hpp" 1 3 4
# 21 "/usr/include/boost/container_hash/is_contiguous_range.hpp" 3 4
namespace boost
{
namespace hash_detail
{

template<class It, class T, class S>
    integral_constant< bool, is_same<typename std::iterator_traits<It>::value_type, T>::value && is_integral<S>::value >
        is_contiguous_range_check( It first, It last, T const*, T const*, S );

template<class T> decltype( is_contiguous_range_check( declval<T const&>().begin(), declval<T const&>().end(), declval<T const&>().data(), declval<T const&>().data() + declval<T const&>().size(), declval<T const&>().size() ) ) is_contiguous_range_( int );
template<class T> false_type is_contiguous_range_( ... );

template<class T> struct is_contiguous_range: decltype( hash_detail::is_contiguous_range_<T>( 0 ) )
{
};

}

namespace container_hash
{

template<class T> struct is_contiguous_range: integral_constant< bool, is_range<T>::value && hash_detail::is_contiguous_range<T>::value >
{
};

}
}
# 17 "/usr/include/boost/container_hash/hash.hpp" 2 3 4
# 1 "/usr/include/boost/container_hash/is_unordered_range.hpp" 1 3 4
# 12 "/usr/include/boost/container_hash/is_unordered_range.hpp" 3 4
namespace boost
{
namespace hash_detail
{

template<class T, class E = true_type> struct has_hasher_: false_type
{
};

template<class T> struct has_hasher_< T, integral_constant< bool,
        is_same<typename T::hasher, typename T::hasher>::value
    > >: true_type
{
};

}

namespace container_hash
{

template<class T> struct is_unordered_range: integral_constant< bool, is_range<T>::value && hash_detail::has_hasher_<T>::value >
{
};

}
}
# 18 "/usr/include/boost/container_hash/hash.hpp" 2 3 4
# 1 "/usr/include/boost/container_hash/is_described_class.hpp" 1 3 4








# 1 "/usr/include/boost/type_traits/is_union.hpp" 1 3 4
# 17 "/usr/include/boost/type_traits/is_union.hpp" 3 4
namespace boost {


template <class T> struct is_union : public integral_constant<bool, __is_union(T)> {};




template <class T> struct is_union<T const> : public is_union<T>{};
template <class T> struct is_union<T volatile const> : public is_union<T>{};
template <class T> struct is_union<T volatile> : public is_union<T>{};

}
# 10 "/usr/include/boost/container_hash/is_described_class.hpp" 2 3 4
# 1 "/usr/include/boost/describe/bases.hpp" 1 3 4







# 1 "/usr/include/boost/describe/modifiers.hpp" 1 3 4







# 1 "/usr/include/boost/describe/detail/config.hpp" 1 3 4
# 9 "/usr/include/boost/describe/modifiers.hpp" 2 3 4

namespace boost
{
namespace describe
{

enum modifiers
{
    mod_public = 1,
    mod_protected = 2,
    mod_private = 4,
    mod_virtual = 8,
    mod_static = 16,
    mod_function = 32,
    mod_any_member = 64,
    mod_inherited = 128,
    mod_hidden = 256
};

constexpr modifiers mod_any_access = static_cast<modifiers>( mod_public | mod_protected | mod_private );

}
}
# 9 "/usr/include/boost/describe/bases.hpp" 2 3 4
# 1 "/usr/include/boost/describe/detail/void_t.hpp" 1 3 4
# 12 "/usr/include/boost/describe/detail/void_t.hpp" 3 4
namespace boost
{
namespace describe
{
namespace detail
{

template<class...> struct make_void
{
    using type = void;
};

template<class... T> using void_t = typename make_void<T...>::type;

}
}
}
# 10 "/usr/include/boost/describe/bases.hpp" 2 3 4




# 1 "/usr/include/boost/mp11/algorithm.hpp" 1 3 4
# 11 "/usr/include/boost/mp11/algorithm.hpp" 3 4
# 1 "/usr/include/boost/mp11/list.hpp" 1 3 4
# 11 "/usr/include/boost/mp11/list.hpp" 3 4
# 1 "/usr/include/boost/mp11/integral.hpp" 1 3 4
# 11 "/usr/include/boost/mp11/integral.hpp" 3 4
# 1 "/usr/include/boost/mp11/version.hpp" 1 3 4
# 12 "/usr/include/boost/mp11/integral.hpp" 2 3 4
# 1 "/usr/include/boost/mp11/detail/mp_value.hpp" 1 3 4







# 1 "/usr/include/boost/mp11/detail/config.hpp" 1 3 4
# 9 "/usr/include/boost/mp11/detail/mp_value.hpp" 2 3 4




namespace boost
{
namespace mp11
{

template<auto A> using mp_value = std::integral_constant<decltype(A), A>;

}
}
# 13 "/usr/include/boost/mp11/integral.hpp" 2 3 4



namespace boost
{
namespace mp11
{


template<bool B> using mp_bool = std::integral_constant<bool, B>;

using mp_true = mp_bool<true>;
using mp_false = mp_bool<false>;


template<class T> using mp_to_bool = mp_bool<static_cast<bool>( T::value )>;


template<class T> using mp_not = mp_bool< !T::value >;


template<int I> using mp_int = std::integral_constant<int, I>;


template<std::size_t N> using mp_size_t = std::integral_constant<std::size_t, N>;

}
}
# 12 "/usr/include/boost/mp11/list.hpp" 2 3 4
# 1 "/usr/include/boost/mp11/detail/mp_list.hpp" 1 3 4
# 11 "/usr/include/boost/mp11/detail/mp_list.hpp" 3 4
namespace boost
{
namespace mp11
{


template<class... T> struct mp_list
{
};

}
}
# 13 "/usr/include/boost/mp11/list.hpp" 2 3 4
# 1 "/usr/include/boost/mp11/detail/mp_list_v.hpp" 1 3 4
# 10 "/usr/include/boost/mp11/detail/mp_list_v.hpp" 3 4
namespace boost
{
namespace mp11
{




template<auto... A> struct mp_list_v
{
};



}
}
# 14 "/usr/include/boost/mp11/list.hpp" 2 3 4
# 1 "/usr/include/boost/mp11/detail/mp_is_list.hpp" 1 3 4
# 13 "/usr/include/boost/mp11/detail/mp_is_list.hpp" 3 4
namespace boost
{
namespace mp11
{


namespace detail
{

template<class L> struct mp_is_list_impl
{
    using type = mp_false;
};

template<template<class...> class L, class... T> struct mp_is_list_impl<L<T...>>
{
    using type = mp_true;
};

}

template<class L> using mp_is_list = typename detail::mp_is_list_impl<L>::type;

}
}
# 15 "/usr/include/boost/mp11/list.hpp" 2 3 4
# 1 "/usr/include/boost/mp11/detail/mp_is_value_list.hpp" 1 3 4
# 11 "/usr/include/boost/mp11/detail/mp_is_value_list.hpp" 3 4
namespace boost
{
namespace mp11
{


namespace detail
{

template<class L> struct mp_is_value_list_impl
{
    using type = mp_false;
};



template<template<auto...> class L, auto... A> struct mp_is_value_list_impl<L<A...>>
{
    using type = mp_true;
};



}

template<class L> using mp_is_value_list = typename detail::mp_is_value_list_impl<L>::type;

}
}
# 16 "/usr/include/boost/mp11/list.hpp" 2 3 4
# 1 "/usr/include/boost/mp11/detail/mp_front.hpp" 1 3 4
# 14 "/usr/include/boost/mp11/detail/mp_front.hpp" 3 4
namespace boost
{
namespace mp11
{


namespace detail
{

template<class L> struct mp_front_impl
{


};

template<template<class...> class L, class T1, class... T> struct mp_front_impl<L<T1, T...>>
{
    using type = T1;
};



template<template<auto...> class L, auto A1, auto... A> struct mp_front_impl<L<A1, A...>>
{
    using type = mp_value<A1>;
};



}

template<class L> using mp_front = typename detail::mp_front_impl<L>::type;

}
}
# 17 "/usr/include/boost/mp11/list.hpp" 2 3 4
# 1 "/usr/include/boost/mp11/detail/mp_rename.hpp" 1 3 4
# 11 "/usr/include/boost/mp11/detail/mp_rename.hpp" 3 4
# 1 "/usr/include/boost/mp11/detail/mp_defer.hpp" 1 3 4
# 11 "/usr/include/boost/mp11/detail/mp_defer.hpp" 3 4
namespace boost
{
namespace mp11
{


namespace detail
{

template<bool C, class T, class... E> struct mp_if_c_impl
{
};

template<class T, class... E> struct mp_if_c_impl<true, T, E...>
{
    using type = T;
};

template<class T, class E> struct mp_if_c_impl<false, T, E>
{
    using type = E;
};

}

template<bool C, class T, class... E> using mp_if_c = typename detail::mp_if_c_impl<C, T, E...>::type;
template<class C, class T, class... E> using mp_if = typename detail::mp_if_c_impl<static_cast<bool>(C::value), T, E...>::type;
# 63 "/usr/include/boost/mp11/detail/mp_defer.hpp" 3 4
namespace detail
{

template<template<class...> class F, class... T> struct mp_valid_impl
{
    template<template<class...> class G, class = G<T...>> static mp_true check(int);
    template<template<class...> class> static mp_false check(...);

    using type = decltype(check<F>(0));
};

}

template<template<class...> class F, class... T> using mp_valid = typename detail::mp_valid_impl<F, T...>::type;



template<class Q, class... T> using mp_valid_q = mp_valid<Q::template fn, T...>;


namespace detail
{

template<template<class...> class F, class... T> struct mp_defer_impl
{
    using type = F<T...>;
};

struct mp_no_type
{
};
# 104 "/usr/include/boost/mp11/detail/mp_defer.hpp" 3 4
}







template<template<class...> class F, class... T> using mp_defer = mp_if<mp_valid<F, T...>, detail::mp_defer_impl<F, T...>, detail::mp_no_type>;



}
}
# 12 "/usr/include/boost/mp11/detail/mp_rename.hpp" 2 3 4



namespace boost
{
namespace mp11
{


namespace detail
{

template<class L, template<class...> class B> struct mp_rename_impl
{

};

template<template<class...> class L, class... T, template<class...> class B> struct mp_rename_impl<L<T...>, B>: mp_defer<B, T...>
{
};



template<template<auto...> class L, auto... A, template<class...> class B> struct mp_rename_impl<L<A...>, B>: mp_defer<B, mp_value<A>...>
{
};



}

template<class L, template<class...> class B> using mp_rename = typename detail::mp_rename_impl<L, B>::type;


template<template<class...> class F, class L> using mp_apply = typename detail::mp_rename_impl<L, F>::type;


template<class Q, class L> using mp_apply_q = typename detail::mp_rename_impl<L, Q::template fn>::type;

}
}
# 18 "/usr/include/boost/mp11/list.hpp" 2 3 4
# 1 "/usr/include/boost/mp11/detail/mp_append.hpp" 1 3 4
# 11 "/usr/include/boost/mp11/detail/mp_append.hpp" 3 4
# 1 "/usr/include/boost/mp11/detail/mp_count.hpp" 1 3 4
# 12 "/usr/include/boost/mp11/detail/mp_count.hpp" 3 4
# 1 "/usr/include/boost/mp11/detail/mp_plus.hpp" 1 3 4
# 14 "/usr/include/boost/mp11/detail/mp_plus.hpp" 3 4
namespace boost
{
namespace mp11
{


namespace detail
{
# 36 "/usr/include/boost/mp11/detail/mp_plus.hpp" 3 4
template<class... T> struct mp_plus_impl;

template<> struct mp_plus_impl<>
{
    using type = std::integral_constant<int, 0>;
};
# 61 "/usr/include/boost/mp11/detail/mp_plus.hpp" 3 4
template<class T1, class... T> struct mp_plus_impl<T1, T...>
{
    static const auto _v = T1::value + mp_plus_impl<T...>::type::value;
    using type = std::integral_constant<typename std::remove_const<decltype(_v)>::type, _v>;
};

template<class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class... T> struct mp_plus_impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T...>
{
    static const auto _v = T1::value + T2::value + T3::value + T4::value + T5::value + T6::value + T7::value + T8::value + T9::value + T10::value + mp_plus_impl<T...>::type::value;
    using type = std::integral_constant<typename std::remove_const<decltype(_v)>::type, _v>;
};





}

template<class... T> using mp_plus = typename detail::mp_plus_impl<T...>::type;

}
}
# 13 "/usr/include/boost/mp11/detail/mp_count.hpp" 2 3 4


namespace boost
{
namespace mp11
{


namespace detail
{



constexpr std::size_t cx_plus()
{
    return 0;
}

template<class T1, class... T> constexpr std::size_t cx_plus(T1 t1, T... t)
{
    return static_cast<std::size_t>(t1) + cx_plus(t...);
}

template<class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class... T>
constexpr std::size_t cx_plus(T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9, T10 t10, T... t)
{
    return static_cast<std::size_t>(t1 + t2 + t3 + t4 + t5 + t6 + t7 + t8 + t9 + t10) + cx_plus(t...);
}



template<class L, class V> struct mp_count_impl;



template<class V, class... T> constexpr std::size_t cx_count()
{
    constexpr bool a[] = { false, std::is_same<T, V>::value... };

    std::size_t r = 0;

    for( std::size_t i = 1; i < sizeof...(T) + 1; ++i )
    {
        r += a[ i ];
    }

    return r;
}

template<template<class...> class L, class... T, class V> struct mp_count_impl<L<T...>, V>
{
    using type = mp_size_t<cx_count<V, T...>()>;
};
# 83 "/usr/include/boost/mp11/detail/mp_count.hpp" 3 4
}

template<class L, class V> using mp_count = typename detail::mp_count_impl<L, V>::type;


namespace detail
{

template<class L, template<class...> class P> struct mp_count_if_impl;



template<template<class...> class P, class... T> constexpr std::size_t cx_count_if()
{
    constexpr bool a[] = { false, static_cast<bool>( P<T>::value )... };

    std::size_t r = 0;

    for( std::size_t i = 1; i < sizeof...(T) + 1; ++i )
    {
        r += a[ i ];
    }

    return r;
}

template<template<class...> class L, class... T, template<class...> class P> struct mp_count_if_impl<L<T...>, P>
{
    using type = mp_size_t<cx_count_if<P, T...>()>;
};
# 139 "/usr/include/boost/mp11/detail/mp_count.hpp" 3 4
}

template<class L, template<class...> class P> using mp_count_if = typename detail::mp_count_if_impl<L, P>::type;
template<class L, class Q> using mp_count_if_q = mp_count_if<L, Q::template fn>;

}
}
# 12 "/usr/include/boost/mp11/detail/mp_append.hpp" 2 3 4



# 1 "/usr/include/boost/mp11/utility.hpp" 1 3 4
# 13 "/usr/include/boost/mp11/utility.hpp" 3 4
# 1 "/usr/include/boost/mp11/detail/mp_fold.hpp" 1 3 4
# 14 "/usr/include/boost/mp11/detail/mp_fold.hpp" 3 4
namespace boost
{
namespace mp11
{


namespace detail
{

template<class L, class V, template<class...> class F> struct mp_fold_impl
{

};
# 38 "/usr/include/boost/mp11/detail/mp_fold.hpp" 3 4
template<template<class...> class L, class V, template<class...> class F> struct mp_fold_impl<L<>, V, F>
{
    using type = V;
};





template<class V, template<class...> class F> struct mp_fold_Q1
{
    template<class T1>
        using fn = F<V, T1>;
};

template<class V, template<class...> class F> struct mp_fold_Q2
{
    template<class T1, class T2>
        using fn = F<F<V, T1>, T2>;
};

template<class V, template<class...> class F> struct mp_fold_Q3
{
    template<class T1, class T2, class T3>
        using fn = F<F<F<V, T1>, T2>, T3>;
};

template<class V, template<class...> class F> struct mp_fold_Q4
{
    template<class T1, class T2, class T3, class T4>
        using fn = F<F<F<F<V, T1>, T2>, T3>, T4>;
};

template<class V, template<class...> class F> struct mp_fold_Q5
{
    template<class T1, class T2, class T3, class T4, class T5>
        using fn = F<F<F<F<F<V, T1>, T2>, T3>, T4>, T5>;
};

template<class V, template<class...> class F> struct mp_fold_Q6
{
    template<class T1, class T2, class T3, class T4, class T5, class T6>
        using fn = F<F<F<F<F<F<V, T1>, T2>, T3>, T4>, T5>, T6>;
};

template<class V, template<class...> class F> struct mp_fold_Q7
{
    template<class T1, class T2, class T3, class T4, class T5, class T6, class T7>
        using fn = F<F<F<F<F<F<F<V, T1>, T2>, T3>, T4>, T5>, T6>, T7>;
};

template<class V, template<class...> class F> struct mp_fold_Q8
{
    template<class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
        using fn = F<F<F<F<F<F<F<F<V, T1>, T2>, T3>, T4>, T5>, T6>, T7>, T8>;
};

template<class V, template<class...> class F> struct mp_fold_Q9
{
    template<class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
        using fn = F<F<F<F<F<F<F<F<F<V, T1>, T2>, T3>, T4>, T5>, T6>, T7>, T8>, T9>;
};



template<template<class...> class L, class T1, class V, template<class...> class F>
struct mp_fold_impl<L<T1>, V, F>: mp_defer<mp_fold_Q1<V, F>::template fn, T1>
{
};

template<template<class...> class L, class T1, class T2, class V, template<class...> class F>
struct mp_fold_impl<L<T1, T2>, V, F>: mp_defer<mp_fold_Q2<V, F>::template fn, T1, T2>
{
};

template<template<class...> class L, class T1, class T2, class T3, class V, template<class...> class F>
struct mp_fold_impl<L<T1, T2, T3>, V, F>: mp_defer<mp_fold_Q3<V, F>::template fn, T1, T2, T3>
{
};

template<template<class...> class L, class T1, class T2, class T3, class T4, class V, template<class...> class F>
struct mp_fold_impl<L<T1, T2, T3, T4>, V, F>: mp_defer<mp_fold_Q4<V, F>::template fn, T1, T2, T3, T4>
{
};

template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class V, template<class...> class F>
struct mp_fold_impl<L<T1, T2, T3, T4, T5>, V, F>: mp_defer<mp_fold_Q5<V, F>::template fn, T1, T2, T3, T4, T5>
{
};

template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class V, template<class...> class F>
struct mp_fold_impl<L<T1, T2, T3, T4, T5, T6>, V, F>: mp_defer<mp_fold_Q6<V, F>::template fn, T1, T2, T3, T4, T5, T6>
{
};

template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class V, template<class...> class F>
struct mp_fold_impl<L<T1, T2, T3, T4, T5, T6, T7>, V, F>: mp_defer<mp_fold_Q7<V, F>::template fn, T1, T2, T3, T4, T5, T6, T7>
{
};

template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class V, template<class...> class F>
struct mp_fold_impl<L<T1, T2, T3, T4, T5, T6, T7, T8>, V, F>: mp_defer<mp_fold_Q8<V, F>::template fn, T1, T2, T3, T4, T5, T6, T7, T8>
{
};

template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class V, template<class...> class F>
struct mp_fold_impl<L<T1, T2, T3, T4, T5, T6, T7, T8, T9>, V, F>: mp_defer<mp_fold_Q9<V, F>::template fn, T1, T2, T3, T4, T5, T6, T7, T8, T9>
{
};



template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class... T, class V, template<class...> class F>
struct mp_fold_impl<L<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T...>, V, F>
{
    using type = typename mp_fold_impl<L<T...>, F<F<F<F<F<F<F<F<F<F<V, T1>, T2>, T3>, T4>, T5>, T6>, T7>, T8>, T9>, T10>, F>::type;
};

}

template<class L, class V, template<class...> class F> using mp_fold = typename detail::mp_fold_impl<L, V, F>::type;
template<class L, class V, class Q> using mp_fold_q = mp_fold<L, V, Q::template fn>;

}
}
# 14 "/usr/include/boost/mp11/utility.hpp" 2 3 4





namespace boost
{
namespace mp11
{


template<class T> struct mp_identity
{
    using type = T;
};


template<class T> using mp_identity_t = typename mp_identity<T>::type;


template<class... T> struct mp_inherit: T... {};







namespace detail
{

template<bool C, class T, template<class...> class F, class... U> struct mp_eval_if_c_impl;

template<class T, template<class...> class F, class... U> struct mp_eval_if_c_impl<true, T, F, U...>
{
    using type = T;
};

template<class T, template<class...> class F, class... U> struct mp_eval_if_c_impl<false, T, F, U...>: mp_defer<F, U...>
{
};

}

template<bool C, class T, template<class...> class F, class... U> using mp_eval_if_c = typename detail::mp_eval_if_c_impl<C, T, F, U...>::type;
template<class C, class T, template<class...> class F, class... U> using mp_eval_if = typename detail::mp_eval_if_c_impl<static_cast<bool>(C::value), T, F, U...>::type;
template<class C, class T, class Q, class... U> using mp_eval_if_q = typename detail::mp_eval_if_c_impl<static_cast<bool>(C::value), T, Q::template fn, U...>::type;


template<class C, class T, template<class...> class F, class... U> using mp_eval_if_not = mp_eval_if<mp_not<C>, T, F, U...>;
template<class C, class T, class Q, class... U> using mp_eval_if_not_q = mp_eval_if<mp_not<C>, T, Q::template fn, U...>;


template<class T, template<class...> class F, class... U> using mp_eval_or = mp_eval_if_not<mp_valid<F, U...>, T, F, U...>;
template<class T, class Q, class... U> using mp_eval_or_q = mp_eval_or<T, Q::template fn, U...>;


template<template<class...> class F, class... T> using mp_valid_and_true = mp_eval_or<mp_false, F, T...>;
template<class Q, class... T> using mp_valid_and_true_q = mp_valid_and_true<Q::template fn, T...>;






namespace detail
{

template<class C, class T, class... E> struct mp_cond_impl;

}

template<class C, class T, class... E> using mp_cond = typename detail::mp_cond_impl<C, T, E...>::type;

namespace detail
{

template<class C, class T, class... E> using mp_cond_ = mp_eval_if<C, T, mp_cond, E...>;

template<class C, class T, class... E> struct mp_cond_impl: mp_defer<mp_cond_, C, T, E...>
{
};

}


template<template<class...> class F> struct mp_quote
{



    template<class... T> using fn = typename mp_defer<F, T...>::type;
};


template<template<class...> class F> struct mp_quote_trait
{
    template<class... T> using fn = typename F<T...>::type;
};
# 132 "/usr/include/boost/mp11/utility.hpp" 3 4
template<class Q, class... T> using mp_invoke_q = typename Q::template fn<T...>;




template<template<class...> class P> struct mp_not_fn
{
    template<class... T> using fn = mp_not< mp_invoke_q<mp_quote<P>, T...> >;
};

template<class Q> using mp_not_fn_q = mp_not_fn<Q::template fn>;


namespace detail
{

template<class L, class Q> using mp_compose_helper = mp_list< mp_apply_q<Q, L> >;

}



template<template<class...> class... F> struct mp_compose
{
    template<class... T> using fn = mp_front< mp_fold<mp_list<mp_quote<F>...>, mp_list<T...>, detail::mp_compose_helper> >;
};



template<class... Q> struct mp_compose_q
{
    template<class... T> using fn = mp_front< mp_fold<mp_list<Q...>, mp_list<T...>, detail::mp_compose_helper> >;
};

}
}
# 16 "/usr/include/boost/mp11/detail/mp_append.hpp" 2 3 4


namespace boost
{
namespace mp11
{



namespace detail
{



template<class... L> struct mp_append_impl;
# 70 "/usr/include/boost/mp11/detail/mp_append.hpp" 3 4
template<class L1 = mp_list<>, class L2 = mp_list<>, class L3 = mp_list<>, class L4 = mp_list<>, class L5 = mp_list<>, class L6 = mp_list<>, class L7 = mp_list<>, class L8 = mp_list<>, class L9 = mp_list<>, class L10 = mp_list<>, class L11 = mp_list<>> struct append_11_impl
{
};

template<
    template<class...> class L1, class... T1,
    template<class...> class L2, class... T2,
    template<class...> class L3, class... T3,
    template<class...> class L4, class... T4,
    template<class...> class L5, class... T5,
    template<class...> class L6, class... T6,
    template<class...> class L7, class... T7,
    template<class...> class L8, class... T8,
    template<class...> class L9, class... T9,
    template<class...> class L10, class... T10,
    template<class...> class L11, class... T11>

struct append_11_impl<L1<T1...>, L2<T2...>, L3<T3...>, L4<T4...>, L5<T5...>, L6<T6...>, L7<T7...>, L8<T8...>, L9<T9...>, L10<T10...>, L11<T11...>>
{
    using type = L1<T1..., T2..., T3..., T4..., T5..., T6..., T7..., T8..., T9..., T10..., T11...>;
};

template<

    class L00 = mp_list<>, class L01 = mp_list<>, class L02 = mp_list<>, class L03 = mp_list<>, class L04 = mp_list<>, class L05 = mp_list<>, class L06 = mp_list<>, class L07 = mp_list<>, class L08 = mp_list<>, class L09 = mp_list<>, class L0A = mp_list<>,
    class L10 = mp_list<>, class L11 = mp_list<>, class L12 = mp_list<>, class L13 = mp_list<>, class L14 = mp_list<>, class L15 = mp_list<>, class L16 = mp_list<>, class L17 = mp_list<>, class L18 = mp_list<>, class L19 = mp_list<>,
    class L20 = mp_list<>, class L21 = mp_list<>, class L22 = mp_list<>, class L23 = mp_list<>, class L24 = mp_list<>, class L25 = mp_list<>, class L26 = mp_list<>, class L27 = mp_list<>, class L28 = mp_list<>, class L29 = mp_list<>,
    class L30 = mp_list<>, class L31 = mp_list<>, class L32 = mp_list<>, class L33 = mp_list<>, class L34 = mp_list<>, class L35 = mp_list<>, class L36 = mp_list<>, class L37 = mp_list<>, class L38 = mp_list<>, class L39 = mp_list<>,
    class L40 = mp_list<>, class L41 = mp_list<>, class L42 = mp_list<>, class L43 = mp_list<>, class L44 = mp_list<>, class L45 = mp_list<>, class L46 = mp_list<>, class L47 = mp_list<>, class L48 = mp_list<>, class L49 = mp_list<>,
    class L50 = mp_list<>, class L51 = mp_list<>, class L52 = mp_list<>, class L53 = mp_list<>, class L54 = mp_list<>, class L55 = mp_list<>, class L56 = mp_list<>, class L57 = mp_list<>, class L58 = mp_list<>, class L59 = mp_list<>,
    class L60 = mp_list<>, class L61 = mp_list<>, class L62 = mp_list<>, class L63 = mp_list<>, class L64 = mp_list<>, class L65 = mp_list<>, class L66 = mp_list<>, class L67 = mp_list<>, class L68 = mp_list<>, class L69 = mp_list<>,
    class L70 = mp_list<>, class L71 = mp_list<>, class L72 = mp_list<>, class L73 = mp_list<>, class L74 = mp_list<>, class L75 = mp_list<>, class L76 = mp_list<>, class L77 = mp_list<>, class L78 = mp_list<>, class L79 = mp_list<>,
    class L80 = mp_list<>, class L81 = mp_list<>, class L82 = mp_list<>, class L83 = mp_list<>, class L84 = mp_list<>, class L85 = mp_list<>, class L86 = mp_list<>, class L87 = mp_list<>, class L88 = mp_list<>, class L89 = mp_list<>,
    class L90 = mp_list<>, class L91 = mp_list<>, class L92 = mp_list<>, class L93 = mp_list<>, class L94 = mp_list<>, class L95 = mp_list<>, class L96 = mp_list<>, class L97 = mp_list<>, class L98 = mp_list<>, class L99 = mp_list<>,
    class LA0 = mp_list<>, class LA1 = mp_list<>, class LA2 = mp_list<>, class LA3 = mp_list<>, class LA4 = mp_list<>, class LA5 = mp_list<>, class LA6 = mp_list<>, class LA7 = mp_list<>, class LA8 = mp_list<>, class LA9 = mp_list<>

> struct append_111_impl
{
    using type = typename append_11_impl<

        typename append_11_impl<L00, L01, L02, L03, L04, L05, L06, L07, L08, L09, L0A>::type,
        typename append_11_impl<mp_list<>, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19>::type,
        typename append_11_impl<mp_list<>, L20, L21, L22, L23, L24, L25, L26, L27, L28, L29>::type,
        typename append_11_impl<mp_list<>, L30, L31, L32, L33, L34, L35, L36, L37, L38, L39>::type,
        typename append_11_impl<mp_list<>, L40, L41, L42, L43, L44, L45, L46, L47, L48, L49>::type,
        typename append_11_impl<mp_list<>, L50, L51, L52, L53, L54, L55, L56, L57, L58, L59>::type,
        typename append_11_impl<mp_list<>, L60, L61, L62, L63, L64, L65, L66, L67, L68, L69>::type,
        typename append_11_impl<mp_list<>, L70, L71, L72, L73, L74, L75, L76, L77, L78, L79>::type,
        typename append_11_impl<mp_list<>, L80, L81, L82, L83, L84, L85, L86, L87, L88, L89>::type,
        typename append_11_impl<mp_list<>, L90, L91, L92, L93, L94, L95, L96, L97, L98, L99>::type,
        typename append_11_impl<mp_list<>, LA0, LA1, LA2, LA3, LA4, LA5, LA6, LA7, LA8, LA9>::type

    >::type;
};

template<

    class L00, class L01, class L02, class L03, class L04, class L05, class L06, class L07, class L08, class L09, class L0A,
    class L10, class L11, class L12, class L13, class L14, class L15, class L16, class L17, class L18, class L19,
    class L20, class L21, class L22, class L23, class L24, class L25, class L26, class L27, class L28, class L29,
    class L30, class L31, class L32, class L33, class L34, class L35, class L36, class L37, class L38, class L39,
    class L40, class L41, class L42, class L43, class L44, class L45, class L46, class L47, class L48, class L49,
    class L50, class L51, class L52, class L53, class L54, class L55, class L56, class L57, class L58, class L59,
    class L60, class L61, class L62, class L63, class L64, class L65, class L66, class L67, class L68, class L69,
    class L70, class L71, class L72, class L73, class L74, class L75, class L76, class L77, class L78, class L79,
    class L80, class L81, class L82, class L83, class L84, class L85, class L86, class L87, class L88, class L89,
    class L90, class L91, class L92, class L93, class L94, class L95, class L96, class L97, class L98, class L99,
    class LA0, class LA1, class LA2, class LA3, class LA4, class LA5, class LA6, class LA7, class LA8, class LA9,
    class... Lr

> struct append_inf_impl
{
    using prefix = typename append_111_impl<

        L00, L01, L02, L03, L04, L05, L06, L07, L08, L09, L0A,
        L10, L11, L12, L13, L14, L15, L16, L17, L18, L19,
        L20, L21, L22, L23, L24, L25, L26, L27, L28, L29,
        L30, L31, L32, L33, L34, L35, L36, L37, L38, L39,
        L40, L41, L42, L43, L44, L45, L46, L47, L48, L49,
        L50, L51, L52, L53, L54, L55, L56, L57, L58, L59,
        L60, L61, L62, L63, L64, L65, L66, L67, L68, L69,
        L70, L71, L72, L73, L74, L75, L76, L77, L78, L79,
        L80, L81, L82, L83, L84, L85, L86, L87, L88, L89,
        L90, L91, L92, L93, L94, L95, L96, L97, L98, L99,
        LA0, LA1, LA2, LA3, LA4, LA5, LA6, LA7, LA8, LA9

    >::type;

    using type = typename mp_append_impl<prefix, Lr...>::type;
};
# 175 "/usr/include/boost/mp11/detail/mp_append.hpp" 3 4
template<class... L> struct mp_append_impl:
    mp_cond<
        mp_bool<(sizeof...(L) > 111)>, mp_quote<append_inf_impl>,
        mp_bool<(sizeof...(L) > 11)>, mp_quote<append_111_impl>,
        mp_true, mp_quote<append_11_impl>
    >::template fn<L...>
{
};





struct append_type_lists
{
    template<class... L> using fn = typename mp_append_impl<L...>::type;
};





template<class... L> struct append_value_impl;

template<class L1 = mp_list_v<>, class L2 = mp_list_v<>, class L3 = mp_list_v<>, class L4 = mp_list_v<>, class L5 = mp_list_v<>, class L6 = mp_list_v<>, class L7 = mp_list_v<>, class L8 = mp_list_v<>, class L9 = mp_list_v<>, class L10 = mp_list_v<>, class L11 = mp_list_v<>> struct append_value_11_impl
{
};

template<
    template<auto...> class L1, auto... T1,
    template<auto...> class L2, auto... T2,
    template<auto...> class L3, auto... T3,
    template<auto...> class L4, auto... T4,
    template<auto...> class L5, auto... T5,
    template<auto...> class L6, auto... T6,
    template<auto...> class L7, auto... T7,
    template<auto...> class L8, auto... T8,
    template<auto...> class L9, auto... T9,
    template<auto...> class L10, auto... T10,
    template<auto...> class L11, auto... T11>

struct append_value_11_impl<L1<T1...>, L2<T2...>, L3<T3...>, L4<T4...>, L5<T5...>, L6<T6...>, L7<T7...>, L8<T8...>, L9<T9...>, L10<T10...>, L11<T11...>>
{
    using type = L1<T1..., T2..., T3..., T4..., T5..., T6..., T7..., T8..., T9..., T10..., T11...>;
};

template<

    class L00 = mp_list_v<>, class L01 = mp_list_v<>, class L02 = mp_list_v<>, class L03 = mp_list_v<>, class L04 = mp_list_v<>, class L05 = mp_list_v<>, class L06 = mp_list_v<>, class L07 = mp_list_v<>, class L08 = mp_list_v<>, class L09 = mp_list_v<>, class L0A = mp_list_v<>,
    class L10 = mp_list_v<>, class L11 = mp_list_v<>, class L12 = mp_list_v<>, class L13 = mp_list_v<>, class L14 = mp_list_v<>, class L15 = mp_list_v<>, class L16 = mp_list_v<>, class L17 = mp_list_v<>, class L18 = mp_list_v<>, class L19 = mp_list_v<>,
    class L20 = mp_list_v<>, class L21 = mp_list_v<>, class L22 = mp_list_v<>, class L23 = mp_list_v<>, class L24 = mp_list_v<>, class L25 = mp_list_v<>, class L26 = mp_list_v<>, class L27 = mp_list_v<>, class L28 = mp_list_v<>, class L29 = mp_list_v<>,
    class L30 = mp_list_v<>, class L31 = mp_list_v<>, class L32 = mp_list_v<>, class L33 = mp_list_v<>, class L34 = mp_list_v<>, class L35 = mp_list_v<>, class L36 = mp_list_v<>, class L37 = mp_list_v<>, class L38 = mp_list_v<>, class L39 = mp_list_v<>,
    class L40 = mp_list_v<>, class L41 = mp_list_v<>, class L42 = mp_list_v<>, class L43 = mp_list_v<>, class L44 = mp_list_v<>, class L45 = mp_list_v<>, class L46 = mp_list_v<>, class L47 = mp_list_v<>, class L48 = mp_list_v<>, class L49 = mp_list_v<>,
    class L50 = mp_list_v<>, class L51 = mp_list_v<>, class L52 = mp_list_v<>, class L53 = mp_list_v<>, class L54 = mp_list_v<>, class L55 = mp_list_v<>, class L56 = mp_list_v<>, class L57 = mp_list_v<>, class L58 = mp_list_v<>, class L59 = mp_list_v<>,
    class L60 = mp_list_v<>, class L61 = mp_list_v<>, class L62 = mp_list_v<>, class L63 = mp_list_v<>, class L64 = mp_list_v<>, class L65 = mp_list_v<>, class L66 = mp_list_v<>, class L67 = mp_list_v<>, class L68 = mp_list_v<>, class L69 = mp_list_v<>,
    class L70 = mp_list_v<>, class L71 = mp_list_v<>, class L72 = mp_list_v<>, class L73 = mp_list_v<>, class L74 = mp_list_v<>, class L75 = mp_list_v<>, class L76 = mp_list_v<>, class L77 = mp_list_v<>, class L78 = mp_list_v<>, class L79 = mp_list_v<>,
    class L80 = mp_list_v<>, class L81 = mp_list_v<>, class L82 = mp_list_v<>, class L83 = mp_list_v<>, class L84 = mp_list_v<>, class L85 = mp_list_v<>, class L86 = mp_list_v<>, class L87 = mp_list_v<>, class L88 = mp_list_v<>, class L89 = mp_list_v<>,
    class L90 = mp_list_v<>, class L91 = mp_list_v<>, class L92 = mp_list_v<>, class L93 = mp_list_v<>, class L94 = mp_list_v<>, class L95 = mp_list_v<>, class L96 = mp_list_v<>, class L97 = mp_list_v<>, class L98 = mp_list_v<>, class L99 = mp_list_v<>,
    class LA0 = mp_list_v<>, class LA1 = mp_list_v<>, class LA2 = mp_list_v<>, class LA3 = mp_list_v<>, class LA4 = mp_list_v<>, class LA5 = mp_list_v<>, class LA6 = mp_list_v<>, class LA7 = mp_list_v<>, class LA8 = mp_list_v<>, class LA9 = mp_list_v<>

> struct append_value_111_impl
{
    using type = typename append_value_11_impl<

        typename append_value_11_impl<L00, L01, L02, L03, L04, L05, L06, L07, L08, L09, L0A>::type,
        typename append_value_11_impl<mp_list_v<>, L10, L11, L12, L13, L14, L15, L16, L17, L18, L19>::type,
        typename append_value_11_impl<mp_list_v<>, L20, L21, L22, L23, L24, L25, L26, L27, L28, L29>::type,
        typename append_value_11_impl<mp_list_v<>, L30, L31, L32, L33, L34, L35, L36, L37, L38, L39>::type,
        typename append_value_11_impl<mp_list_v<>, L40, L41, L42, L43, L44, L45, L46, L47, L48, L49>::type,
        typename append_value_11_impl<mp_list_v<>, L50, L51, L52, L53, L54, L55, L56, L57, L58, L59>::type,
        typename append_value_11_impl<mp_list_v<>, L60, L61, L62, L63, L64, L65, L66, L67, L68, L69>::type,
        typename append_value_11_impl<mp_list_v<>, L70, L71, L72, L73, L74, L75, L76, L77, L78, L79>::type,
        typename append_value_11_impl<mp_list_v<>, L80, L81, L82, L83, L84, L85, L86, L87, L88, L89>::type,
        typename append_value_11_impl<mp_list_v<>, L90, L91, L92, L93, L94, L95, L96, L97, L98, L99>::type,
        typename append_value_11_impl<mp_list_v<>, LA0, LA1, LA2, LA3, LA4, LA5, LA6, LA7, LA8, LA9>::type

    >::type;
};

template<

    class L00, class L01, class L02, class L03, class L04, class L05, class L06, class L07, class L08, class L09, class L0A,
    class L10, class L11, class L12, class L13, class L14, class L15, class L16, class L17, class L18, class L19,
    class L20, class L21, class L22, class L23, class L24, class L25, class L26, class L27, class L28, class L29,
    class L30, class L31, class L32, class L33, class L34, class L35, class L36, class L37, class L38, class L39,
    class L40, class L41, class L42, class L43, class L44, class L45, class L46, class L47, class L48, class L49,
    class L50, class L51, class L52, class L53, class L54, class L55, class L56, class L57, class L58, class L59,
    class L60, class L61, class L62, class L63, class L64, class L65, class L66, class L67, class L68, class L69,
    class L70, class L71, class L72, class L73, class L74, class L75, class L76, class L77, class L78, class L79,
    class L80, class L81, class L82, class L83, class L84, class L85, class L86, class L87, class L88, class L89,
    class L90, class L91, class L92, class L93, class L94, class L95, class L96, class L97, class L98, class L99,
    class LA0, class LA1, class LA2, class LA3, class LA4, class LA5, class LA6, class LA7, class LA8, class LA9,
    class... Lr

> struct append_value_inf_impl
{
    using prefix = typename append_value_111_impl<

        L00, L01, L02, L03, L04, L05, L06, L07, L08, L09, L0A,
        L10, L11, L12, L13, L14, L15, L16, L17, L18, L19,
        L20, L21, L22, L23, L24, L25, L26, L27, L28, L29,
        L30, L31, L32, L33, L34, L35, L36, L37, L38, L39,
        L40, L41, L42, L43, L44, L45, L46, L47, L48, L49,
        L50, L51, L52, L53, L54, L55, L56, L57, L58, L59,
        L60, L61, L62, L63, L64, L65, L66, L67, L68, L69,
        L70, L71, L72, L73, L74, L75, L76, L77, L78, L79,
        L80, L81, L82, L83, L84, L85, L86, L87, L88, L89,
        L90, L91, L92, L93, L94, L95, L96, L97, L98, L99,
        LA0, LA1, LA2, LA3, LA4, LA5, LA6, LA7, LA8, LA9

    >::type;

    using type = typename append_value_impl<prefix, Lr...>::type;
};

template<class... L> struct append_value_impl:
    mp_cond<
        mp_bool<(sizeof...(L) > 111)>, mp_quote<append_value_inf_impl>,
        mp_bool<(sizeof...(L) > 11)>, mp_quote<append_value_111_impl>,
        mp_true, mp_quote<append_value_11_impl>
    >::template fn<L...>
{
};

struct append_value_lists
{
    template<class... L> using fn = typename append_value_impl<L...>::type;
};



}



template<class... L> using mp_append = typename mp_if_c<(sizeof...(L) > 0 && sizeof...(L) == mp_count_if<mp_list<L...>, mp_is_value_list>::value), detail::append_value_lists, detail::append_type_lists>::template fn<L...>;







}
}
# 19 "/usr/include/boost/mp11/list.hpp" 2 3 4



namespace boost
{
namespace mp11
{





template<class T, T... I> using mp_list_c = mp_list<std::integral_constant<T, I>...>;
# 43 "/usr/include/boost/mp11/list.hpp" 3 4
namespace detail
{

template<class L> struct mp_size_impl
{

};

template<template<class...> class L, class... T> struct mp_size_impl<L<T...>>
{
    using type = mp_size_t<sizeof...(T)>;
};



template<template<auto...> class L, auto... A> struct mp_size_impl<L<A...>>
{
    using type = mp_size_t<sizeof...(A)>;
};



}

template<class L> using mp_size = typename detail::mp_size_impl<L>::type;


template<class L> using mp_empty = mp_bool< mp_size<L>::value == 0 >;


namespace detail
{

template<class L1, class L2> struct mp_assign_impl
{

};

template<template<class...> class L1, class... T, template<class...> class L2, class... U> struct mp_assign_impl<L1<T...>, L2<U...>>
{
    using type = L1<U...>;
};



template<template<auto...> class L1, auto... A, template<class...> class L2, class... U> struct mp_assign_impl<L1<A...>, L2<U...>>
{
    using type = L1<U::value...>;
};

template<template<class...> class L1, class... T, template<auto...> class L2, auto... B> struct mp_assign_impl<L1<T...>, L2<B...>>
{
    using type = L1<mp_value<B>...>;
};

template<template<auto...> class L1, auto... A, template<auto...> class L2, auto... B> struct mp_assign_impl<L1<A...>, L2<B...>>
{
    using type = L1<B...>;
};



}

template<class L1, class L2> using mp_assign = typename detail::mp_assign_impl<L1, L2>::type;


template<class L> using mp_clear = mp_assign<L, mp_list<>>;





namespace detail
{

template<class L> struct mp_pop_front_impl
{


};

template<template<class...> class L, class T1, class... T> struct mp_pop_front_impl<L<T1, T...>>
{
    using type = L<T...>;
};



template<template<auto...> class L, auto A1, auto... A> struct mp_pop_front_impl<L<A1, A...>>
{
    using type = L<A...>;
};



}

template<class L> using mp_pop_front = typename detail::mp_pop_front_impl<L>::type;


template<class L> using mp_first = mp_front<L>;


template<class L> using mp_rest = mp_pop_front<L>;


namespace detail
{

template<class L> struct mp_second_impl
{


};

template<template<class...> class L, class T1, class T2, class... T> struct mp_second_impl<L<T1, T2, T...>>
{
    using type = T2;
};



template<template<auto...> class L, auto A1, auto A2, auto... A> struct mp_second_impl<L<A1, A2, A...>>
{
    using type = mp_value<A2>;
};



}

template<class L> using mp_second = typename detail::mp_second_impl<L>::type;


namespace detail
{

template<class L> struct mp_third_impl
{


};

template<template<class...> class L, class T1, class T2, class T3, class... T> struct mp_third_impl<L<T1, T2, T3, T...>>
{
    using type = T3;
};



template<template<auto...> class L, auto A1, auto A2, auto A3, auto... A> struct mp_third_impl<L<A1, A2, A3, A...>>
{
    using type = mp_value<A3>;
};



}

template<class L> using mp_third = typename detail::mp_third_impl<L>::type;


namespace detail
{

template<class L, class... T> struct mp_push_front_impl
{

};

template<template<class...> class L, class... U, class... T> struct mp_push_front_impl<L<U...>, T...>
{
    using type = L<T..., U...>;
};



template<template<auto...> class L, auto... A, class... T> struct mp_push_front_impl<L<A...>, T...>
{
    using type = L<T::value..., A...>;
};



}

template<class L, class... T> using mp_push_front = typename detail::mp_push_front_impl<L, T...>::type;


namespace detail
{

template<class L, class... T> struct mp_push_back_impl
{

};

template<template<class...> class L, class... U, class... T> struct mp_push_back_impl<L<U...>, T...>
{
    using type = L<U..., T...>;
};



template<template<auto...> class L, auto... A, class... T> struct mp_push_back_impl<L<A...>, T...>
{
    using type = L<A..., T::value...>;
};



}

template<class L, class... T> using mp_push_back = typename detail::mp_push_back_impl<L, T...>::type;
# 267 "/usr/include/boost/mp11/list.hpp" 3 4
namespace detail
{

template<class L, template<auto...> class B> struct mp_rename_v_impl
{

};

template<template<class...> class L, class... T, template<auto...> class B> struct mp_rename_v_impl<L<T...>, B>
{
    using type = B<T::value...>;
};

template<template<auto...> class L, auto... A, template<auto...> class B> struct mp_rename_v_impl<L<A...>, B>
{
    using type = B<A...>;
};

}

template<class L, template<auto...> class B> using mp_rename_v = typename detail::mp_rename_v_impl<L, B>::type;




namespace detail
{

template<class L, class T> struct mp_replace_front_impl
{


};

template<template<class...> class L, class U1, class... U, class T> struct mp_replace_front_impl<L<U1, U...>, T>
{
    using type = L<T, U...>;
};



template<template<auto...> class L, auto A1, auto... A, class T> struct mp_replace_front_impl<L<A1, A...>, T>
{
    using type = L<T::value, A...>;
};



}

template<class L, class T> using mp_replace_front = typename detail::mp_replace_front_impl<L, T>::type;


template<class L, class T> using mp_replace_first = typename detail::mp_replace_front_impl<L, T>::type;


namespace detail
{

template<class L, class T> struct mp_replace_second_impl
{


};

template<template<class...> class L, class U1, class U2, class... U, class T> struct mp_replace_second_impl<L<U1, U2, U...>, T>
{
    using type = L<U1, T, U...>;
};



template<template<auto...> class L, auto A1, auto A2, auto... A, class T> struct mp_replace_second_impl<L<A1, A2, A...>, T>
{
    using type = L<A1, T::value, A...>;
};



}

template<class L, class T> using mp_replace_second = typename detail::mp_replace_second_impl<L, T>::type;


namespace detail
{

template<class L, class T> struct mp_replace_third_impl
{


};

template<template<class...> class L, class U1, class U2, class U3, class... U, class T> struct mp_replace_third_impl<L<U1, U2, U3, U...>, T>
{
    using type = L<U1, U2, T, U...>;
};



template<template<auto...> class L, auto A1, auto A2, auto A3, auto... A, class T> struct mp_replace_third_impl<L<A1, A2, A3, A...>, T>
{
    using type = L<A1, A2, T::value, A...>;
};



}

template<class L, class T> using mp_replace_third = typename detail::mp_replace_third_impl<L, T>::type;


namespace detail
{

template<class L, template<class...> class F> struct mp_transform_front_impl
{


};

template<template<class...> class L, class U1, class... U, template<class...> class F> struct mp_transform_front_impl<L<U1, U...>, F>
{
    using type = L<F<U1>, U...>;
};



template<template<auto...> class L, auto A1, auto... A, template<class...> class F> struct mp_transform_front_impl<L<A1, A...>, F>
{
    using type = L<F<mp_value<A1>>::value, A...>;
};



}

template<class L, template<class...> class F> using mp_transform_front = typename detail::mp_transform_front_impl<L, F>::type;
template<class L, class Q> using mp_transform_front_q = mp_transform_front<L, Q::template fn>;


template<class L, template<class...> class F> using mp_transform_first = typename detail::mp_transform_front_impl<L, F>::type;
template<class L, class Q> using mp_transform_first_q = mp_transform_first<L, Q::template fn>;


namespace detail
{

template<class L, template<class...> class F> struct mp_transform_second_impl
{


};

template<template<class...> class L, class U1, class U2, class... U, template<class...> class F> struct mp_transform_second_impl<L<U1, U2, U...>, F>
{
    using type = L<U1, F<U2>, U...>;
};



template<template<auto...> class L, auto A1, auto A2, auto... A, template<class...> class F> struct mp_transform_second_impl<L<A1, A2, A...>, F>
{
    using type = L<A1, F<mp_value<A2>>::value, A...>;
};



}

template<class L, template<class...> class F> using mp_transform_second = typename detail::mp_transform_second_impl<L, F>::type;
template<class L, class Q> using mp_transform_second_q = mp_transform_second<L, Q::template fn>;


namespace detail
{

template<class L, template<class...> class F> struct mp_transform_third_impl
{


};

template<template<class...> class L, class U1, class U2, class U3, class... U, template<class...> class F> struct mp_transform_third_impl<L<U1, U2, U3, U...>, F>
{
    using type = L<U1, U2, F<U3>, U...>;
};



template<template<auto...> class L, auto A1, auto A2, auto A3, auto... A, template<class...> class F> struct mp_transform_third_impl<L<A1, A2, A3, A...>, F>
{
    using type = L<A1, A2, F<mp_value<A3>>::value, A...>;
};



}

template<class L, template<class...> class F> using mp_transform_third = typename detail::mp_transform_third_impl<L, F>::type;
template<class L, class Q> using mp_transform_third_q = mp_transform_third<L, Q::template fn>;

}
}
# 12 "/usr/include/boost/mp11/algorithm.hpp" 2 3 4
# 1 "/usr/include/boost/mp11/set.hpp" 1 3 4
# 12 "/usr/include/boost/mp11/set.hpp" 3 4
# 1 "/usr/include/boost/mp11/function.hpp" 1 3 4
# 16 "/usr/include/boost/mp11/function.hpp" 3 4
# 1 "/usr/include/boost/mp11/detail/mp_min_element.hpp" 1 3 4
# 15 "/usr/include/boost/mp11/detail/mp_min_element.hpp" 3 4
namespace boost
{
namespace mp11
{


namespace detail
{

template<template<class...> class P> struct select_min
{
    template<class T1, class T2> using fn = mp_if<P<T1, T2>, T1, T2>;
};

}

template<class L, template<class...> class P> using mp_min_element = mp_fold_q<mp_rest<L>, mp_first<L>, detail::select_min<P>>;
template<class L, class Q> using mp_min_element_q = mp_min_element<L, Q::template fn>;


namespace detail
{

template<template<class...> class P> struct select_max
{
    template<class T1, class T2> using fn = mp_if<P<T2, T1>, T1, T2>;
};

}

template<class L, template<class...> class P> using mp_max_element = mp_fold_q<mp_rest<L>, mp_first<L>, detail::select_max<P>>;
template<class L, class Q> using mp_max_element_q = mp_max_element<L, Q::template fn>;

}
}
# 17 "/usr/include/boost/mp11/function.hpp" 2 3 4
# 1 "/usr/include/boost/mp11/detail/mp_void.hpp" 1 3 4
# 11 "/usr/include/boost/mp11/detail/mp_void.hpp" 3 4
namespace boost
{
namespace mp11
{


namespace detail
{

template<class... T> struct mp_void_impl
{
    using type = void;
};

}

template<class... T> using mp_void = typename detail::mp_void_impl<T...>::type;

}
}
# 18 "/usr/include/boost/mp11/function.hpp" 2 3 4



namespace boost
{
namespace mp11
{
# 63 "/usr/include/boost/mp11/function.hpp" 3 4
namespace detail
{

template<class L, class E = void> struct mp_and_impl
{
    using type = mp_false;
};

template<class... T> struct mp_and_impl< mp_list<T...>, mp_void<mp_if<T, void>...> >
{
    using type = mp_true;
};

}

template<class... T> using mp_and = typename detail::mp_and_impl<mp_list<T...>>::type;
# 90 "/usr/include/boost/mp11/function.hpp" 3 4
template<class... T> using mp_all = mp_bool< mp_count< mp_list<mp_to_bool<T>...>, mp_false >::value == 0 >;




namespace detail
{

template<class... T> struct mp_or_impl;

}

template<class... T> using mp_or = mp_to_bool< typename detail::mp_or_impl<T...>::type >;

namespace detail
{

template<> struct mp_or_impl<>
{
    using type = mp_false;
};

template<class T> struct mp_or_impl<T>
{
    using type = T;
};

template<class T1, class... T> struct mp_or_impl<T1, T...>
{
    using type = mp_eval_if< T1, T1, mp_or, T... >;
};

}
# 132 "/usr/include/boost/mp11/function.hpp" 3 4
template<class... T> using mp_any = mp_bool< mp_count< mp_list<mp_to_bool<T>...>, mp_true >::value != 0 >;




namespace detail
{

template<class... T> struct mp_same_impl;

template<> struct mp_same_impl<>
{
    using type = mp_true;
};

template<class T1, class... T> struct mp_same_impl<T1, T...>
{
    using type = mp_bool< mp_count<mp_list<T...>, T1>::value == sizeof...(T) >;
};

}

template<class... T> using mp_same = typename detail::mp_same_impl<T...>::type;


namespace detail
{

template<class... T> struct mp_similar_impl;

template<> struct mp_similar_impl<>
{
    using type = mp_true;
};

template<class T> struct mp_similar_impl<T>
{
    using type = mp_true;
};

template<class T> struct mp_similar_impl<T, T>
{
    using type = mp_true;
};

template<class T1, class T2> struct mp_similar_impl<T1, T2>
{
    using type = mp_false;
};

template<template<class...> class L, class... T1, class... T2> struct mp_similar_impl<L<T1...>, L<T2...>>
{
    using type = mp_true;
};

template<template<class...> class L, class... T> struct mp_similar_impl<L<T...>, L<T...>>
{
    using type = mp_true;
};

template<class T1, class T2, class T3, class... T> struct mp_similar_impl<T1, T2, T3, T...>
{
    using type = mp_all< typename mp_similar_impl<T1, T2>::type, typename mp_similar_impl<T1, T3>::type, typename mp_similar_impl<T1, T>::type... >;
};

}

template<class... T> using mp_similar = typename detail::mp_similar_impl<T...>::type;







template<class T1, class T2> using mp_less = mp_bool<(T1::value < 0 && T2::value >= 0) || ((T1::value < T2::value) && !(T1::value >= 0 && T2::value < 0))>;






template<class T1, class... T> using mp_min = mp_min_element<mp_list<T1, T...>, mp_less>;


template<class T1, class... T> using mp_max = mp_max_element<mp_list<T1, T...>, mp_less>;

}
}
# 13 "/usr/include/boost/mp11/set.hpp" 2 3 4


# 1 "/usr/include/boost/mp11/detail/mp_copy_if.hpp" 1 3 4
# 16 "/usr/include/boost/mp11/detail/mp_copy_if.hpp" 3 4
namespace boost
{
namespace mp11
{


namespace detail
{

template<class L, template<class...> class P> struct mp_copy_if_impl
{
};

template<template<class...> class L, class... T, template<class...> class P> struct mp_copy_if_impl<L<T...>, P>
{




    template<class U> using _f = mp_if<P<U>, mp_list<U>, mp_list<>>;
    using type = mp_append<L<>, _f<T>...>;

};

}

template<class L, template<class...> class P> using mp_copy_if = typename detail::mp_copy_if_impl<L, P>::type;
template<class L, class Q> using mp_copy_if_q = mp_copy_if<L, Q::template fn>;

}
}
# 16 "/usr/include/boost/mp11/set.hpp" 2 3 4
# 1 "/usr/include/boost/mp11/detail/mp_remove_if.hpp" 1 3 4
# 16 "/usr/include/boost/mp11/detail/mp_remove_if.hpp" 3 4
namespace boost
{
namespace mp11
{


namespace detail
{

template<class L, template<class...> class P> struct mp_remove_if_impl
{
};

template<template<class...> class L, class... T, template<class...> class P> struct mp_remove_if_impl<L<T...>, P>
{




    template<class U> using _f = mp_if<P<U>, mp_list<>, mp_list<U>>;
    using type = mp_append<L<>, _f<T>...>;

};

}

template<class L, template<class...> class P> using mp_remove_if = typename detail::mp_remove_if_impl<L, P>::type;
template<class L, class Q> using mp_remove_if_q = mp_remove_if<L, Q::template fn>;

}
}
# 17 "/usr/include/boost/mp11/set.hpp" 2 3 4



namespace boost
{
namespace mp11
{


namespace detail
{

template<class S, class V> struct mp_set_contains_impl
{
};

template<template<class...> class L, class... T, class V> struct mp_set_contains_impl<L<T...>, V>
{
    using type = mp_to_bool<std::is_base_of<mp_identity<V>, mp_inherit<mp_identity<T>...> > >;
};

}

template<class S, class V> using mp_set_contains = typename detail::mp_set_contains_impl<S, V>::type;


namespace detail
{

template<class S, class... T> struct mp_set_push_back_impl
{
};

template<template<class...> class L, class... U> struct mp_set_push_back_impl<L<U...>>
{
    using type = L<U...>;
};

template<template<class...> class L, class... U, class T1, class... T> struct mp_set_push_back_impl<L<U...>, T1, T...>
{
    using S = mp_if<mp_set_contains<L<U...>, T1>, L<U...>, L<U..., T1>>;
    using type = typename mp_set_push_back_impl<S, T...>::type;
};

}

template<class S, class... T> using mp_set_push_back = typename detail::mp_set_push_back_impl<S, T...>::type;


namespace detail
{

template<class S, class... T> struct mp_set_push_front_impl
{
};

template<template<class...> class L, class... U> struct mp_set_push_front_impl<L<U...>>
{
    using type = L<U...>;
};

template<template<class...> class L, class... U, class T1> struct mp_set_push_front_impl<L<U...>, T1>
{
    using type = mp_if<mp_set_contains<L<U...>, T1>, L<U...>, L<T1, U...>>;
};

template<template<class...> class L, class... U, class T1, class... T> struct mp_set_push_front_impl<L<U...>, T1, T...>
{
    using S = typename mp_set_push_front_impl<L<U...>, T...>::type;
    using type = typename mp_set_push_front_impl<S, T1>::type;
};

}

template<class S, class... T> using mp_set_push_front = typename detail::mp_set_push_front_impl<S, T...>::type;


namespace detail
{

template<class S> struct mp_is_set_impl
{
    using type = mp_false;
};

template<template<class...> class L, class... T> struct mp_is_set_impl<L<T...>>
{
    using type = mp_to_bool<std::is_same<mp_list<T...>, mp_set_push_back<mp_list<>, T...> > >;
};

}

template<class S> using mp_is_set = typename detail::mp_is_set_impl<S>::type;


namespace detail
{

template<class... L> struct mp_set_union_impl
{
};

template<> struct mp_set_union_impl<>
{
    using type = mp_list<>;
};

template<template<class...> class L, class... T> struct mp_set_union_impl<L<T...>>
{
    using type = L<T...>;
};

template<template<class...> class L1, class... T1, template<class...> class L2, class... T2> struct mp_set_union_impl<L1<T1...>, L2<T2...>>
{
    using type = mp_set_push_back<L1<T1...>, T2...>;
};

template<class L1, class... L> using mp_set_union_ = typename mp_set_union_impl<L1, mp_append<mp_list<>, L...>>::type;

template<class L1, class L2, class L3, class... L> struct mp_set_union_impl<L1, L2, L3, L...>: mp_defer<mp_set_union_, L1, L2, L3, L...>
{
};

}

template<class... L> using mp_set_union = typename detail::mp_set_union_impl<L...>::type;


namespace detail
{

template<class... S> struct in_all_sets
{
    template<class T> using fn = mp_all< mp_set_contains<S, T>... >;
};

template<class L, class... S> using mp_set_intersection_ = mp_if< mp_all<mp_is_list<S>...>, mp_copy_if_q<L, detail::in_all_sets<S...>> >;

template<class... S> struct mp_set_intersection_impl
{
};

template<> struct mp_set_intersection_impl<>
{
    using type = mp_list<>;
};

template<class L, class... S> struct mp_set_intersection_impl<L, S...>: mp_defer<mp_set_intersection_, L, S...>
{
};

}

template<class... S> using mp_set_intersection = typename detail::mp_set_intersection_impl<S...>::type;


namespace detail
{

template<class... S> struct in_any_set
{
    template<class T> using fn = mp_any< mp_set_contains<S, T>... >;
};

}

template<class L, class... S> using mp_set_difference = mp_if< mp_all<mp_is_list<S>...>, mp_remove_if_q<L, detail::in_any_set<S...>> >;

}
}
# 13 "/usr/include/boost/mp11/algorithm.hpp" 2 3 4





# 1 "/usr/include/boost/mp11/detail/mp_map_find.hpp" 1 3 4
# 24 "/usr/include/boost/mp11/detail/mp_map_find.hpp" 3 4
namespace boost
{
namespace mp11
{


namespace detail
{



template<class T> using mpmf_wrap = mp_identity<T>;
template<class T> using mpmf_unwrap = typename T::type;
# 68 "/usr/include/boost/mp11/detail/mp_map_find.hpp" 3 4
template<class M, class K> struct mp_map_find_impl;

template<template<class...> class M, class... T, class K> struct mp_map_find_impl<M<T...>, K>
{
    using U = mp_inherit<mpmf_wrap<T>...>;

    template<template<class...> class L, class... U> static mp_identity<L<K, U...>> f( mp_identity<L<K, U...>>* );
    static mp_identity<void> f( ... );

    using type = mpmf_unwrap< decltype( f( static_cast<U*>(0) ) ) >;
};

}

template<class M, class K> using mp_map_find = typename detail::mp_map_find_impl<M, K>::type;

}
}
# 19 "/usr/include/boost/mp11/algorithm.hpp" 2 3 4
# 1 "/usr/include/boost/mp11/detail/mp_with_index.hpp" 1 3 4
# 15 "/usr/include/boost/mp11/detail/mp_with_index.hpp" 3 4
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 1 3 4
# 42 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 3


# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 45 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 2 3
# 16 "/usr/include/boost/mp11/detail/mp_with_index.hpp" 2 3 4
# 31 "/usr/include/boost/mp11/detail/mp_with_index.hpp" 3 4
namespace boost
{
namespace mp11
{

namespace detail
{

template<std::size_t N> struct mp_with_index_impl_
{
    template<std::size_t K, class F> static constexpr decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
    {
        if( i < N / 2 )
        {
            return mp_with_index_impl_<N/2>::template call<K>( i, std::forward<F>(f) );
        }
        else
        {
            return mp_with_index_impl_<N-N/2>::template call<K+N/2>( i - N/2, std::forward<F>(f) );
        }
    }
};

template<> struct mp_with_index_impl_<0>
{
};

template<> struct mp_with_index_impl_<1>
{
    template<std::size_t K, class F> static constexpr decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t , F && f )
    {
        return std::forward<F>(f)( mp_size_t<K+0>() );
    }
};

template<> struct mp_with_index_impl_<2>
{
    template<std::size_t K, class F> static constexpr decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
    {
        switch( i )
        {
        default: __builtin_unreachable();
        case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
        case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
        }
    }
};

template<> struct mp_with_index_impl_<3>
{
    template<std::size_t K, class F> static constexpr decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
    {
        switch( i )
        {
        default: __builtin_unreachable();
        case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
        case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
        case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
        }
    }
};

template<> struct mp_with_index_impl_<4>
{
    template<std::size_t K, class F> static constexpr decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
    {
        switch( i )
        {
        default: __builtin_unreachable();
        case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
        case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
        case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
        case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
        }
    }
};

template<> struct mp_with_index_impl_<5>
{
    template<std::size_t K, class F> static constexpr decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
    {
        switch( i )
        {
        default: __builtin_unreachable();
        case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
        case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
        case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
        case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
        case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
        }
    }
};

template<> struct mp_with_index_impl_<6>
{
    template<std::size_t K, class F> static constexpr decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
    {
        switch( i )
        {
        default: __builtin_unreachable();
        case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
        case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
        case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
        case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
        case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
        case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
        }
    }
};

template<> struct mp_with_index_impl_<7>
{
    template<std::size_t K, class F> static constexpr decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
    {
        switch( i )
        {
        default: __builtin_unreachable();
        case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
        case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
        case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
        case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
        case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
        case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
        case 6: return std::forward<F>(f)( mp_size_t<K+6>() );
        }
    }
};

template<> struct mp_with_index_impl_<8>
{
    template<std::size_t K, class F> static constexpr decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
    {
        switch( i )
        {
        default: __builtin_unreachable();
        case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
        case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
        case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
        case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
        case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
        case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
        case 6: return std::forward<F>(f)( mp_size_t<K+6>() );
        case 7: return std::forward<F>(f)( mp_size_t<K+7>() );
        }
    }
};

template<> struct mp_with_index_impl_<9>
{
    template<std::size_t K, class F> static constexpr decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
    {
        switch( i )
        {
        default: __builtin_unreachable();
        case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
        case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
        case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
        case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
        case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
        case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
        case 6: return std::forward<F>(f)( mp_size_t<K+6>() );
        case 7: return std::forward<F>(f)( mp_size_t<K+7>() );
        case 8: return std::forward<F>(f)( mp_size_t<K+8>() );
        }
    }
};

template<> struct mp_with_index_impl_<10>
{
    template<std::size_t K, class F> static constexpr decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
    {
        switch( i )
        {
        default: __builtin_unreachable();
        case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
        case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
        case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
        case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
        case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
        case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
        case 6: return std::forward<F>(f)( mp_size_t<K+6>() );
        case 7: return std::forward<F>(f)( mp_size_t<K+7>() );
        case 8: return std::forward<F>(f)( mp_size_t<K+8>() );
        case 9: return std::forward<F>(f)( mp_size_t<K+9>() );
        }
    }
};

template<> struct mp_with_index_impl_<11>
{
    template<std::size_t K, class F> static constexpr decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
    {
        switch( i )
        {
        default: __builtin_unreachable();
        case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
        case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
        case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
        case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
        case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
        case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
        case 6: return std::forward<F>(f)( mp_size_t<K+6>() );
        case 7: return std::forward<F>(f)( mp_size_t<K+7>() );
        case 8: return std::forward<F>(f)( mp_size_t<K+8>() );
        case 9: return std::forward<F>(f)( mp_size_t<K+9>() );
        case 10: return std::forward<F>(f)( mp_size_t<K+10>() );
        }
    }
};

template<> struct mp_with_index_impl_<12>
{
    template<std::size_t K, class F> static constexpr decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
    {
        switch( i )
        {
        default: __builtin_unreachable();
        case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
        case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
        case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
        case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
        case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
        case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
        case 6: return std::forward<F>(f)( mp_size_t<K+6>() );
        case 7: return std::forward<F>(f)( mp_size_t<K+7>() );
        case 8: return std::forward<F>(f)( mp_size_t<K+8>() );
        case 9: return std::forward<F>(f)( mp_size_t<K+9>() );
        case 10: return std::forward<F>(f)( mp_size_t<K+10>() );
        case 11: return std::forward<F>(f)( mp_size_t<K+11>() );
        }
    }
};

template<> struct mp_with_index_impl_<13>
{
    template<std::size_t K, class F> static constexpr decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
    {
        switch( i )
        {
        default: __builtin_unreachable();
        case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
        case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
        case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
        case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
        case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
        case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
        case 6: return std::forward<F>(f)( mp_size_t<K+6>() );
        case 7: return std::forward<F>(f)( mp_size_t<K+7>() );
        case 8: return std::forward<F>(f)( mp_size_t<K+8>() );
        case 9: return std::forward<F>(f)( mp_size_t<K+9>() );
        case 10: return std::forward<F>(f)( mp_size_t<K+10>() );
        case 11: return std::forward<F>(f)( mp_size_t<K+11>() );
        case 12: return std::forward<F>(f)( mp_size_t<K+12>() );
        }
    }
};

template<> struct mp_with_index_impl_<14>
{
    template<std::size_t K, class F> static constexpr decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
    {
        switch( i )
        {
        default: __builtin_unreachable();
        case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
        case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
        case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
        case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
        case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
        case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
        case 6: return std::forward<F>(f)( mp_size_t<K+6>() );
        case 7: return std::forward<F>(f)( mp_size_t<K+7>() );
        case 8: return std::forward<F>(f)( mp_size_t<K+8>() );
        case 9: return std::forward<F>(f)( mp_size_t<K+9>() );
        case 10: return std::forward<F>(f)( mp_size_t<K+10>() );
        case 11: return std::forward<F>(f)( mp_size_t<K+11>() );
        case 12: return std::forward<F>(f)( mp_size_t<K+12>() );
        case 13: return std::forward<F>(f)( mp_size_t<K+13>() );
        }
    }
};

template<> struct mp_with_index_impl_<15>
{
    template<std::size_t K, class F> static constexpr decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
    {
        switch( i )
        {
        default: __builtin_unreachable();
        case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
        case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
        case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
        case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
        case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
        case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
        case 6: return std::forward<F>(f)( mp_size_t<K+6>() );
        case 7: return std::forward<F>(f)( mp_size_t<K+7>() );
        case 8: return std::forward<F>(f)( mp_size_t<K+8>() );
        case 9: return std::forward<F>(f)( mp_size_t<K+9>() );
        case 10: return std::forward<F>(f)( mp_size_t<K+10>() );
        case 11: return std::forward<F>(f)( mp_size_t<K+11>() );
        case 12: return std::forward<F>(f)( mp_size_t<K+12>() );
        case 13: return std::forward<F>(f)( mp_size_t<K+13>() );
        case 14: return std::forward<F>(f)( mp_size_t<K+14>() );
        }
    }
};

template<> struct mp_with_index_impl_<16>
{
    template<std::size_t K, class F> static constexpr decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) call( std::size_t i, F && f )
    {
        switch( i )
        {
        default: __builtin_unreachable();
        case 0: return std::forward<F>(f)( mp_size_t<K+0>() );
        case 1: return std::forward<F>(f)( mp_size_t<K+1>() );
        case 2: return std::forward<F>(f)( mp_size_t<K+2>() );
        case 3: return std::forward<F>(f)( mp_size_t<K+3>() );
        case 4: return std::forward<F>(f)( mp_size_t<K+4>() );
        case 5: return std::forward<F>(f)( mp_size_t<K+5>() );
        case 6: return std::forward<F>(f)( mp_size_t<K+6>() );
        case 7: return std::forward<F>(f)( mp_size_t<K+7>() );
        case 8: return std::forward<F>(f)( mp_size_t<K+8>() );
        case 9: return std::forward<F>(f)( mp_size_t<K+9>() );
        case 10: return std::forward<F>(f)( mp_size_t<K+10>() );
        case 11: return std::forward<F>(f)( mp_size_t<K+11>() );
        case 12: return std::forward<F>(f)( mp_size_t<K+12>() );
        case 13: return std::forward<F>(f)( mp_size_t<K+13>() );
        case 14: return std::forward<F>(f)( mp_size_t<K+14>() );
        case 15: return std::forward<F>(f)( mp_size_t<K+15>() );
        }
    }
};

}

template<std::size_t N, class F> inline constexpr decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) mp_with_index( std::size_t i, F && f )
{
    (static_cast <bool> (i < N) ? void (0) : __assert_fail ("i < N", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
    return detail::mp_with_index_impl_<N>::template call<0>( i, std::forward<F>(f) );
}

template<class N, class F> inline constexpr decltype(std::declval<F>()(std::declval<mp_size_t<0>>())) mp_with_index( std::size_t i, F && f )
{
    return mp_with_index<std::size_t{N::value}>( i, std::forward<F>(f) );
}




}
}
# 20 "/usr/include/boost/mp11/algorithm.hpp" 2 3 4





# 1 "/usr/include/boost/mp11/integer_sequence.hpp" 1 3 4
# 20 "/usr/include/boost/mp11/integer_sequence.hpp" 3 4
namespace boost
{
namespace mp11
{


template<class T, T... I> struct integer_sequence
{
};



template<class T, T N> using make_integer_sequence = __make_integer_seq<integer_sequence, T, N>;
# 101 "/usr/include/boost/mp11/integer_sequence.hpp" 3 4
template<std::size_t... I> using index_sequence = integer_sequence<std::size_t, I...>;


template<std::size_t N> using make_index_sequence = make_integer_sequence<std::size_t, N>;


template<class... T> using index_sequence_for = make_integer_sequence<std::size_t, sizeof...(T)>;

}
}
# 26 "/usr/include/boost/mp11/algorithm.hpp" 2 3 4



namespace boost
{
namespace mp11
{


namespace detail
{

template<template<class...> class F, class... L> struct mp_transform_impl
{
};

template<template<class...> class F, template<class...> class L, class... T> struct mp_transform_impl<F, L<T...>>
{
# 52 "/usr/include/boost/mp11/algorithm.hpp" 3 4
    using type = L<F<T>...>;


};

template<template<class...> class F, template<class...> class L1, class... T1, template<class...> class L2, class... T2> struct mp_transform_impl<F, L1<T1...>, L2<T2...>>
{
# 67 "/usr/include/boost/mp11/algorithm.hpp" 3 4
    using type = L1<F<T1,T2>...>;


};

template<template<class...> class F, template<class...> class L1, class... T1, template<class...> class L2, class... T2, template<class...> class L3, class... T3> struct mp_transform_impl<F, L1<T1...>, L2<T2...>, L3<T3...>>
{
# 82 "/usr/include/boost/mp11/algorithm.hpp" 3 4
    using type = L1<F<T1,T2,T3>...>;


};
# 94 "/usr/include/boost/mp11/algorithm.hpp" 3 4
struct list_size_mismatch
{
};
# 107 "/usr/include/boost/mp11/algorithm.hpp" 3 4
}
# 121 "/usr/include/boost/mp11/algorithm.hpp" 3 4
template<template<class...> class F, class... L> using mp_transform = typename mp_if<mp_same<mp_size<L>...>, detail::mp_transform_impl<F, L...>, detail::list_size_mismatch>::type;





template<class Q, class... L> using mp_transform_q = mp_transform<Q::template fn, L...>;

namespace detail
{

template<template<class...> class F, template<class...> class L1, class... T1, template<class...> class L2, class... T2, template<class...> class L3, class... T3, template<class...> class L4, class... T4, class... L> struct mp_transform_impl<F, L1<T1...>, L2<T2...>, L3<T3...>, L4<T4...>, L...>
{
    using A1 = L1<mp_list<T1, T2, T3, T4>...>;

    template<class V, class T> using _f = mp_transform<mp_push_back, V, T>;

    using A2 = mp_fold<mp_list<L...>, A1, _f>;

    template<class T> using _g = mp_apply<F, T>;

    using type = mp_transform<_g, A2>;
};

}


namespace detail
{

template<template<class...> class P, template<class...> class F, class... L> struct mp_transform_if_impl
{


    using Qp = mp_quote<P>;
    using Qf = mp_quote<F>;
# 165 "/usr/include/boost/mp11/algorithm.hpp" 3 4
    template<class... U> using _f = mp_eval_if_q<mp_not<mp_invoke_q<Qp, U...>>, mp_first<mp_list<U...>>, Qf, U...>;



    using type = mp_transform<_f, L...>;
};

}

template<template<class...> class P, template<class...> class F, class... L> using mp_transform_if = typename detail::mp_transform_if_impl<P, F, L...>::type;
template<class Qp, class Qf, class... L> using mp_transform_if_q = typename detail::mp_transform_if_impl<Qp::template fn, Qf::template fn, L...>::type;


namespace detail
{

template<template<class...> class P, class L1, class... L> struct mp_filter_impl
{
    using Qp = mp_quote<P>;

    template<class T1, class... T> using _f = mp_if< mp_invoke_q<Qp, T1, T...>, mp_list<T1>, mp_list<> >;

    using _t1 = mp_transform<_f, L1, L...>;
    using _t2 = mp_apply<mp_append, _t1>;

    using type = mp_assign<L1, _t2>;
};

}

template<template<class...> class P, class... L> using mp_filter = typename detail::mp_filter_impl<P, L...>::type;
template<class Q, class... L> using mp_filter_q = typename detail::mp_filter_impl<Q::template fn, L...>::type;


namespace detail
{

template<class L, class V> struct mp_fill_impl
{

};

template<template<class...> class L, class... T, class V> struct mp_fill_impl<L<T...>, V>
{







    template<class...> using _f = V;
    using type = L<_f<T>...>;


};



template<template<auto...> class L, auto... A, class V> struct mp_fill_impl<L<A...>, V>
{
    using type = L<((void)A, V::value)...>;
};



}

template<class L, class V> using mp_fill = typename detail::mp_fill_impl<L, V>::type;


template<class L, class V> using mp_contains = mp_to_bool<mp_count<L, V>>;


namespace detail
{

template<class L, std::size_t N> struct mp_repeat_c_impl
{
    using _l1 = typename mp_repeat_c_impl<L, N/2>::type;
    using _l2 = typename mp_repeat_c_impl<L, N%2>::type;

    using type = mp_append<_l1, _l1, _l2>;
};

template<class L> struct mp_repeat_c_impl<L, 0>
{
    using type = mp_clear<L>;
};

template<class L> struct mp_repeat_c_impl<L, 1>
{
    using type = L;
};

}

template<class L, std::size_t N> using mp_repeat_c = typename detail::mp_repeat_c_impl<L, N>::type;
template<class L, class N> using mp_repeat = typename detail::mp_repeat_c_impl<L, std::size_t{ N::value }>::type;


namespace detail
{

template<template<class...> class F, class P, class... L> struct mp_product_impl_2
{
};

template<template<class...> class F, class P> struct mp_product_impl_2<F, P>
{
    using type = mp_list<mp_rename<P, F>>;
};

template<template<class...> class F, class P, template<class...> class L1, class... T1, class... L> struct mp_product_impl_2<F, P, L1<T1...>, L...>
{
    using type = mp_append<typename mp_product_impl_2<F, mp_push_back<P, T1>, L...>::type...>;
};

template<template<class...> class F, class... L> struct mp_product_impl
{
};

template<template<class...> class F> struct mp_product_impl<F>
{
    using type = mp_list< F<> >;
};

template<template<class...> class F, class L1, class... L> struct mp_product_impl<F, L1, L...>
{
    using type = mp_assign<L1, typename mp_product_impl_2<F, mp_list<>, L1, L...>::type>;
};

}

template<template<class...> class F, class... L> using mp_product = typename detail::mp_product_impl<F, L...>::type;
template<class Q, class... L> using mp_product_q = typename detail::mp_product_impl<Q::template fn, L...>::type;


namespace detail
{

template<class L, class L2, class En> struct mp_drop_impl;

template<template<class...> class L, class... T, template<class...> class L2, class... U> struct mp_drop_impl<L<T...>, L2<U...>, mp_true>
{
    template<class... W> static mp_identity<L<W...>> f( U*..., mp_identity<W>*... );

    using R = decltype( f( static_cast<mp_identity<T>*>(0) ... ) );

    using type = typename R::type;
};

}

template<class L, std::size_t N> using mp_drop_c = mp_assign<L, typename detail::mp_drop_impl<mp_rename<L, mp_list>, mp_repeat_c<mp_list<void>, N>, mp_bool<N <= mp_size<L>::value>>::type>;

template<class L, class N> using mp_drop = mp_drop_c<L, std::size_t{ N::value }>;


namespace detail
{

template<class S, class F> struct mp_from_sequence_impl;

template<template<class T, T... I> class S, class U, U... J, class F> struct mp_from_sequence_impl<S<U, J...>, F>
{
    using type = mp_list_c<U, (F::value + J)...>;
};

}

template<class S, class F = mp_int<0>> using mp_from_sequence = typename detail::mp_from_sequence_impl<S, F>::type;


template<std::size_t N, std::size_t F = 0> using mp_iota_c = mp_from_sequence<make_index_sequence<N>, mp_size_t<F>>;
template<class N, class F = mp_int<0>> using mp_iota = mp_from_sequence<make_integer_sequence<typename std::remove_const<decltype(N::value)>::type, N::value>, F>;


namespace detail
{

template<class L, std::size_t I> struct mp_at_c_impl;



template<template<class...> class L, class... T, std::size_t I> struct mp_at_c_impl<L<T...>, I>
{
    using type = __type_pack_element<I, T...>;
};



template<template<auto...> class L, auto... A, std::size_t I> struct mp_at_c_impl<L<A...>, I>
{
    using type = __type_pack_element<I, mp_value<A>...>;
};
# 383 "/usr/include/boost/mp11/algorithm.hpp" 3 4
}







template<class L, std::size_t I> using mp_at_c = typename mp_if_c<(I < mp_size<L>::value), detail::mp_at_c_impl<L, I>, void>::type;



template<class L, class I> using mp_at = mp_at_c<L, std::size_t{ I::value }>;


namespace detail
{

template<std::size_t N, class L, class E = void> struct mp_take_c_impl
{
};

template<template<class...> class L, class... T>
struct mp_take_c_impl<0, L<T...>>
{
    using type = L<>;
};

template<template<class...> class L, class T1, class... T>
struct mp_take_c_impl<1, L<T1, T...>>
{
    using type = L<T1>;
};

template<template<class...> class L, class T1, class T2, class... T>
struct mp_take_c_impl<2, L<T1, T2, T...>>
{
    using type = L<T1, T2>;
};

template<template<class...> class L, class T1, class T2, class T3, class... T>
struct mp_take_c_impl<3, L<T1, T2, T3, T...>>
{
    using type = L<T1, T2, T3>;
};

template<template<class...> class L, class T1, class T2, class T3, class T4, class... T>
struct mp_take_c_impl<4, L<T1, T2, T3, T4, T...>>
{
    using type = L<T1, T2, T3, T4>;
};

template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class... T>
struct mp_take_c_impl<5, L<T1, T2, T3, T4, T5, T...>>
{
    using type = L<T1, T2, T3, T4, T5>;
};

template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class... T>
struct mp_take_c_impl<6, L<T1, T2, T3, T4, T5, T6, T...>>
{
    using type = L<T1, T2, T3, T4, T5, T6>;
};

template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class... T>
struct mp_take_c_impl<7, L<T1, T2, T3, T4, T5, T6, T7, T...>>
{
    using type = L<T1, T2, T3, T4, T5, T6, T7>;
};

template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class... T>
struct mp_take_c_impl<8, L<T1, T2, T3, T4, T5, T6, T7, T8, T...>>
{
    using type = L<T1, T2, T3, T4, T5, T6, T7, T8>;
};

template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class... T>
struct mp_take_c_impl<9, L<T1, T2, T3, T4, T5, T6, T7, T8, T9, T...>>
{
    using type = L<T1, T2, T3, T4, T5, T6, T7, T8, T9>;
};

template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class... T, std::size_t N>
struct mp_take_c_impl<N, L<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T...>, typename std::enable_if<N >= 10>::type>
{
    using type = mp_append<L<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>, typename mp_take_c_impl<N-10, L<T...>>::type>;
};

}

template<class L, std::size_t N> using mp_take_c = mp_assign<L, typename detail::mp_take_c_impl<N, mp_rename<L, mp_list>>::type>;
template<class L, class N> using mp_take = mp_take_c<L, std::size_t{ N::value }>;


template<class L> using mp_back = mp_at_c<L, mp_size<L>::value - 1>;


template<class L> using mp_pop_back = mp_take_c<L, mp_size<L>::value - 1>;


namespace detail
{

template<class L, class V, class W> struct mp_replace_impl;

template<template<class...> class L, class... T, class V, class W> struct mp_replace_impl<L<T...>, V, W>
{




    template<class A> using _f = mp_if<std::is_same<A, V>, W, A>;
    using type = L<_f<T>...>;

};

}

template<class L, class V, class W> using mp_replace = typename detail::mp_replace_impl<L, V, W>::type;


namespace detail
{

template<class L, template<class...> class P, class W> struct mp_replace_if_impl;

template<template<class...> class L, class... T, template<class...> class P, class W> struct mp_replace_if_impl<L<T...>, P, W>
{




    template<class U> using _f = mp_if<P<U>, W, U>;
    using type = L<_f<T>...>;

};

}

template<class L, template<class...> class P, class W> using mp_replace_if = typename detail::mp_replace_if_impl<L, P, W>::type;
template<class L, class Q, class W> using mp_replace_if_q = mp_replace_if<L, Q::template fn, W>;





namespace detail
{

template<class L, class V> struct mp_remove_impl;

template<template<class...> class L, class... T, class V> struct mp_remove_impl<L<T...>, V>
{




    template<class U> using _f = mp_if<std::is_same<U, V>, mp_list<>, mp_list<U>>;
    using type = mp_append<L<>, _f<T>...>;

};

}

template<class L, class V> using mp_remove = typename detail::mp_remove_impl<L, V>::type;





namespace detail
{

template<class L2> struct mp_flatten_impl
{
    template<class T> using fn = mp_if<mp_similar<L2, T>, T, mp_list<T>>;
};

}

template<class L, class L2 = mp_clear<L>> using mp_flatten = mp_apply<mp_append, mp_push_front<mp_transform_q<detail::mp_flatten_impl<L2>, L>, mp_clear<L>>>;


namespace detail
{

template<class L, template<class...> class P> struct mp_partition_impl;

template<template<class...> class L, class... T, template<class...> class P> struct mp_partition_impl<L<T...>, P>
{
    using type = L<mp_copy_if<L<T...>, P>, mp_remove_if<L<T...>, P>>;
};

}

template<class L, template<class...> class P> using mp_partition = typename detail::mp_partition_impl<L, P>::type;
template<class L, class Q> using mp_partition_q = mp_partition<L, Q::template fn>;


namespace detail
{

template<class L, template<class...> class P> struct mp_sort_impl;
# 597 "/usr/include/boost/mp11/algorithm.hpp" 3 4
template<template<class...> class L, template<class...> class P> struct mp_sort_impl<L<>, P>
{
    using type = L<>;
};



template<template<class...> class L, class T1, template<class...> class P> struct mp_sort_impl<L<T1>, P>
{
    using type = L<T1>;
};

template<template<class...> class L, class T1, class... T, template<class...> class P> struct mp_sort_impl<L<T1, T...>, P>
{
    template<class U> using F = P<U, T1>;

    using part = mp_partition<L<T...>, F>;

    using S1 = typename mp_sort_impl<mp_first<part>, P>::type;
    using S2 = typename mp_sort_impl<mp_second<part>, P>::type;

    using type = mp_append<mp_push_back<S1, T1>, S2>;
};

}

template<class L, template<class...> class P> using mp_sort = typename detail::mp_sort_impl<L, P>::type;
template<class L, class Q> using mp_sort_q = mp_sort<L, Q::template fn>;


namespace detail
{

template<class L, std::size_t I, template<class...> class P> struct mp_nth_element_impl;

template<template<class...> class L, class T1, std::size_t I, template<class...> class P> struct mp_nth_element_impl<L<T1>, I, P>
{
    static_assert( I == 0, "mp_nth_element index out of range" );
    using type = T1;
};

template<template<class...> class L, class T1, class... T, std::size_t I, template<class...> class P> struct mp_nth_element_impl<L<T1, T...>, I, P>
{
    static_assert( I < 1 + sizeof...(T), "mp_nth_element index out of range" );

    template<class U> using F = P<U, T1>;

    using part = mp_partition<L<T...>, F>;

    using L1 = mp_first<part>;
    static std::size_t const N1 = mp_size<L1>::value;

    using L2 = mp_second<part>;
# 671 "/usr/include/boost/mp11/algorithm.hpp" 3 4
    using type = typename mp_cond<

        mp_bool<(I < N1)>, mp_nth_element_impl<L1, I, P>,
        mp_bool<(I == N1)>, mp_identity<T1>,
        mp_true, mp_nth_element_impl<L2, I - N1 - 1, P>

    >::type;


};

}

template<class L, std::size_t I, template<class...> class P> using mp_nth_element_c = typename detail::mp_nth_element_impl<L, I, P>::type;
template<class L, class I, template<class...> class P> using mp_nth_element = typename detail::mp_nth_element_impl<L, std::size_t{ I::value }, P>::type;
template<class L, class I, class Q> using mp_nth_element_q = mp_nth_element<L, I, Q::template fn>;


namespace detail
{

template<class L, class V> struct mp_find_impl;



struct mp_index_holder
{
    std::size_t i_;
    bool f_;
};

constexpr inline mp_index_holder operator+( mp_index_holder const & v, bool f )
{
    if( v.f_ )
    {
        return v;
    }
    else if( f )
    {
        return { v.i_, true };
    }
    else
    {
        return { v.i_ + 1, false };
    }
}

template<template<class...> class L, class... T, class V> struct mp_find_impl<L<T...>, V>
{
    static constexpr mp_index_holder _v{ 0, false };
    using type = mp_size_t< (_v + ... + std::is_same<T, V>::value).i_ >;
};
# 793 "/usr/include/boost/mp11/algorithm.hpp" 3 4
}

template<class L, class V> using mp_find = typename detail::mp_find_impl<L, V>::type;


namespace detail
{

template<class L, template<class...> class P> struct mp_find_if_impl;



template<template<class...> class L, class... T, template<class...> class P> struct mp_find_if_impl<L<T...>, P>
{
    static constexpr mp_index_holder _v{ 0, false };
    using type = mp_size_t< (_v + ... + P<T>::value).i_ >;
};
# 856 "/usr/include/boost/mp11/algorithm.hpp" 3 4
}

template<class L, template<class...> class P> using mp_find_if = typename detail::mp_find_if_impl<L, P>::type;
template<class L, class Q> using mp_find_if_q = mp_find_if<L, Q::template fn>;


namespace detail
{

template<class L> struct mp_reverse_impl;
# 877 "/usr/include/boost/mp11/algorithm.hpp" 3 4
template<template<class...> class L> struct mp_reverse_impl<L<>>
{
    using type = L<>;
};



template<template<class...> class L, class T1> struct mp_reverse_impl<L<T1>>
{
    using type = L<T1>;
};

template<template<class...> class L, class T1, class T2> struct mp_reverse_impl<L<T1, T2>>
{
    using type = L<T2, T1>;
};

template<template<class...> class L, class T1, class T2, class T3> struct mp_reverse_impl<L<T1, T2, T3>>
{
    using type = L<T3, T2, T1>;
};

template<template<class...> class L, class T1, class T2, class T3, class T4> struct mp_reverse_impl<L<T1, T2, T3, T4>>
{
    using type = L<T4, T3, T2, T1>;
};

template<template<class...> class L, class T1, class T2, class T3, class T4, class T5> struct mp_reverse_impl<L<T1, T2, T3, T4, T5>>
{
    using type = L<T5, T4, T3, T2, T1>;
};

template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6> struct mp_reverse_impl<L<T1, T2, T3, T4, T5, T6>>
{
    using type = L<T6, T5, T4, T3, T2, T1>;
};

template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7> struct mp_reverse_impl<L<T1, T2, T3, T4, T5, T6, T7>>
{
    using type = L<T7, T6, T5, T4, T3, T2, T1>;
};

template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8> struct mp_reverse_impl<L<T1, T2, T3, T4, T5, T6, T7, T8>>
{
    using type = L<T8, T7, T6, T5, T4, T3, T2, T1>;
};

template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9> struct mp_reverse_impl<L<T1, T2, T3, T4, T5, T6, T7, T8, T9>>
{
    using type = L<T9, T8, T7, T6, T5, T4, T3, T2, T1>;
};

template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class... T> struct mp_reverse_impl<L<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T...>>
{
    using type = mp_push_back<typename mp_reverse_impl<L<T...>>::type, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1>;
};

}

template<class L> using mp_reverse = typename detail::mp_reverse_impl<L>::type;





namespace detail
{

template<class L, class V, template<class...> class F> struct mp_reverse_fold_impl;
# 957 "/usr/include/boost/mp11/algorithm.hpp" 3 4
template<template<class...> class L, class V, template<class...> class F> struct mp_reverse_fold_impl<L<>, V, F>
{
    using type = V;
};



template<template<class...> class L, class T1, class... T, class V, template<class...> class F> struct mp_reverse_fold_impl<L<T1, T...>, V, F>
{
    using rest = typename mp_reverse_fold_impl<L<T...>, V, F>::type;
    using type = F<T1, rest>;
};

template<template<class...> class L, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10, class... T, class V, template<class...> class F> struct mp_reverse_fold_impl<L<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T...>, V, F>
{
    using rest = typename mp_reverse_fold_impl<L<T...>, V, F>::type;
    using type = F<T1, F<T2, F<T3, F<T4, F<T5, F<T6, F<T7, F<T8, F<T9, F<T10, rest> > > > > > > > > >;
};

}

template<class L, class V, template<class...> class F> using mp_reverse_fold = typename detail::mp_reverse_fold_impl<L, V, F>::type;
template<class L, class V, class Q> using mp_reverse_fold_q = mp_reverse_fold<L, V, Q::template fn>;


namespace detail
{

template<class L> struct mp_unique_impl;

template<template<class...> class L, class... T> struct mp_unique_impl<L<T...>>
{
    using type = mp_set_push_back<L<>, T...>;
};

}

template<class L> using mp_unique = typename detail::mp_unique_impl<L>::type;


namespace detail
{

template<template<class...> class P> struct mp_unique_if_push_back
{
    template<class...> struct impl
    {
    };

    template<template<class...> class L, class... Ts, class T>
    struct impl<L<Ts...>, T>
    {
        using type = mp_if<mp_any<P<Ts, T>...>, L<Ts...>, L<Ts..., T>>;
    };

    template<class... T> using fn = typename impl<T...>::type;
};

}

template<class L, template<class...> class P>
using mp_unique_if = mp_fold_q<L, mp_clear<L>, detail::mp_unique_if_push_back<P>>;

template<class L, class Q> using mp_unique_if_q = mp_unique_if<L, Q::template fn>;


template<class L, template<class...> class P> using mp_all_of = mp_bool< mp_count_if<L, P>::value == mp_size<L>::value >;
template<class L, class Q> using mp_all_of_q = mp_all_of<L, Q::template fn>;


template<class L, template<class...> class P> using mp_none_of = mp_bool< mp_count_if<L, P>::value == 0 >;
template<class L, class Q> using mp_none_of_q = mp_none_of<L, Q::template fn>;


template<class L, template<class...> class P> using mp_any_of = mp_bool< mp_count_if<L, P>::value != 0 >;
template<class L, class Q> using mp_any_of_q = mp_any_of<L, Q::template fn>;


namespace detail
{

template<class L, class I, class W> struct mp_replace_at_impl
{
    static_assert( I::value >= 0, "mp_replace_at<L, I, W>: I must not be negative" );

    template<class T1, class T2> using _p = std::is_same<T2, mp_size_t<I::value>>;
    template<class T1, class T2> using _f = W;

    using type = mp_transform_if<_p, _f, L, mp_iota<mp_size<L> > >;
};

}

template<class L, class I, class W> using mp_replace_at = typename detail::mp_replace_at_impl<L, I, W>::type;
template<class L, std::size_t I, class W> using mp_replace_at_c = typename detail::mp_replace_at_impl<L, mp_size_t<I>, W>::type;


namespace detail
{

template<class... T, class F> constexpr F mp_for_each_impl( mp_list<T...>, F && f )
{
    using A = int[sizeof...(T)];
    return (void)A{ ((void)f(T()), 0)... }, std::forward<F>(f);
}

template<class F> constexpr F mp_for_each_impl( mp_list<>, F && f )
{
    return std::forward<F>(f);
}

}
# 1091 "/usr/include/boost/mp11/algorithm.hpp" 3 4
template<class L, class F> constexpr F mp_for_each( F && f )
{
    return detail::mp_for_each_impl( mp_rename<L, mp_list>(), std::forward<F>(f) );
}




template<class L, class I, class... T> using mp_insert = mp_append<mp_take<L, I>, mp_push_front<mp_drop<L, I>, T...>>;


template<class L, std::size_t I, class... T> using mp_insert_c = mp_append<mp_take_c<L, I>, mp_push_front<mp_drop_c<L, I>, T...>>;


template<class L, class I, class J> using mp_erase = mp_append<mp_take<L, I>, mp_drop<L, J>>;


template<class L, std::size_t I, std::size_t J> using mp_erase_c = mp_append<mp_take_c<L, I>, mp_drop_c<L, J>>;



namespace detail {

template<class L1, class L2>
struct mp_starts_with_impl { };

template<template<class...> class L1, class... T1, template<class...> class L2,
    class... T2>
struct mp_starts_with_impl<L1<T1...>, L2<T2...> > {
    template<class L>
    static mp_false check(L);

    template<class... T>
    static mp_true check(mp_list<T2..., T...>);

    using type = decltype(check(mp_list<T1...>()));
};

}

template<class L1, class L2>
using mp_starts_with = typename detail::mp_starts_with_impl<L1, L2>::type;


namespace detail
{


template<std::size_t Ln, std::size_t N> using canonical_left_rotation = mp_size_t<N % (Ln == 0? 1: Ln)>;


template<std::size_t Ln, std::size_t N> using canonical_right_rotation = mp_size_t<Ln - N % (Ln == 0? 1: Ln)>;


template<class L, class N, class L2 = mp_rename<L, mp_list>> using mp_rotate_impl = mp_assign<L, mp_append< mp_drop<L2, N>, mp_take<L2, N> >>;

}

template<class L, std::size_t N> using mp_rotate_left_c = detail::mp_rotate_impl<L, detail::canonical_left_rotation<mp_size<L>::value, N>>;
template<class L, class N> using mp_rotate_left = mp_rotate_left_c<L, std::size_t{ N::value }>;


template<class L, std::size_t N> using mp_rotate_right_c = mp_rotate_left<L, detail::canonical_right_rotation<mp_size<L>::value, N>>;
template<class L, class N> using mp_rotate_right = mp_rotate_right_c<L, std::size_t{ N::value }>;






namespace detail
{

template<class L> struct mp_power_set_impl;

}

template<class L> using mp_power_set = typename detail::mp_power_set_impl<L>::type;

namespace detail
{
# 1183 "/usr/include/boost/mp11/algorithm.hpp" 3 4
template<template<class...> class L> struct mp_power_set_impl< L<> >
{
    using type = L< L<> >;
};



template<template<class...> class L, class T1, class... T> struct mp_power_set_impl< L<T1, T...> >
{
    using S1 = mp_power_set< L<T...> >;

    template<class L2> using _f = mp_push_front<L2, T1>;

    using S2 = mp_transform<_f, S1>;

    using type = mp_append< S1, S2 >;
};

}


namespace detail
{

template<template<class...> class F> struct mp_partial_sum_impl_f
{






    template<class V, class T, class N = F<mp_first<V>, T>> using fn = mp_list<N, mp_push_back<mp_second<V>, N>>;


};

}

template<class L, class V, template<class...> class F> using mp_partial_sum = mp_second<mp_fold_q<L, mp_list<V, mp_clear<L>>, detail::mp_partial_sum_impl_f<F>> >;
template<class L, class V, class Q> using mp_partial_sum_q = mp_partial_sum<L, V, Q::template fn>;


namespace detail
{

template<class V, template<class...> class F, template<class...> class R, class N> struct mp_iterate_impl;

}

template<class V, template<class...> class F, template<class...> class R> using mp_iterate = typename detail::mp_iterate_impl<V, F, R, mp_valid<R, V>>::type;

namespace detail
{

template<class V, template<class...> class F, template<class...> class R> struct mp_iterate_impl<V, F, R, mp_false>
{
    template<class X> using _f = mp_list<F<X>>;
    using type = mp_eval_or<mp_list<>, _f, V>;
};

template<class V, template<class...> class F, template<class...> class R> struct mp_iterate_impl<V, F, R, mp_true>
{
    using type = mp_push_front<mp_iterate<R<V>, F, R>, F<V>>;
};

}

template<class V, class Qf, class Qr> using mp_iterate_q = mp_iterate<V, Qf::template fn, Qr::template fn>;


namespace detail
{

template<class L, class Q> using mp_pairwise_fold_impl = mp_transform_q<Q, mp_pop_back<L>, mp_pop_front<L>>;

}

template<class L, class Q> using mp_pairwise_fold_q = mp_eval_if<mp_empty<L>, mp_clear<L>, detail::mp_pairwise_fold_impl, L, Q>;
template<class L, template<class...> class F> using mp_pairwise_fold = mp_pairwise_fold_q<L, mp_quote<F>>;


namespace detail
{

template<class L, class S> struct mp_intersperse_impl
{
};
# 1282 "/usr/include/boost/mp11/algorithm.hpp" 3 4
template<template<class...> class L, class S> struct mp_intersperse_impl<L<>, S>
{
    using type = L<>;
};



template<template<class...> class L, class T1, class... T, class S> struct mp_intersperse_impl<L<T1, T...>, S>
{
    using type = mp_append<L<T1>, L<S, T>...>;
};

}

template<class L, class S> using mp_intersperse = typename detail::mp_intersperse_impl<L, S>::type;


namespace detail
{

template<class L, class S, class J> struct mp_split_impl;

}

template<class L, class S> using mp_split = typename detail::mp_split_impl<L, S, mp_find<L, S>>::type;

namespace detail
{

template<class L, class S, class J> using mp_split_impl_ = mp_push_front<mp_split<mp_drop_c<L, J::value + 1>, S>, mp_take<L, J>>;

template<class L, class S, class J> struct mp_split_impl
{
    using type = mp_eval_if_c<mp_size<L>::value == J::value, mp_push_back<mp_clear<L>, L>, mp_split_impl_, L, S, J>;
};

}



template<class L, class S> using mp_join = mp_apply<mp_append, mp_intersperse<L, mp_list<S>>>;

}
}
# 15 "/usr/include/boost/describe/bases.hpp" 2 3 4


namespace boost
{
namespace describe
{
namespace detail
{

template<class T> using _describe_bases = decltype( boost_base_descriptor_fn( static_cast<T**>(0) ) );

template<unsigned M> struct base_filter
{
    template<class T> using fn = mp11::mp_bool< ( M & mod_any_access & T::modifiers ) != 0 >;
};

template<class T, class En = void> struct has_describe_bases: std::false_type
{
};

template<class T> struct has_describe_bases<T, void_t<_describe_bases<T>>>: std::true_type
{
};

}

template<class T, unsigned M> using describe_bases = mp11::mp_copy_if_q<detail::_describe_bases<T>, detail::base_filter<M>>;

template<class T> using has_describe_bases = detail::has_describe_bases<T>;

}
}
# 11 "/usr/include/boost/container_hash/is_described_class.hpp" 2 3 4
# 1 "/usr/include/boost/describe/members.hpp" 1 3 4
# 11 "/usr/include/boost/describe/members.hpp" 3 4
# 1 "/usr/include/boost/describe/detail/cx_streq.hpp" 1 3 4
# 12 "/usr/include/boost/describe/detail/cx_streq.hpp" 3 4
namespace boost
{
namespace describe
{
namespace detail
{

constexpr bool cx_streq( char const * s1, char const * s2 )
{
    return s1[0] == s2[0] && ( s1[0] == 0 || cx_streq( s1 + 1, s2 + 1 ) );
}

}
}
}
# 12 "/usr/include/boost/describe/members.hpp" 2 3 4








# 1 "/usr/include/boost/mp11/bind.hpp" 1 3 4
# 15 "/usr/include/boost/mp11/bind.hpp" 3 4
namespace boost
{
namespace mp11
{


template<template<class...> class F, class... T> struct mp_bind_front
{



    template<class... U> using fn = typename mp_defer<F, T..., U...>::type;
};

template<class Q, class... T> using mp_bind_front_q = mp_bind_front<Q::template fn, T...>;


template<template<class...> class F, class... T> struct mp_bind_back
{
    template<class... U> using fn = typename mp_defer<F, U..., T...>::type;
};

template<class Q, class... T> using mp_bind_back_q = mp_bind_back<Q::template fn, T...>;


template<std::size_t I> struct mp_arg
{
    template<class... T> using fn = mp_at_c<mp_list<T...>, I>;
};

using _1 = mp_arg<0>;
using _2 = mp_arg<1>;
using _3 = mp_arg<2>;
using _4 = mp_arg<3>;
using _5 = mp_arg<4>;
using _6 = mp_arg<5>;
using _7 = mp_arg<6>;
using _8 = mp_arg<7>;
using _9 = mp_arg<8>;


template<template<class...> class F, class... T> struct mp_bind;

namespace detail
{

template<class V, class... T> struct eval_bound_arg
{
    using type = V;
};

template<std::size_t I, class... T> struct eval_bound_arg<mp_arg<I>, T...>
{
    using type = typename mp_arg<I>::template fn<T...>;
};

template<template<class...> class F, class... U, class... T> struct eval_bound_arg<mp_bind<F, U...>, T...>
{
    using type = typename mp_bind<F, U...>::template fn<T...>;
};

template<template<class...> class F, class... U, class... T> struct eval_bound_arg<mp_bind_front<F, U...>, T...>
{
    using type = typename mp_bind_front<F, U...>::template fn<T...>;
};

template<template<class...> class F, class... U, class... T> struct eval_bound_arg<mp_bind_back<F, U...>, T...>
{
    using type = typename mp_bind_back<F, U...>::template fn<T...>;
};

}

template<template<class...> class F, class... T> struct mp_bind
{
# 101 "/usr/include/boost/mp11/bind.hpp" 3 4
    template<class... U> using fn = F<typename detail::eval_bound_arg<T, U...>::type...>;


};

template<class Q, class... T> using mp_bind_q = mp_bind<Q::template fn, T...>;

}
}
# 21 "/usr/include/boost/describe/members.hpp" 2 3 4


namespace boost
{
namespace describe
{
namespace detail
{



template<class T> using _describe_public_members = decltype( boost_public_member_descriptor_fn( static_cast<T**>(0) ) );
template<class T> using _describe_protected_members = decltype( boost_protected_member_descriptor_fn( static_cast<T**>(0) ) );
template<class T> using _describe_private_members = decltype( boost_private_member_descriptor_fn( static_cast<T**>(0) ) );

template<class T> using _describe_members = mp11::mp_append<_describe_public_members<T>, _describe_protected_members<T>, _describe_private_members<T>>;





template<class T, class V> struct describe_inherited_members_impl;
template<class T, class V> using describe_inherited_members = typename describe_inherited_members_impl<T, V>::type;




template<class L, class T, class V> struct describe_inherited_members2_impl;
template<class L, class T, class V> using describe_inherited_members2 = typename describe_inherited_members2_impl<L, T, V>::type;

template<class T, class V> struct describe_inherited_members_impl
{
    using R1 = describe_inherited_members2<describe_bases<T, mod_any_access>, T, V>;
    using R2 = _describe_members<T>;

    using type = mp11::mp_append<R1, R2>;
};

template<template<class...> class L, class T, class V> struct describe_inherited_members2_impl<L<>, T, V>
{
    using type = L<>;
};

template<class D1, class D2> using name_matches = mp11::mp_bool< cx_streq( D1::name, D2::name ) >;

template<class D, class L> using name_is_hidden = mp11::mp_any_of_q<L, mp11::mp_bind_front<name_matches, D>>;

constexpr unsigned cx_max( unsigned m1, unsigned m2 )
{
    return m1 > m2? m1: m2;
}

template<class T, unsigned Bm> struct update_modifiers
{
    template<class D> struct fn
    {
        using L = _describe_members<T>;
        static constexpr unsigned hidden = name_is_hidden<D, L>::value? mod_hidden: 0;

        static constexpr unsigned mods = D::modifiers;
        static constexpr unsigned access = cx_max( mods & mod_any_access, Bm & mod_any_access );

        static constexpr decltype(D::pointer) pointer = D::pointer;
        static constexpr decltype(D::name) name = D::name;
        static constexpr unsigned modifiers = ( mods & ~mod_any_access ) | access | mod_inherited | hidden;
    };
};







template<class D> struct gather_virtual_bases_impl;
template<class D> using gather_virtual_bases = typename gather_virtual_bases_impl<D>::type;

template<class D> struct gather_virtual_bases_impl
{
    using B = typename D::type;
    static constexpr unsigned M = D::modifiers;

    using R1 = mp11::mp_transform<gather_virtual_bases, describe_bases<B, mod_any_access>>;
    using R2 = mp11::mp_apply<mp11::mp_append, R1>;

    using type = mp11::mp_if_c<(M & mod_virtual) != 0, mp11::mp_push_front<R2, B>, R2>;
};

template<template<class...> class L, class D1, class... D, class T, class V> struct describe_inherited_members2_impl<L<D1, D...>, T, V>
{
    using B = typename D1::type;
    static constexpr unsigned M = D1::modifiers;

    using R1 = mp11::mp_if_c<(M & mod_virtual) && mp11::mp_contains<V, B>::value, L<>, describe_inherited_members<B, V>>;

    using R2 = mp11::mp_transform_q<update_modifiers<T, M>, R1>;

    using V2 = mp11::mp_append<V, gather_virtual_bases<D1>>;
    using R3 = describe_inherited_members2<L<D...>, T, V2>;

    using type = mp11::mp_append<R2, R3>;
};



template<class T, unsigned M> using describe_members = mp11::mp_eval_if_c<(M & mod_inherited) == 0, _describe_members<T>, describe_inherited_members, T, mp11::mp_list<>>;



template<unsigned M> struct member_filter
{
    template<class T> using fn = mp11::mp_bool<
        (M & mod_any_access & T::modifiers) != 0 &&
        ( (M & mod_any_member) != 0 || (M & mod_static) == (T::modifiers & mod_static) ) &&
        ( (M & mod_any_member) != 0 || (M & mod_function) == (T::modifiers & mod_function) ) &&
        (M & mod_hidden) >= (T::modifiers & mod_hidden)
    >;
};



template<class T, class En = void> struct has_describe_members: std::false_type
{
};

template<class T> struct has_describe_members<T, void_t<_describe_members<T>>>: std::true_type
{
};

}

template<class T, unsigned M> using describe_members = mp11::mp_copy_if_q<detail::describe_members<T, M>, detail::member_filter<M>>;

template<class T> using has_describe_members = detail::has_describe_members<T>;

}
}
# 12 "/usr/include/boost/container_hash/is_described_class.hpp" 2 3 4

namespace boost
{
namespace container_hash
{



template<class T> struct is_described_class: boost::integral_constant<bool,
    describe::has_describe_bases<T>::value &&
    describe::has_describe_members<T>::value &&
    !boost::is_union<T>::value>
{
};
# 35 "/usr/include/boost/container_hash/is_described_class.hpp" 3 4
}
}
# 19 "/usr/include/boost/container_hash/hash.hpp" 2 3 4
# 1 "/usr/include/boost/container_hash/detail/hash_tuple_like.hpp" 1 3 4
# 10 "/usr/include/boost/container_hash/detail/hash_tuple_like.hpp" 3 4
# 1 "/usr/include/boost/container_hash/is_tuple_like.hpp" 1 3 4
# 13 "/usr/include/boost/container_hash/is_tuple_like.hpp" 3 4
namespace boost
{
namespace hash_detail
{

template<class T, class E = true_type> struct is_tuple_like_: false_type
{
};



template<class T> struct is_tuple_like_<T, integral_constant<bool, std::tuple_size<T>::value == std::tuple_size<T>::value> >: true_type
{
};



}

namespace container_hash
{

template<class T> struct is_tuple_like: hash_detail::is_tuple_like_<T>
{
};

}
}
# 11 "/usr/include/boost/container_hash/detail/hash_tuple_like.hpp" 2 3 4

# 1 "/usr/include/boost/type_traits/enable_if.hpp" 1 3 4
# 20 "/usr/include/boost/type_traits/enable_if.hpp" 3 4
namespace boost {

template<bool B, class T = void>
struct enable_if_ {
    typedef T type;
};

template<class T>
struct enable_if_<false, T> { };


template<bool B, class T = void>
using enable_if_t = typename enable_if_<B, T>::type;


}
# 13 "/usr/include/boost/container_hash/detail/hash_tuple_like.hpp" 2 3 4
# 24 "/usr/include/boost/container_hash/detail/hash_tuple_like.hpp" 3 4
namespace boost
{
namespace hash_detail
{

template <std::size_t I, typename T>
inline
typename boost::enable_if_<(I == std::tuple_size<T>::value), void>::type
    hash_combine_tuple_like( std::size_t&, T const& )
{
}

template <std::size_t I, typename T>
inline
typename boost::enable_if_<(I < std::tuple_size<T>::value), void>::type
    hash_combine_tuple_like( std::size_t& seed, T const& v )
{
    using std::get;
    boost::hash_combine( seed, get<I>( v ) );

    boost::hash_detail::hash_combine_tuple_like<I + 1>( seed, v );
}

template <typename T>
inline std::size_t hash_tuple_like( T const& v )
{
    std::size_t seed = 0;

    boost::hash_detail::hash_combine_tuple_like<0>( seed, v );

    return seed;
}

}





template <class T>
inline
typename boost::enable_if_<
    container_hash::is_tuple_like<T>::value && !container_hash::is_range<T>::value,
std::size_t>::type
    hash_value( T const& v )
{
    return boost::hash_detail::hash_tuple_like( v );
}
# 152 "/usr/include/boost/container_hash/detail/hash_tuple_like.hpp" 3 4
}
# 20 "/usr/include/boost/container_hash/hash.hpp" 2 3 4
# 1 "/usr/include/boost/container_hash/detail/hash_mix.hpp" 1 3 4







# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 9 "/usr/include/boost/container_hash/detail/hash_mix.hpp" 2 3 4

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/climits" 1 3 4
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/climits" 3
# 11 "/usr/include/boost/container_hash/detail/hash_mix.hpp" 2 3 4

namespace boost
{
namespace hash_detail
{

template<std::size_t Bits> struct hash_mix_impl;
# 67 "/usr/include/boost/container_hash/detail/hash_mix.hpp" 3 4
template<> struct hash_mix_impl<64>
{
    inline static boost::uint64_t fn( boost::uint64_t x )
    {
        boost::uint64_t const m = (boost::uint64_t(0xe9846af) << 32) + 0x9b1a615d;

        x ^= x >> 32;
        x *= m;
        x ^= x >> 32;
        x *= m;
        x ^= x >> 28;

        return x;
    }
};






template<> struct hash_mix_impl<32>
{
    inline static boost::uint32_t fn( boost::uint32_t x )
    {
        boost::uint32_t const m1 = 0x21f0aaad;
        boost::uint32_t const m2 = 0x735a2d97;

        x ^= x >> 16;
        x *= m1;
        x ^= x >> 15;
        x *= m2;
        x ^= x >> 15;

        return x;
    }
};

inline std::size_t hash_mix( std::size_t v )
{
    return hash_mix_impl<sizeof(std::size_t) * 8>::fn( v );
}

}
}
# 21 "/usr/include/boost/container_hash/hash.hpp" 2 3 4
# 1 "/usr/include/boost/container_hash/detail/hash_range.hpp" 1 3 4








# 1 "/usr/include/boost/container_hash/detail/mulx.hpp" 1 3 4







# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 9 "/usr/include/boost/container_hash/detail/mulx.hpp" 2 3 4




namespace boost
{
namespace hash_detail
{
# 38 "/usr/include/boost/container_hash/detail/mulx.hpp" 3 4
inline boost::uint64_t mulx( boost::uint64_t x, boost::uint64_t y )
{
    __uint128_t r = static_cast<__uint128_t>( x ) * y;
    return static_cast<boost::uint64_t>( r ) ^ static_cast<boost::uint64_t>( r >> 64 );
}
# 76 "/usr/include/boost/container_hash/detail/mulx.hpp" 3 4
}
}
# 10 "/usr/include/boost/container_hash/detail/hash_range.hpp" 2 3 4



# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 14 "/usr/include/boost/container_hash/detail/hash_range.hpp" 2 3 4



# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/climits" 1 3 4
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/climits" 3
# 18 "/usr/include/boost/container_hash/detail/hash_range.hpp" 2 3 4
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 1 3 4
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 3


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 43 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 2 3
# 19 "/usr/include/boost/container_hash/detail/hash_range.hpp" 2 3 4

namespace boost
{
namespace hash_detail
{

template<class T> struct is_char_type: public boost::false_type {};



template<> struct is_char_type<char>: public boost::true_type {};
template<> struct is_char_type<signed char>: public boost::true_type {};
template<> struct is_char_type<unsigned char>: public boost::true_type {};


template<> struct is_char_type<char8_t>: public boost::true_type {};



template<> struct is_char_type<std::byte>: public boost::true_type {};






template<class It>
inline typename boost::enable_if_<
    !is_char_type<typename std::iterator_traits<It>::value_type>::value,
std::size_t >::type
    hash_range( std::size_t seed, It first, It last )
{
    for( ; first != last; ++first )
    {
        hash_combine<typename std::iterator_traits<It>::value_type>( seed, *first );
    }

    return seed;
}



template<class It> inline boost::uint32_t read32le( It p )
{



    boost::uint32_t w =
        static_cast<boost::uint32_t>( static_cast<unsigned char>( p[0] ) ) |
        static_cast<boost::uint32_t>( static_cast<unsigned char>( p[1] ) ) << 8 |
        static_cast<boost::uint32_t>( static_cast<unsigned char>( p[2] ) ) << 16 |
        static_cast<boost::uint32_t>( static_cast<unsigned char>( p[3] ) ) << 24;

    return w;
}
# 87 "/usr/include/boost/container_hash/detail/hash_range.hpp" 3 4
inline boost::uint64_t mul32( boost::uint32_t x, boost::uint32_t y )
{
    return static_cast<boost::uint64_t>( x ) * y;
}

template<class It>
inline typename boost::enable_if_<
    is_char_type<typename std::iterator_traits<It>::value_type>::value &&
    is_same<typename std::iterator_traits<It>::iterator_category, std::random_access_iterator_tag>::value &&
    std::numeric_limits<std::size_t>::digits <= 32,
std::size_t>::type
    hash_range( std::size_t seed, It first, It last )
{
    It p = first;
    std::size_t n = static_cast<std::size_t>( last - first );

    boost::uint32_t const q = 0x9e3779b9U;
    boost::uint32_t const k = 0xe35e67b1U;

    boost::uint64_t h = mul32( static_cast<boost::uint32_t>( seed ) + q, k );
    boost::uint32_t w = static_cast<boost::uint32_t>( h & 0xFFFFFFFF );

    h ^= n;

    while( n >= 4 )
    {
        boost::uint32_t v1 = read32le( p );

        w += q;
        h ^= mul32( v1 + w, k );

        p += 4;
        n -= 4;
    }

    {
        boost::uint32_t v1 = 0;

        if( n >= 1 )
        {
            std::size_t const x1 = ( n - 1 ) & 2;
            std::size_t const x2 = n >> 1;

            v1 =
                static_cast<boost::uint32_t>( static_cast<unsigned char>( p[ static_cast<std::ptrdiff_t>( x1 ) ] ) ) << x1 * 8 |
                static_cast<boost::uint32_t>( static_cast<unsigned char>( p[ static_cast<std::ptrdiff_t>( x2 ) ] ) ) << x2 * 8 |
                static_cast<boost::uint32_t>( static_cast<unsigned char>( p[ 0 ] ) );
        }

        w += q;
        h ^= mul32( v1 + w, k );
    }

    w += q;
    h ^= mul32( static_cast<boost::uint32_t>( h & 0xFFFFFFFF ) + w, static_cast<boost::uint32_t>( h >> 32 ) + w + k );

    return static_cast<boost::uint32_t>( h & 0xFFFFFFFF ) ^ static_cast<boost::uint32_t>( h >> 32 );
}

template<class It>
inline typename boost::enable_if_<
    is_char_type<typename std::iterator_traits<It>::value_type>::value &&
    !is_same<typename std::iterator_traits<It>::iterator_category, std::random_access_iterator_tag>::value &&
    std::numeric_limits<std::size_t>::digits <= 32,
std::size_t>::type
    hash_range( std::size_t seed, It first, It last )
{
    std::size_t n = 0;

    boost::uint32_t const q = 0x9e3779b9U;
    boost::uint32_t const k = 0xe35e67b1U;

    boost::uint64_t h = mul32( static_cast<boost::uint32_t>( seed ) + q, k );
    boost::uint32_t w = static_cast<boost::uint32_t>( h & 0xFFFFFFFF );

    boost::uint32_t v1 = 0;

    for( ;; )
    {
        v1 = 0;

        if( first == last )
        {
            break;
        }

        v1 |= static_cast<boost::uint32_t>( static_cast<unsigned char>( *first ) );
        ++first;
        ++n;

        if( first == last )
        {
            break;
        }

        v1 |= static_cast<boost::uint32_t>( static_cast<unsigned char>( *first ) ) << 8;
        ++first;
        ++n;

        if( first == last )
        {
            break;
        }

        v1 |= static_cast<boost::uint32_t>( static_cast<unsigned char>( *first ) ) << 16;
        ++first;
        ++n;

        if( first == last )
        {
            break;
        }

        v1 |= static_cast<boost::uint32_t>( static_cast<unsigned char>( *first ) ) << 24;
        ++first;
        ++n;

        w += q;
        h ^= mul32( v1 + w, k );
    }

    h ^= n;

    w += q;
    h ^= mul32( v1 + w, k );

    w += q;
    h ^= mul32( static_cast<boost::uint32_t>( h & 0xFFFFFFFF ) + w, static_cast<boost::uint32_t>( h >> 32 ) + w + k );

    return static_cast<boost::uint32_t>( h & 0xFFFFFFFF ) ^ static_cast<boost::uint32_t>( h >> 32 );
}



template<class It> inline boost::uint64_t read64le( It p )
{
    boost::uint64_t w =
        static_cast<boost::uint64_t>( static_cast<unsigned char>( p[0] ) ) |
        static_cast<boost::uint64_t>( static_cast<unsigned char>( p[1] ) ) << 8 |
        static_cast<boost::uint64_t>( static_cast<unsigned char>( p[2] ) ) << 16 |
        static_cast<boost::uint64_t>( static_cast<unsigned char>( p[3] ) ) << 24 |
        static_cast<boost::uint64_t>( static_cast<unsigned char>( p[4] ) ) << 32 |
        static_cast<boost::uint64_t>( static_cast<unsigned char>( p[5] ) ) << 40 |
        static_cast<boost::uint64_t>( static_cast<unsigned char>( p[6] ) ) << 48 |
        static_cast<boost::uint64_t>( static_cast<unsigned char>( p[7] ) ) << 56;

    return w;
}
# 248 "/usr/include/boost/container_hash/detail/hash_range.hpp" 3 4
template<class It>
inline typename boost::enable_if_<
    is_char_type<typename std::iterator_traits<It>::value_type>::value &&
    is_same<typename std::iterator_traits<It>::iterator_category, std::random_access_iterator_tag>::value &&
    (std::numeric_limits<std::size_t>::digits > 32),
std::size_t>::type
    hash_range( std::size_t seed, It first, It last )
{
    It p = first;
    std::size_t n = static_cast<std::size_t>( last - first );

    boost::uint64_t const q = static_cast<boost::uint64_t>( 0x9e3779b9 ) << 32 | 0x7f4a7c15;
    boost::uint64_t const k = static_cast<boost::uint64_t>( 0xdf442d22 ) << 32 | 0xce4859b9;

    boost::uint64_t w = mulx( seed + q, k );
    boost::uint64_t h = w ^ n;

    while( n >= 8 )
    {
        boost::uint64_t v1 = read64le( p );

        w += q;
        h ^= mulx( v1 + w, k );

        p += 8;
        n -= 8;
    }

    {
        boost::uint64_t v1 = 0;

        if( n >= 4 )
        {
            v1 = static_cast<boost::uint64_t>( read32le( p + static_cast<std::ptrdiff_t>( n - 4 ) ) ) << ( n - 4 ) * 8 | read32le( p );
        }
        else if( n >= 1 )
        {
            std::size_t const x1 = ( n - 1 ) & 2;
            std::size_t const x2 = n >> 1;

            v1 =
                static_cast<boost::uint64_t>( static_cast<unsigned char>( p[ static_cast<std::ptrdiff_t>( x1 ) ] ) ) << x1 * 8 |
                static_cast<boost::uint64_t>( static_cast<unsigned char>( p[ static_cast<std::ptrdiff_t>( x2 ) ] ) ) << x2 * 8 |
                static_cast<boost::uint64_t>( static_cast<unsigned char>( p[ 0 ] ) );
        }

        w += q;
        h ^= mulx( v1 + w, k );
    }

    return mulx( h + w, k );
}

template<class It>
inline typename boost::enable_if_<
    is_char_type<typename std::iterator_traits<It>::value_type>::value &&
    !is_same<typename std::iterator_traits<It>::iterator_category, std::random_access_iterator_tag>::value &&
    (std::numeric_limits<std::size_t>::digits > 32),
std::size_t>::type
    hash_range( std::size_t seed, It first, It last )
{
    std::size_t n = 0;

    boost::uint64_t const q = static_cast<boost::uint64_t>( 0x9e3779b9 ) << 32 | 0x7f4a7c15;
    boost::uint64_t const k = static_cast<boost::uint64_t>( 0xdf442d22 ) << 32 | 0xce4859b9;

    boost::uint64_t w = mulx( seed + q, k );
    boost::uint64_t h = w;

    boost::uint64_t v1 = 0;

    for( ;; )
    {
        v1 = 0;

        if( first == last )
        {
            break;
        }

        v1 |= static_cast<boost::uint64_t>( static_cast<unsigned char>( *first ) );
        ++first;
        ++n;

        if( first == last )
        {
            break;
        }

        v1 |= static_cast<boost::uint64_t>( static_cast<unsigned char>( *first ) ) << 8;
        ++first;
        ++n;

        if( first == last )
        {
            break;
        }

        v1 |= static_cast<boost::uint64_t>( static_cast<unsigned char>( *first ) ) << 16;
        ++first;
        ++n;

        if( first == last )
        {
            break;
        }

        v1 |= static_cast<boost::uint64_t>( static_cast<unsigned char>( *first ) ) << 24;
        ++first;
        ++n;

        if( first == last )
        {
            break;
        }

        v1 |= static_cast<boost::uint64_t>( static_cast<unsigned char>( *first ) ) << 32;
        ++first;
        ++n;

        if( first == last )
        {
            break;
        }

        v1 |= static_cast<boost::uint64_t>( static_cast<unsigned char>( *first ) ) << 40;
        ++first;
        ++n;

        if( first == last )
        {
            break;
        }

        v1 |= static_cast<boost::uint64_t>( static_cast<unsigned char>( *first ) ) << 48;
        ++first;
        ++n;

        if( first == last )
        {
            break;
        }

        v1 |= static_cast<boost::uint64_t>( static_cast<unsigned char>( *first ) ) << 56;
        ++first;
        ++n;

        w += q;
        h ^= mulx( v1 + w, k );
    }

    h ^= n;

    w += q;
    h ^= mulx( v1 + w, k );

    return mulx( h + w, k );
}

}
}
# 22 "/usr/include/boost/container_hash/hash.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/is_enum.hpp" 1 3 4
# 32 "/usr/include/boost/type_traits/is_enum.hpp" 3 4
namespace boost {
# 160 "/usr/include/boost/type_traits/is_enum.hpp" 3 4
template <class T> struct is_enum : public integral_constant<bool, __is_enum(T)> {};



}
# 23 "/usr/include/boost/container_hash/hash.hpp" 2 3 4

# 1 "/usr/include/boost/type_traits/is_floating_point.hpp" 1 3 4
# 13 "/usr/include/boost/type_traits/is_floating_point.hpp" 3 4
namespace boost {


   template <class T> struct is_floating_point : public false_type{};
   template <class T> struct is_floating_point<const T> : public is_floating_point<T>{};
   template <class T> struct is_floating_point<volatile const T> : public is_floating_point<T>{};
   template <class T> struct is_floating_point<volatile T> : public is_floating_point<T>{};
   template<> struct is_floating_point<float> : public true_type{};
   template<> struct is_floating_point<double> : public true_type{};
   template<> struct is_floating_point<long double> : public true_type{};





}
# 25 "/usr/include/boost/container_hash/hash.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/is_signed.hpp" 1 3 4
# 16 "/usr/include/boost/type_traits/is_signed.hpp" 3 4
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/climits" 1 3 4
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/climits" 3
# 17 "/usr/include/boost/type_traits/is_signed.hpp" 2 3 4

namespace boost {







namespace detail{

template <class T>
struct is_signed_values
{





   typedef typename remove_cv<T>::type no_cv_t;
   static const no_cv_t minus_one = (static_cast<no_cv_t>(-1));
   static const no_cv_t zero = (static_cast<no_cv_t>(0));
};

template <class T>
struct is_signed_helper
{
   typedef typename remove_cv<T>::type no_cv_t;
   static const bool value = (!(::boost::detail::is_signed_values<T>::minus_one > boost::detail::is_signed_values<T>::zero));
};

template <bool integral_type>
struct is_signed_select_helper
{
   template <class T>
   struct rebind
   {
      typedef is_signed_helper<T> type;
   };
};

template <>
struct is_signed_select_helper<false>
{
   template <class T>
   struct rebind
   {
      typedef false_type type;
   };
};

template <class T>
struct is_signed_impl
{
   typedef ::boost::detail::is_signed_select_helper< ::boost::is_integral<T>::value || ::boost::is_enum<T>::value> selector;
   typedef typename selector::template rebind<T> binder;
   typedef typename binder::type type;
   static const bool value = type::value;
};

}

template <class T> struct is_signed : public integral_constant<bool, boost::detail::is_signed_impl<T>::value> {};
# 91 "/usr/include/boost/type_traits/is_signed.hpp" 3 4
template <> struct is_signed<signed char> : public true_type{};
template <> struct is_signed<const signed char> : public true_type{};
template <> struct is_signed<volatile signed char> : public true_type{};
template <> struct is_signed<const volatile signed char> : public true_type{};
template <> struct is_signed<short> : public true_type{};
template <> struct is_signed<const short> : public true_type{};
template <> struct is_signed<volatile short> : public true_type{};
template <> struct is_signed<const volatile short> : public true_type{};
template <> struct is_signed<int> : public true_type{};
template <> struct is_signed<const int> : public true_type{};
template <> struct is_signed<volatile int> : public true_type{};
template <> struct is_signed<const volatile int> : public true_type{};
template <> struct is_signed<long> : public true_type{};
template <> struct is_signed<const long> : public true_type{};
template <> struct is_signed<volatile long> : public true_type{};
template <> struct is_signed<const volatile long> : public true_type{};

template <> struct is_signed<unsigned char> : public false_type{};
template <> struct is_signed<const unsigned char> : public false_type{};
template <> struct is_signed<volatile unsigned char> : public false_type{};
template <> struct is_signed<const volatile unsigned char> : public false_type{};
template <> struct is_signed<unsigned short> : public false_type{};
template <> struct is_signed<const unsigned short> : public false_type{};
template <> struct is_signed<volatile unsigned short> : public false_type{};
template <> struct is_signed<const volatile unsigned short> : public false_type{};
template <> struct is_signed<unsigned int> : public false_type{};
template <> struct is_signed<const unsigned int> : public false_type{};
template <> struct is_signed<volatile unsigned int> : public false_type{};
template <> struct is_signed<const volatile unsigned int> : public false_type{};
template <> struct is_signed<unsigned long> : public false_type{};
template <> struct is_signed<const unsigned long> : public false_type{};
template <> struct is_signed<volatile unsigned long> : public false_type{};
template <> struct is_signed<const volatile unsigned long> : public false_type{};

template <> struct is_signed< ::boost::long_long_type> : public true_type{};
template <> struct is_signed<const ::boost::long_long_type> : public true_type{};
template <> struct is_signed<volatile ::boost::long_long_type> : public true_type{};
template <> struct is_signed<const volatile ::boost::long_long_type> : public true_type{};

template <> struct is_signed< ::boost::ulong_long_type> : public false_type{};
template <> struct is_signed<const ::boost::ulong_long_type> : public false_type{};
template <> struct is_signed<volatile ::boost::ulong_long_type> : public false_type{};
template <> struct is_signed<const volatile ::boost::ulong_long_type> : public false_type{};



template <> struct is_signed<char> : public true_type{};
template <> struct is_signed<const char> : public true_type{};
template <> struct is_signed<volatile char> : public true_type{};
template <> struct is_signed<const volatile char> : public true_type{};
# 150 "/usr/include/boost/type_traits/is_signed.hpp" 3 4
template <> struct is_signed<wchar_t> : public true_type{};
template <> struct is_signed<const wchar_t> : public true_type{};
template <> struct is_signed<volatile wchar_t> : public true_type{};
template <> struct is_signed<const volatile wchar_t> : public true_type{};







}
# 26 "/usr/include/boost/container_hash/hash.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/is_unsigned.hpp" 1 3 4
# 17 "/usr/include/boost/type_traits/is_unsigned.hpp" 3 4
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/climits" 1 3 4
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/climits" 3
# 18 "/usr/include/boost/type_traits/is_unsigned.hpp" 2 3 4

namespace boost {







namespace detail{

template <class T>
struct is_unsigned_values
{





   typedef typename remove_cv<T>::type no_cv_t;
   static const no_cv_t minus_one = (static_cast<no_cv_t>(-1));
   static const no_cv_t zero = (static_cast<no_cv_t>(0));
};

template <class T>
struct is_ununsigned_helper
{
   static const bool value = (::boost::detail::is_unsigned_values<T>::minus_one > ::boost::detail::is_unsigned_values<T>::zero);
};

template <bool integral_type>
struct is_unsigned_select_helper
{
   template <class T>
   struct rebind
   {
      typedef is_ununsigned_helper<T> type;
   };
};

template <>
struct is_unsigned_select_helper<false>
{
   template <class T>
   struct rebind
   {
      typedef false_type type;
   };
};

template <class T>
struct is_unsigned
{
   typedef ::boost::detail::is_unsigned_select_helper< ::boost::is_integral<T>::value || ::boost::is_enum<T>::value > selector;
   typedef typename selector::template rebind<T> binder;
   typedef typename binder::type type;
   static const bool value = type::value;
};

}

template <class T> struct is_unsigned : public integral_constant<bool, boost::detail::is_unsigned<T>::value> {};
# 91 "/usr/include/boost/type_traits/is_unsigned.hpp" 3 4
template <> struct is_unsigned<unsigned char> : public true_type{};
template <> struct is_unsigned<const unsigned char> : public true_type{};
template <> struct is_unsigned<volatile unsigned char> : public true_type{};
template <> struct is_unsigned<const volatile unsigned char> : public true_type{};
template <> struct is_unsigned<unsigned short> : public true_type{};
template <> struct is_unsigned<const unsigned short> : public true_type{};
template <> struct is_unsigned<volatile unsigned short> : public true_type{};
template <> struct is_unsigned<const volatile unsigned short> : public true_type{};
template <> struct is_unsigned<unsigned int> : public true_type{};
template <> struct is_unsigned<const unsigned int> : public true_type{};
template <> struct is_unsigned<volatile unsigned int> : public true_type{};
template <> struct is_unsigned<const volatile unsigned int> : public true_type{};
template <> struct is_unsigned<unsigned long> : public true_type{};
template <> struct is_unsigned<const unsigned long> : public true_type{};
template <> struct is_unsigned<volatile unsigned long> : public true_type{};
template <> struct is_unsigned<const volatile unsigned long> : public true_type{};

template <> struct is_unsigned<signed char> : public false_type{};
template <> struct is_unsigned<const signed char> : public false_type{};
template <> struct is_unsigned<volatile signed char> : public false_type{};
template <> struct is_unsigned<const volatile signed char> : public false_type{};
template <> struct is_unsigned< short> : public false_type{};
template <> struct is_unsigned<const short> : public false_type{};
template <> struct is_unsigned<volatile short> : public false_type{};
template <> struct is_unsigned<const volatile short> : public false_type{};
template <> struct is_unsigned< int> : public false_type{};
template <> struct is_unsigned<const int> : public false_type{};
template <> struct is_unsigned<volatile int> : public false_type{};
template <> struct is_unsigned<const volatile int> : public false_type{};
template <> struct is_unsigned< long> : public false_type{};
template <> struct is_unsigned<const long> : public false_type{};
template <> struct is_unsigned<volatile long> : public false_type{};
template <> struct is_unsigned<const volatile long> : public false_type{};

template <> struct is_unsigned< ::boost::ulong_long_type> : public true_type{};
template <> struct is_unsigned<const ::boost::ulong_long_type> : public true_type{};
template <> struct is_unsigned<volatile ::boost::ulong_long_type> : public true_type{};
template <> struct is_unsigned<const volatile ::boost::ulong_long_type> : public true_type{};

template <> struct is_unsigned< ::boost::long_long_type> : public false_type{};
template <> struct is_unsigned<const ::boost::long_long_type> : public false_type{};
template <> struct is_unsigned<volatile ::boost::long_long_type> : public false_type{};
template <> struct is_unsigned<const volatile ::boost::long_long_type> : public false_type{};
# 142 "/usr/include/boost/type_traits/is_unsigned.hpp" 3 4
template <> struct is_unsigned<char> : public false_type{};
template <> struct is_unsigned<const char> : public false_type{};
template <> struct is_unsigned<volatile char> : public false_type{};
template <> struct is_unsigned<const volatile char> : public false_type{};
# 155 "/usr/include/boost/type_traits/is_unsigned.hpp" 3 4
template <> struct is_unsigned<wchar_t> : public false_type{};
template <> struct is_unsigned<const wchar_t> : public false_type{};
template <> struct is_unsigned<volatile wchar_t> : public false_type{};
template <> struct is_unsigned<const volatile wchar_t> : public false_type{};


}
# 27 "/usr/include/boost/container_hash/hash.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/make_unsigned.hpp" 1 3 4
# 21 "/usr/include/boost/type_traits/make_unsigned.hpp" 3 4
# 1 "/usr/include/boost/type_traits/add_const.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/add_const.hpp" 3 4
namespace boost {
# 30 "/usr/include/boost/type_traits/add_const.hpp" 3 4
   template <class T> struct add_const
   {
      typedef T const type;
   };





   template <class T> struct add_const<T&>
   {
      typedef T& type;
   };



   template <class T> using add_const_t = typename add_const<T>::type;



}
# 22 "/usr/include/boost/type_traits/make_unsigned.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/add_volatile.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/add_volatile.hpp" 3 4
namespace boost {
# 30 "/usr/include/boost/type_traits/add_volatile.hpp" 3 4
template <class T> struct add_volatile{ typedef T volatile type; };





template <class T> struct add_volatile<T&>{ typedef T& type; };



   template <class T> using add_volatile_t = typename add_volatile<T>::type;



}
# 23 "/usr/include/boost/type_traits/make_unsigned.hpp" 2 3 4


namespace boost {

template <class T>
struct make_unsigned
{
private:
   static_assert((::boost::is_integral<T>::value || ::boost::is_enum<T>::value), "The template argument to make_unsigned must be an integer or enum type.");
   static_assert((! ::boost::is_same<typename remove_cv<T>::type, bool>::value), "The template argument to make_unsigned must not be the type bool");

   typedef typename remove_cv<T>::type t_no_cv;
   typedef typename conditional<
      (::boost::is_unsigned<T>::value && ::boost::is_integral<T>::value
      && ! ::boost::is_same<t_no_cv, char>::value
      && ! ::boost::is_same<t_no_cv, wchar_t>::value
      && ! ::boost::is_same<t_no_cv, bool>::value),
      T,
      typename conditional<
         (::boost::is_integral<T>::value
         && ! ::boost::is_same<t_no_cv, char>::value
         && ! ::boost::is_same<t_no_cv, wchar_t>::value
         && ! ::boost::is_same<t_no_cv, bool>::value),
         typename conditional<
            is_same<t_no_cv, signed char>::value,
            unsigned char,
            typename conditional<
               is_same<t_no_cv, short>::value,
               unsigned short,
               typename conditional<
                  is_same<t_no_cv, int>::value,
                  unsigned int,
                  typename conditional<
                     is_same<t_no_cv, long>::value,
                     unsigned long,


                     typename conditional<
                        sizeof(t_no_cv) == sizeof(boost::ulong_long_type),
                        boost::ulong_long_type,
                        boost::uint128_type
                     >::type
# 73 "/usr/include/boost/type_traits/make_unsigned.hpp" 3 4
                  >::type
               >::type
            >::type
         >::type,

         typename conditional<
            sizeof(t_no_cv) == sizeof(unsigned char),
            unsigned char,
            typename conditional<
               sizeof(t_no_cv) == sizeof(unsigned short),
               unsigned short,
               typename conditional<
                  sizeof(t_no_cv) == sizeof(unsigned int),
                  unsigned int,
                  typename conditional<
                     sizeof(t_no_cv) == sizeof(unsigned long),
                     unsigned long,


                     typename conditional<
                        sizeof(t_no_cv) == sizeof(boost::ulong_long_type),
                        boost::ulong_long_type,
                        boost::uint128_type
                     >::type
# 105 "/usr/include/boost/type_traits/make_unsigned.hpp" 3 4
                  >::type
               >::type
            >::type
         >::type
      >::type
   >::type base_integer_type;


   typedef typename conditional<
      is_const<T>::value,
      typename add_const<base_integer_type>::type,
      base_integer_type
   >::type const_base_integer_type;
public:

   typedef typename conditional<
      is_volatile<T>::value,
      typename add_volatile<const_base_integer_type>::type,
      const_base_integer_type
   >::type type;
};



   template <class T> using make_unsigned_t = typename make_unsigned<T>::type;



}
# 28 "/usr/include/boost/container_hash/hash.hpp" 2 3 4

# 1 "/usr/include/boost/type_traits/conjunction.hpp" 1 3 4
# 18 "/usr/include/boost/type_traits/conjunction.hpp" 3 4
namespace boost {


template<class...>
struct conjunction
    : true_type { };

template<class T>
struct conjunction<T>
    : T { };

template<class T, class... U>
struct conjunction<T, U...>
    : conditional<bool(T::value), conjunction<U...>, T>::type { };






}
# 30 "/usr/include/boost/container_hash/hash.hpp" 2 3 4




# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 35 "/usr/include/boost/container_hash/hash.hpp" 2 3 4







# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/complex" 1 3 4
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/complex" 3




# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cmath" 1 3
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cmath" 3
# 45 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/complex" 2 3






#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wc99-extensions"




# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 58 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/complex" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{
# 72 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/complex" 3
  template<typename _Tp> class complex;
  template<> class complex<float>;
  template<> class complex<double>;
  template<> class complex<long double>;


  template<typename _Tp> _Tp abs(const complex<_Tp>&);

  template<typename _Tp> _Tp arg(const complex<_Tp>&);

  template<typename _Tp> _Tp constexpr norm(const complex<_Tp>&);


  template<typename _Tp>
    constexpr complex<_Tp> conj(const complex<_Tp>&);

  template<typename _Tp> complex<_Tp> polar(const _Tp&, const _Tp& = 0);



  template<typename _Tp> complex<_Tp> cos(const complex<_Tp>&);

  template<typename _Tp> complex<_Tp> cosh(const complex<_Tp>&);

  template<typename _Tp> complex<_Tp> exp(const complex<_Tp>&);

  template<typename _Tp> complex<_Tp> log(const complex<_Tp>&);

  template<typename _Tp> complex<_Tp> log10(const complex<_Tp>&);

  template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, int);

  template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, const _Tp&);

  template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&,
                                          const complex<_Tp>&);

  template<typename _Tp> complex<_Tp> pow(const _Tp&, const complex<_Tp>&);

  template<typename _Tp> complex<_Tp> sin(const complex<_Tp>&);

  template<typename _Tp> complex<_Tp> sinh(const complex<_Tp>&);

  template<typename _Tp> complex<_Tp> sqrt(const complex<_Tp>&);

  template<typename _Tp> complex<_Tp> tan(const complex<_Tp>&);

  template<typename _Tp> complex<_Tp> tanh(const complex<_Tp>&);
# 131 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/complex" 3
  template<typename _Tp>
    class complex
    {
    public:

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

 explicit(!requires(_Up __u) { _Tp{__u}; })

 constexpr complex(const complex<_Up>& __z)
 : _M_real(_Tp(__z.real())), _M_imag(_Tp(__z.imag())) { }




      __attribute ((__abi_tag__ ("cxx11")))
      constexpr _Tp
      real() const { return _M_real; }

      __attribute ((__abi_tag__ ("cxx11")))
      constexpr _Tp
      imag() const { return _M_imag; }
# 186 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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<typename _Up>
        constexpr complex<_Tp>& operator=(const complex<_Up>&);

      template<typename _Up>
        constexpr complex<_Tp>& operator+=(const complex<_Up>&);

      template<typename _Up>
        constexpr complex<_Tp>& operator-=(const complex<_Up>&);

      template<typename _Up>
        constexpr complex<_Tp>& operator*=(const complex<_Up>&);

      template<typename _Up>
        constexpr complex<_Tp>& operator/=(const complex<_Up>&);

      constexpr complex __rep() const
      { return *this; }

    private:
      _Tp _M_real;
      _Tp _M_imag;
    };

  template<typename _Tp>
    constexpr complex<_Tp>&
    complex<_Tp>::operator=(const _Tp& __t)
    {
     _M_real = __t;
     _M_imag = _Tp();
     return *this;
    }


  template<typename _Tp>
    constexpr complex<_Tp>&
    complex<_Tp>::operator*=(const _Tp& __t)
    {
      _M_real *= __t;
      _M_imag *= __t;
      return *this;
    }


  template<typename _Tp>
    constexpr complex<_Tp>&
    complex<_Tp>::operator/=(const _Tp& __t)
    {
      _M_real /= __t;
      _M_imag /= __t;
      return *this;
    }

  template<typename _Tp>
    template<typename _Up>
    constexpr complex<_Tp>&
    complex<_Tp>::operator=(const complex<_Up>& __z)
    {
      _M_real = __z.real();
      _M_imag = __z.imag();
      return *this;
    }


  template<typename _Tp>
    template<typename _Up>
    constexpr complex<_Tp>&
    complex<_Tp>::operator+=(const complex<_Up>& __z)
    {
      _M_real += __z.real();
      _M_imag += __z.imag();
      return *this;
    }


  template<typename _Tp>
    template<typename _Up>
    constexpr complex<_Tp>&
    complex<_Tp>::operator-=(const complex<_Up>& __z)
    {
      _M_real -= __z.real();
      _M_imag -= __z.imag();
      return *this;
    }



  template<typename _Tp>
    template<typename _Up>
    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<typename _Tp>
    template<typename _Up>
    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<typename _Tp>
    inline constexpr complex<_Tp>
    operator+(const complex<_Tp>& __x, const complex<_Tp>& __y)
    {
      complex<_Tp> __r = __x;
      __r += __y;
      return __r;
    }

  template<typename _Tp>
    inline constexpr complex<_Tp>
    operator+(const complex<_Tp>& __x, const _Tp& __y)
    {
      complex<_Tp> __r = __x;
      __r += __y;
      return __r;
    }

  template<typename _Tp>
    inline constexpr complex<_Tp>
    operator+(const _Tp& __x, const complex<_Tp>& __y)
    {
      complex<_Tp> __r = __y;
      __r += __x;
      return __r;
    }




  template<typename _Tp>
    inline constexpr complex<_Tp>
    operator-(const complex<_Tp>& __x, const complex<_Tp>& __y)
    {
      complex<_Tp> __r = __x;
      __r -= __y;
      return __r;
    }

  template<typename _Tp>
    inline constexpr complex<_Tp>
    operator-(const complex<_Tp>& __x, const _Tp& __y)
    {
      complex<_Tp> __r = __x;
      __r -= __y;
      return __r;
    }

  template<typename _Tp>
    inline constexpr complex<_Tp>
    operator-(const _Tp& __x, const complex<_Tp>& __y)
    {
      complex<_Tp> __r = -__y;
      __r += __x;
      return __r;
    }




  template<typename _Tp>
    inline constexpr complex<_Tp>
    operator*(const complex<_Tp>& __x, const complex<_Tp>& __y)
    {
      complex<_Tp> __r = __x;
      __r *= __y;
      return __r;
    }

  template<typename _Tp>
    inline constexpr complex<_Tp>
    operator*(const complex<_Tp>& __x, const _Tp& __y)
    {
      complex<_Tp> __r = __x;
      __r *= __y;
      return __r;
    }

  template<typename _Tp>
    inline constexpr complex<_Tp>
    operator*(const _Tp& __x, const complex<_Tp>& __y)
    {
      complex<_Tp> __r = __y;
      __r *= __x;
      return __r;
    }




  template<typename _Tp>
    inline constexpr complex<_Tp>
    operator/(const complex<_Tp>& __x, const complex<_Tp>& __y)
    {
      complex<_Tp> __r = __x;
      __r /= __y;
      return __r;
    }

  template<typename _Tp>
    inline constexpr complex<_Tp>
    operator/(const complex<_Tp>& __x, const _Tp& __y)
    {
      complex<_Tp> __r = __x;
      __r /= __y;
      return __r;
    }

  template<typename _Tp>
    inline constexpr complex<_Tp>
    operator/(const _Tp& __x, const complex<_Tp>& __y)
    {
      complex<_Tp> __r = __x;
      __r /= __y;
      return __r;
    }



  template<typename _Tp>
    inline constexpr complex<_Tp>
    operator+(const complex<_Tp>& __x)
    { return __x; }


  template<typename _Tp>
    inline constexpr complex<_Tp>
    operator-(const complex<_Tp>& __x)
    { return complex<_Tp>(-__x.real(), -__x.imag()); }



  template<typename _Tp>
    inline constexpr bool
    operator==(const complex<_Tp>& __x, const complex<_Tp>& __y)
    { return __x.real() == __y.real() && __x.imag() == __y.imag(); }

  template<typename _Tp>
    inline constexpr bool
    operator==(const complex<_Tp>& __x, const _Tp& __y)
    { return __x.real() == __y && __x.imag() == _Tp(); }
# 507 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/complex" 3
  template<typename _Tp, typename _CharT, class _Traits>
    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<typename _Tp, typename _CharT, class _Traits>
    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<typename _Tp>
    constexpr _Tp
    real(const complex<_Tp>& __z)
    { return __z.real(); }

  template<typename _Tp>
    constexpr _Tp
    imag(const complex<_Tp>& __z)
    { return __z.imag(); }
# 865 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/complex" 3
  template<typename _Tp>
    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<typename _Tp>
    inline _Tp
    abs(const complex<_Tp>& __z) { return __complex_abs(__z.__rep()); }
# 901 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/complex" 3
  template<typename _Tp>
    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<typename _Tp>
    inline _Tp
    arg(const complex<_Tp>& __z) { return __complex_arg(__z.__rep()); }
# 931 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/complex" 3
  template<bool>
    struct _Norm_helper
    {
      template<typename _Tp>
        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<true>
    {
      template<typename _Tp>
        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<typename _Tp>
    inline constexpr _Tp
    norm(const complex<_Tp>& __z)
    {
      return _Norm_helper<__is_floating<_Tp>::__value
 && !0>::_S_do_it(__z);
    }

  template<typename _Tp>
    inline complex<_Tp>
    polar(const _Tp& __rho, const _Tp& __theta)
    {
      do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__rho >= 0), false)) std::__glibcxx_assert_fail(); } while (false);
      return complex<_Tp>(__rho * cos(__theta), __rho * sin(__theta));
    }

  template<typename _Tp>
    inline constexpr complex<_Tp>
    conj(const complex<_Tp>& __z)
    { return complex<_Tp>(__z.real(), -__z.imag()); }




  template<typename _Tp>
    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<typename _Tp>
    inline complex<_Tp>
    cos(const complex<_Tp>& __z) { return __complex_cos(__z.__rep()); }







  template<typename _Tp>
    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<typename _Tp>
    inline complex<_Tp>
    cosh(const complex<_Tp>& __z) { return __complex_cosh(__z.__rep()); }







  template<typename _Tp>
    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<typename _Tp>
    inline complex<_Tp>
    exp(const complex<_Tp>& __z) { return __complex_exp(__z.__rep()); }
# 1068 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/complex" 3
  template<typename _Tp>
    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<typename _Tp>
    inline complex<_Tp>
    log(const complex<_Tp>& __z) { return __complex_log(__z.__rep()); }






  template<typename _Tp>
    inline complex<_Tp>
    log10(const complex<_Tp>& __z)
    { return std::log(__z) / log(_Tp(10.0)); }


  template<typename _Tp>
    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<typename _Tp>
    inline complex<_Tp>
    sin(const complex<_Tp>& __z) { return __complex_sin(__z.__rep()); }







  template<typename _Tp>
    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<typename _Tp>
    inline complex<_Tp>
    sinh(const complex<_Tp>& __z) { return __complex_sinh(__z.__rep()); }
# 1160 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/complex" 3
  template<typename _Tp>
    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<typename _Tp>
    inline complex<_Tp>
    sqrt(const complex<_Tp>& __z) { return __complex_sqrt(__z.__rep()); }
# 1204 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/complex" 3
  template<typename _Tp>
    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<typename _Tp>
    inline complex<_Tp>
    tan(const complex<_Tp>& __z) { return __complex_tan(__z.__rep()); }
# 1232 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/complex" 3
  template<typename _Tp>
    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<typename _Tp>
    inline complex<_Tp>
    tanh(const complex<_Tp>& __z) { return __complex_tanh(__z.__rep()); }
# 1261 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/complex" 3
  template<typename _Tp>
    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<typename _Tp>
    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<typename _Tp>
    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<typename _Tp>
    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<typename _Tp>
    inline complex<_Tp>
    pow(const complex<_Tp>& __x, const complex<_Tp>& __y)
    { return __complex_pow(__x.__rep(), __y.__rep()); }







  template<typename _Tp>
    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<>
    class complex<float>
    {
    public:
      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 } { }
# 1368 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/complex" 3
      constexpr complex(const complex&) = default;



      template<typename _Up>
 explicit(!requires(_Up __u) { value_type{__u}; })
 constexpr complex(const complex<_Up>& __z)
 : _M_value{ value_type(__z.real()), value_type(__z.imag()) } { }
# 1384 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/complex" 3
      __attribute ((__abi_tag__ ("cxx11")))
      constexpr float
      real() const { return __real__ _M_value; }

      __attribute ((__abi_tag__ ("cxx11")))
      constexpr float
      imag() const { return __imag__ _M_value; }
# 1407 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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<typename _Tp>
        constexpr complex&
        operator=(const complex<_Tp>& __z)
 {
   __real__ _M_value = __z.real();
   __imag__ _M_value = __z.imag();
   return *this;
 }

      template<typename _Tp>
        constexpr complex&
        operator+=(const complex<_Tp>& __z)
 {
   _M_value += __z.__rep();
   return *this;
 }

      template<class _Tp>
        constexpr complex&
        operator-=(const complex<_Tp>& __z)
 {
   _M_value -= __z.__rep();
   return *this;
 }

      template<class _Tp>
        constexpr complex&
        operator*=(const complex<_Tp>& __z)
 {
   const _ComplexT __t = __z.__rep();
   _M_value *= __t;
   return *this;
 }

      template<class _Tp>
        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<>
    class complex<double>
    {
    public:
      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 } { }
# 1525 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/complex" 3
      constexpr complex(const complex&) = default;



      template<typename _Up>
 explicit(!requires(_Up __u) { value_type{__u}; })
 constexpr complex(const complex<_Up>& __z)
 : _M_value{ value_type(__z.real()), value_type(__z.imag()) } { }
# 1543 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/complex" 3
      __attribute ((__abi_tag__ ("cxx11")))
      constexpr double
      real() const { return __real__ _M_value; }

      __attribute ((__abi_tag__ ("cxx11")))
      constexpr double
      imag() const { return __imag__ _M_value; }
# 1566 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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<typename _Tp>
        constexpr complex&
        operator=(const complex<_Tp>& __z)
 {
   _M_value = __z.__rep();
   return *this;
 }

      template<typename _Tp>
        constexpr complex&
        operator+=(const complex<_Tp>& __z)
 {
   _M_value += __z.__rep();
   return *this;
 }

      template<typename _Tp>
        constexpr complex&
        operator-=(const complex<_Tp>& __z)
 {
   _M_value -= __z.__rep();
   return *this;
 }

      template<typename _Tp>
        constexpr complex&
        operator*=(const complex<_Tp>& __z)
 {
   const _ComplexT __t = __z.__rep();
   _M_value *= __t;
   return *this;
 }

      template<typename _Tp>
        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<>
    class complex<long double>
    {
    public:
      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 } { }
# 1683 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/complex" 3
      constexpr complex(const complex&) = default;



      template<typename _Up>
 explicit(!requires(_Up __u) { value_type{__u}; })
 constexpr complex(const complex<_Up>& __z)
 : _M_value{ value_type(__z.real()), value_type(__z.imag()) } { }
# 1702 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/complex" 3
      __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; }
# 1725 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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<typename _Tp>
        constexpr complex&
        operator=(const complex<_Tp>& __z)
 {
   _M_value = __z.__rep();
   return *this;
 }

      template<typename _Tp>
        constexpr complex&
 operator+=(const complex<_Tp>& __z)
 {
   _M_value += __z.__rep();
   return *this;
 }

      template<typename _Tp>
        constexpr complex&
 operator-=(const complex<_Tp>& __z)
 {
   _M_value -= __z.__rep();
   return *this;
 }

      template<typename _Tp>
        constexpr complex&
 operator*=(const complex<_Tp>& __z)
 {
   const _ComplexT __t = __z.__rep();
   _M_value *= __t;
   return *this;
 }

      template<typename _Tp>
        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<typename _Tp>
    struct __complex_type
    { };
# 1854 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/complex" 3
  template<typename _Tp>
    requires requires { typename __complex_type<_Tp>::type; }
    class complex<_Tp>
    {
    public:
      typedef _Tp value_type;
      typedef typename std::__complex_type<_Tp>::type _ComplexT;

      constexpr complex(_ComplexT __z) : _M_value(__z) { }

      constexpr complex(_Tp __r = _Tp(), _Tp __i = _Tp())
      : _M_value{ __r, __i } { }

      template<typename _Up>
 explicit(!requires(_Up __u) { value_type{__u}; })
 constexpr complex(const complex<_Up>& __z)
 : _M_value{ value_type(__z.real()), value_type(__z.imag()) } { }

      constexpr _Tp
      real() const { return __real__ _M_value; }

      constexpr _Tp
      imag() const { return __imag__ _M_value; }

      constexpr void
      real(_Tp __val) { __real__ _M_value = __val; }

      constexpr void
      imag(_Tp __val) { __imag__ _M_value = __val; }

      constexpr complex&
      operator=(_Tp __f)
      {
 _M_value = __f;
 return *this;
      }

      constexpr complex&
      operator+=(_Tp __f)
      {
 _M_value += __f;
 return *this;
      }

      constexpr complex&
      operator-=(_Tp __f)
      {
 _M_value -= __f;
 return *this;
      }

      constexpr complex&
      operator*=(_Tp __f)
      {
 _M_value *= __f;
 return *this;
      }

      constexpr complex&
      operator/=(_Tp __f)
      {
 _M_value /= __f;
 return *this;
      }



      constexpr complex(const complex&) = default;
      constexpr complex& operator=(const complex&) = default;

      template<typename _Up>
 constexpr complex&
 operator=(const complex<_Up>& __z)
 {
   __real__ _M_value = __z.real();
   __imag__ _M_value = __z.imag();
   return *this;
 }

      template<typename _Up>
 constexpr complex&
 operator+=(const complex<_Up>& __z)
 {
   _M_value += __z.__rep();
   return *this;
 }

      template<class _Up>
 constexpr complex&
 operator-=(const complex<_Up>& __z)
 {
   _M_value -= __z.__rep();
   return *this;
 }

      template<class _Up>
 constexpr complex&
 operator*=(const complex<_Up>& __z)
 {
   const _ComplexT __t = __z.__rep();
   _M_value *= __t;
   return *this;
 }

      template<class _Up>
 constexpr complex&
 operator/=(const complex<_Up>& __z)
 {
   const _ComplexT __t = __z.__rep();
   _M_value /= __t;
   return *this;
 }

      constexpr _ComplexT __rep() const { return _M_value; }

    private:
      _ComplexT _M_value;
    };
# 1994 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/complex" 3
  extern template istream& operator>>(istream&, complex<float>&);
  extern template ostream& operator<<(ostream&, const complex<float>&);
  extern template istream& operator>>(istream&, complex<double>&);
  extern template ostream& operator<<(ostream&, const complex<double>&);
  extern template istream& operator>>(istream&, complex<long double>&);
  extern template ostream& operator<<(ostream&, const complex<long double>&);


  extern template wistream& operator>>(wistream&, complex<float>&);
  extern template wostream& operator<<(wostream&, const complex<float>&);
  extern template wistream& operator>>(wistream&, complex<double>&);
  extern template wostream& operator<<(wostream&, const complex<double>&);
  extern template wistream& operator>>(wistream&, complex<long double>&);
  extern template wostream& operator<<(wostream&, const complex<long double>&);






}



namespace std __attribute__ ((__visibility__ ("default")))
{



  template<typename _Tp> std::complex<_Tp> acos(const std::complex<_Tp>&);
  template<typename _Tp> std::complex<_Tp> asin(const std::complex<_Tp>&);
  template<typename _Tp> std::complex<_Tp> atan(const std::complex<_Tp>&);

  template<typename _Tp> std::complex<_Tp> acosh(const std::complex<_Tp>&);
  template<typename _Tp> std::complex<_Tp> asinh(const std::complex<_Tp>&);
  template<typename _Tp> std::complex<_Tp> atanh(const std::complex<_Tp>&);

  template<typename _Tp> _Tp fabs(const std::complex<_Tp>&);

  template<typename _Tp>
    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());
    }
# 2199 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/complex" 3
  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<typename _Tp>
    inline std::complex<_Tp>
    acos(const std::complex<_Tp>& __z)
    { return __complex_acos(__z.__rep()); }
# 2225 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/complex" 3
  template<typename _Tp>
    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<typename _Tp>
    inline std::complex<_Tp>
    asin(const std::complex<_Tp>& __z)
    { return __complex_asin(__z.__rep()); }
# 2261 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/complex" 3
  template<typename _Tp>
    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<typename _Tp>
    inline std::complex<_Tp>
    atan(const std::complex<_Tp>& __z)
    { return __complex_atan(__z.__rep()); }
# 2305 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/complex" 3
  template<typename _Tp>
    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<typename _Tp>
    inline std::complex<_Tp>
    acosh(const std::complex<_Tp>& __z)
    { return __complex_acosh(__z.__rep()); }
# 2341 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/complex" 3
  template<typename _Tp>
    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<typename _Tp>
    inline std::complex<_Tp>
    asinh(const std::complex<_Tp>& __z)
    { return __complex_asinh(__z.__rep()); }
# 2380 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/complex" 3
  template<typename _Tp>
    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<typename _Tp>
    inline std::complex<_Tp>
    atanh(const std::complex<_Tp>& __z)
    { return __complex_atanh(__z.__rep()); }
# 2424 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/complex" 3
  template<typename _Tp>
    inline _Tp



    fabs(const std::complex<_Tp>& __z)
    { return std::abs(__z); }


  template<typename _Tp>
    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<typename _Tp>
    constexpr inline typename __gnu_cxx::__promote<_Tp>::__type
    imag(_Tp)
    { return _Tp(); }

  template<typename _Tp>
    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<typename _Tp>
    constexpr inline typename __gnu_cxx::__promote<_Tp>::__type
    real(_Tp __x)
    { return __x; }

  template<typename _Tp, typename _Up>
    inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__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<typename _Tp, typename _Up>
    inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__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<typename _Tp, typename _Up>
    inline std::complex<typename __gnu_cxx::__promote_2<_Tp, _Up>::__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<typename _Tp>
    std::complex<_Tp> proj(const std::complex<_Tp>&);


  template<typename _Tp>
    inline std::complex<_Tp>
    __complex_proj(const std::complex<_Tp>& __z)
    { return __z; }


  inline complex<float>
  __complex_proj(const complex<float>& __z)
  { return __builtin_cprojf(__z.__rep()); }

  inline complex<double>
  __complex_proj(const complex<double>& __z)
  { return __builtin_cproj(__z.__rep()); }

  inline complex<long double>
  __complex_proj(const complex<long double>& __z)
  { return __builtin_cprojl(__z.__rep()); }
# 2548 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/complex" 3
  template<typename _Tp>
    requires requires { typename __complex_type<_Tp>::type; }
    inline complex<_Tp>
    __complex_proj(const complex<_Tp>& __z)
    { return __complex_proj(__z.__rep()); }
# 2584 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/complex" 3
  template<typename _Tp>
    inline std::complex<_Tp>
    proj(const std::complex<_Tp>& __z)
    { return __complex_proj(__z); }


  template<typename _Tp>
    inline std::complex<typename __gnu_cxx::__promote<_Tp>::__type>
    proj(_Tp __x)
    {
      typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
      return std::proj(std::complex<__type>(__x));
    }

  template<typename _Tp>
    inline constexpr
 std::complex<typename __gnu_cxx::__promote<_Tp>::__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


  constexpr std::complex<float>
  operator""if(long double __num)
  { return std::complex<float>{0.0F, static_cast<float>(__num)}; }

  constexpr std::complex<float>
  operator""if(unsigned long long __num)
  { return std::complex<float>{0.0F, static_cast<float>(__num)}; }

  constexpr std::complex<double>
  operator""i(long double __num)
  { return std::complex<double>{0.0, static_cast<double>(__num)}; }

  constexpr std::complex<double>
  operator""i(unsigned long long __num)
  { return std::complex<double>{0.0, static_cast<double>(__num)}; }

  constexpr std::complex<long double>
  operator""il(long double __num)
  { return std::complex<long double>{0.0L, __num}; }

  constexpr std::complex<long double>
  operator""il(unsigned long long __num)
  { return std::complex<long double>{0.0L, static_cast<long double>(__num)}; }

#pragma GCC diagnostic pop
}
}




}




#pragma clang diagnostic pop
# 43 "/usr/include/boost/container_hash/hash.hpp" 2 3 4


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/climits" 1 3 4
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/climits" 3
# 46 "/usr/include/boost/container_hash/hash.hpp" 2 3 4
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 1 3 4
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 3


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 43 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 2 3
# 47 "/usr/include/boost/container_hash/hash.hpp" 2 3 4
# 72 "/usr/include/boost/container_hash/hash.hpp" 3 4
namespace boost
{







    namespace hash_detail
    {
        template<class T,
            bool bigger_than_size_t = (sizeof(T) > sizeof(std::size_t)),
            bool is_unsigned = boost::is_unsigned<T>::value,
            std::size_t size_t_bits = sizeof(std::size_t) * 8,
            std::size_t type_bits = sizeof(T) * 8>
        struct hash_integral_impl;

        template<class T, bool is_unsigned, std::size_t size_t_bits, std::size_t type_bits> struct hash_integral_impl<T, false, is_unsigned, size_t_bits, type_bits>
        {
            static std::size_t fn( T v )
            {
                return static_cast<std::size_t>( v );
            }
        };

        template<class T, std::size_t size_t_bits, std::size_t type_bits> struct hash_integral_impl<T, true, false, size_t_bits, type_bits>
        {
            static std::size_t fn( T v )
            {
                typedef typename boost::make_unsigned<T>::type U;

                if( v >= 0 )
                {
                    return hash_integral_impl<U>::fn( static_cast<U>( v ) );
                }
                else
                {
                    return ~hash_integral_impl<U>::fn( static_cast<U>( ~static_cast<U>( v ) ) );
                }
            }
        };

        template<class T> struct hash_integral_impl<T, true, true, 32, 64>
        {
            static std::size_t fn( T v )
            {
                std::size_t seed = 0;

                seed = static_cast<std::size_t>( v >> 32 ) + hash_detail::hash_mix( seed );
                seed = static_cast<std::size_t>( v & 0xFFFFFFFF ) + hash_detail::hash_mix( seed );

                return seed;
            }
        };

        template<class T> struct hash_integral_impl<T, true, true, 32, 128>
        {
            static std::size_t fn( T v )
            {
                std::size_t seed = 0;

                seed = static_cast<std::size_t>( v >> 96 ) + hash_detail::hash_mix( seed );
                seed = static_cast<std::size_t>( v >> 64 ) + hash_detail::hash_mix( seed );
                seed = static_cast<std::size_t>( v >> 32 ) + hash_detail::hash_mix( seed );
                seed = static_cast<std::size_t>( v ) + hash_detail::hash_mix( seed );

                return seed;
            }
        };

        template<class T> struct hash_integral_impl<T, true, true, 64, 128>
        {
            static std::size_t fn( T v )
            {
                std::size_t seed = 0;

                seed = static_cast<std::size_t>( v >> 64 ) + hash_detail::hash_mix( seed );
                seed = static_cast<std::size_t>( v ) + hash_detail::hash_mix( seed );

                return seed;
            }
        };

    }

    template <typename T>
    typename boost::enable_if_<boost::is_integral<T>::value, std::size_t>::type
        hash_value( T v )
    {
        return hash_detail::hash_integral_impl<T>::fn( v );
    }



    template <typename T>
    typename boost::enable_if_<boost::is_enum<T>::value, std::size_t>::type
        hash_value( T v )
    {
# 185 "/usr/include/boost/container_hash/hash.hpp" 3 4
        return static_cast<std::size_t>( v );
    }



    namespace hash_detail
    {
        template<class T,
            std::size_t Bits = sizeof(T) * 8,
            int Digits = std::numeric_limits<T>::digits>
        struct hash_float_impl;


        template<class T, int Digits> struct hash_float_impl<T, 32, Digits>
        {
            static std::size_t fn( T v )
            {
                boost::uint32_t w;
                std::memcpy( &w, &v, sizeof( v ) );

                return w;
            }
        };


        template<class T, int Digits> struct hash_float_impl<T, 64, Digits>
        {
            static std::size_t fn( T v )
            {
                boost::uint64_t w;
                std::memcpy( &w, &v, sizeof( v ) );

                return hash_value( w );
            }
        };


        template<class T> struct hash_float_impl<T, 96, 64>
        {
            static std::size_t fn( T v )
            {
                boost::uint64_t w[ 2 ] = {};
                std::memcpy( &w, &v, 80 / 8 );

                std::size_t seed = 0;

                seed = hash_value( w[0] ) + hash_detail::hash_mix( seed );
                seed = hash_value( w[1] ) + hash_detail::hash_mix( seed );

                return seed;
            }
        };


        template<class T> struct hash_float_impl<T, 128, 64>
        {
            static std::size_t fn( T v )
            {
                boost::uint64_t w[ 2 ] = {};
                std::memcpy( &w, &v, 80 / 8 );

                std::size_t seed = 0;

                seed = hash_value( w[0] ) + hash_detail::hash_mix( seed );
                seed = hash_value( w[1] ) + hash_detail::hash_mix( seed );

                return seed;
            }
        };


        template<class T, int Digits> struct hash_float_impl<T, 128, Digits>
        {
            static std::size_t fn( T v )
            {
                boost::uint64_t w[ 2 ];
                std::memcpy( &w, &v, sizeof( v ) );

                std::size_t seed = 0;
# 272 "/usr/include/boost/container_hash/hash.hpp" 3 4
                seed = hash_value( w[0] ) + hash_detail::hash_mix( seed );
                seed = hash_value( w[1] ) + hash_detail::hash_mix( seed );


                return seed;
            }
        };

    }

    template <typename T>
    typename boost::enable_if_<boost::is_floating_point<T>::value, std::size_t>::type
        hash_value( T v )
    {
        return boost::hash_detail::hash_float_impl<T>::fn( v + 0 );
    }




    template <class T> std::size_t hash_value( T* const& v )
    {
        boost::uintptr_t x = reinterpret_cast<boost::uintptr_t>( v );
        return boost::hash_value( x + (x >> 3) );
    }



    template<class T, std::size_t N>
    inline std::size_t hash_value( T const (&x)[ N ] )
    {
        return boost::hash_range( x, x + N );
    }

    template<class T, std::size_t N>
    inline std::size_t hash_value( T (&x)[ N ] )
    {
        return boost::hash_range( x, x + N );
    }



    template <class T>
    std::size_t hash_value( std::complex<T> const& v )
    {
        std::size_t re = boost::hash<T>()( v.real() );
        std::size_t im = boost::hash<T>()( v.imag() );

        return re + hash_detail::hash_mix( im );
    }



    template <class A, class B>
    std::size_t hash_value( std::pair<A, B> const& v )
    {
        std::size_t seed = 0;

        boost::hash_combine( seed, v.first );
        boost::hash_combine( seed, v.second );

        return seed;
    }



    template <typename T>
    typename boost::enable_if_<container_hash::is_range<T>::value && !container_hash::is_contiguous_range<T>::value && !container_hash::is_unordered_range<T>::value, std::size_t>::type
        hash_value( T const& v )
    {
        return boost::hash_range( v.begin(), v.end() );
    }



    template <typename T>
    typename boost::enable_if_<container_hash::is_contiguous_range<T>::value, std::size_t>::type
        hash_value( T const& v )
    {
        return boost::hash_range( v.data(), v.data() + v.size() );
    }



    template <typename T>
    typename boost::enable_if_<container_hash::is_unordered_range<T>::value, std::size_t>::type
        hash_value( T const& v )
    {
        return boost::hash_unordered_range( v.begin(), v.end() );
    }
# 412 "/usr/include/boost/container_hash/hash.hpp" 3 4
    template <typename T>
    typename boost::enable_if_<container_hash::is_described_class<T>::value, std::size_t>::type
        hash_value( T const& v )
    {
        static_assert( !boost::is_union<T>::value, "described unions are not supported" );

        std::size_t r = 0;

        using Bd = describe::describe_bases<T, describe::mod_any_access>;

        mp11::mp_for_each<Bd>([&](auto D){

            using B = typename decltype(D)::type;
            boost::hash_combine( r, (B const&)v );

        });

        using Md = describe::describe_members<T, describe::mod_any_access>;

        mp11::mp_for_each<Md>([&](auto D){

            boost::hash_combine( r, v.*D.pointer );

        });

        return r;
    }
# 450 "/usr/include/boost/container_hash/hash.hpp" 3 4
    template <typename T>
    std::size_t hash_value( std::shared_ptr<T> const& x )
    {
        return boost::hash_value( x.get() );
    }

    template <typename T, typename Deleter>
    std::size_t hash_value( std::unique_ptr<T, Deleter> const& x )
    {
        return boost::hash_value( x.get() );
    }







    inline std::size_t hash_value( std::type_index const& v )
    {
        return v.hash_code();
    }







    inline std::size_t hash_value( std::error_code const& v )
    {
        std::size_t seed = 0;

        boost::hash_combine( seed, v.value() );
        boost::hash_combine( seed, &v.category() );

        return seed;
    }

    inline std::size_t hash_value( std::error_condition const& v )
    {
        std::size_t seed = 0;

        boost::hash_combine( seed, v.value() );
        boost::hash_combine( seed, &v.category() );

        return seed;
    }







    template <typename T>
    typename boost::enable_if_<boost::is_same<T, std::nullptr_t>::value, std::size_t>::type
        hash_value( T const& )
    {
        return boost::hash_value( static_cast<void*>( nullptr ) );
    }







    template <typename T>
    std::size_t hash_value( std::optional<T> const& v )
    {
        if( !v )
        {

            return 0x12345678;
        }
        else
        {
            return boost::hash<T>()(*v);
        }
    }







    inline std::size_t hash_value( std::monostate )
    {
        return 0x87654321;
    }

    template <typename... Types>
    std::size_t hash_value( std::variant<Types...> const& v )
    {
        std::size_t seed = 0;

        hash_combine( seed, v.index() );
        std::visit( [&seed](auto&& x) { hash_combine(seed, x); }, v );

        return seed;
    }







    template <class T>
    inline void hash_combine( std::size_t& seed, T const& v )
    {
        seed = boost::hash_detail::hash_mix( seed + 0x9e3779b9 + boost::hash<T>()( v ) );
    }





    template <class It>
    inline void hash_range( std::size_t& seed, It first, It last )
    {
        seed = hash_detail::hash_range( seed, first, last );
    }

    template <class It>
    inline std::size_t hash_range( It first, It last )
    {
        std::size_t seed = 0;

        hash_range( seed, first, last );

        return seed;
    }





    template <class It>
    inline void hash_unordered_range( std::size_t& seed, It first, It last )
    {
        std::size_t r = 0;
        std::size_t const s2( seed );

        for( ; first != last; ++first )
        {
            std::size_t s3( s2 );

            hash_combine<typename std::iterator_traits<It>::value_type>( s3, *first );

            r += s3;
        }

        seed += r;
    }

    template <class It>
    inline std::size_t hash_unordered_range( It first, It last )
    {
        std::size_t seed = 0;

        hash_unordered_range( seed, first, last );

        return seed;
    }





    template <class T> struct hash
    {
        typedef T argument_type;
        typedef std::size_t result_type;

        std::size_t operator()( T const& val ) const
        {
            return hash_value( val );
        }
    };
# 654 "/usr/include/boost/container_hash/hash.hpp" 3 4
    namespace unordered
    {
        template<class T> struct hash_is_avalanching;
        template<class Ch> struct hash_is_avalanching< boost::hash< std::basic_string<Ch> > >: boost::is_integral<Ch> {};



        template<> struct hash_is_avalanching< boost::hash< std::basic_string<char8_t> > >: boost::true_type {};




        template<class Ch> struct hash_is_avalanching< boost::hash< std::basic_string_view<Ch> > >: boost::is_integral<Ch> {};


        template<> struct hash_is_avalanching< boost::hash< std::basic_string_view<char8_t> > >: boost::true_type {};



    }

}
# 48 "/usr/include/boost/type_index/stl_type_index.hpp" 2 3 4
# 61 "/usr/include/boost/type_index/stl_type_index.hpp" 3 4
namespace boost { namespace typeindex {






class stl_type_index
    : public type_index_facade<
        stl_type_index,



            std::type_info

    >
{
public:



    typedef std::type_info type_info_t;


private:
    const type_info_t* data_;

public:
    inline stl_type_index() noexcept
        : data_(&typeid(void))
    {}

    inline stl_type_index(const type_info_t& data) noexcept
        : data_(&data)
    {}

    inline const type_info_t& type_info() const noexcept;

    inline const char* raw_name() const noexcept;
    inline const char* name() const noexcept;
    inline std::string pretty_name() const;

    inline std::size_t hash_code() const noexcept;
    inline bool equal(const stl_type_index& rhs) const noexcept;
    inline bool before(const stl_type_index& rhs) const noexcept;

    template <class T>
    inline static stl_type_index type_id() noexcept;

    template <class T>
    inline static stl_type_index type_id_with_cvr() noexcept;

    template <class T>
    inline static stl_type_index type_id_runtime(const T& value) noexcept;
};

inline const stl_type_index::type_info_t& stl_type_index::type_info() const noexcept {
    return *data_;
}


inline const char* stl_type_index::raw_name() const noexcept {



    return data_->name();

}

inline const char* stl_type_index::name() const noexcept {
    return data_->name();
}

inline std::string stl_type_index::pretty_name() const {
    static const char cvr_saver_name[] = "boost::typeindex::detail::cvr_saver<";
    static constexpr std::string::size_type cvr_saver_name_len = sizeof(cvr_saver_name) - 1;



    const boost::core::scoped_demangled_name demangled_name(data_->name());

    const char* begin = demangled_name.get();
    if (!begin) {
        boost::throw_exception(std::runtime_error("Type name demangling failed"));
    }

    const std::string::size_type len = std::strlen(begin);
    const char* end = begin + len;

    if (len > cvr_saver_name_len) {
        const char* b = std::strstr(begin, cvr_saver_name);
        if (b) {
            b += cvr_saver_name_len;


            while (*b == ' ') {
                ++ b;
            }


            const char* e = end - 1;
            while (e > b && *e != '>') {
                -- e;
            }


            while (e > b && *(e - 1) == ' ') {
                -- e;
            }

            if (b < e) {

                begin = b;
                end = e;
            }
        }
    }

    return std::string(begin, end);
}


inline std::size_t stl_type_index::hash_code() const noexcept {



    return boost::hash_range(raw_name(), raw_name() + std::strlen(raw_name()));

}
# 206 "/usr/include/boost/type_index/stl_type_index.hpp" 3 4
inline bool stl_type_index::equal(const stl_type_index& rhs) const noexcept {

    return raw_name() == rhs.raw_name() || !std::strcmp(raw_name(), rhs.raw_name());



}

inline bool stl_type_index::before(const stl_type_index& rhs) const noexcept {

    return raw_name() != rhs.raw_name() && std::strcmp(raw_name(), rhs.raw_name()) < 0;



}




template <class T>
inline stl_type_index stl_type_index::type_id() noexcept {
    typedef typename boost::remove_reference<T>::type no_ref_t;
    typedef typename boost::remove_cv<no_ref_t>::type no_cvr_prefinal_t;
# 243 "/usr/include/boost/type_index/stl_type_index.hpp" 3 4
        typedef no_cvr_prefinal_t no_cvr_t;


    return typeid(no_cvr_t);
}

namespace detail {
    template <class T> class cvr_saver{};
}

template <class T>
inline stl_type_index stl_type_index::type_id_with_cvr() noexcept {
    typedef typename boost::conditional<
        boost::is_reference<T>::value || boost::is_const<T>::value || boost::is_volatile<T>::value,
        detail::cvr_saver<T>,
        T
    >::type type;

    return typeid(type);
}


template <class T>
inline stl_type_index stl_type_index::type_id_runtime(const T& value) noexcept {



    return typeid(value);

}

}}
# 50 "/usr/include/boost/type_index.hpp" 2 3 4
# 72 "/usr/include/boost/type_index.hpp" 3 4
namespace boost { namespace typeindex {
# 152 "/usr/include/boost/type_index.hpp" 3 4
    typedef boost::typeindex::stl_type_index type_index;
# 164 "/usr/include/boost/type_index.hpp" 3 4
typedef type_index::type_info_t type_info;
# 230 "/usr/include/boost/type_index.hpp" 3 4
template <class T>
inline type_index type_id() noexcept {
    return type_index::type_id<T>();
}
# 250 "/usr/include/boost/type_index.hpp" 3 4
template <class T>
inline type_index type_id_with_cvr() noexcept {
    return type_index::type_id_with_cvr<T>();
}
# 275 "/usr/include/boost/type_index.hpp" 3 4
template <class T>
inline type_index type_id_runtime(const T& runtime_val) noexcept {
    return type_index::type_id_runtime(runtime_val);
}

}}
# 16 "/usr/include/boost/any/detail/placeholder.hpp" 2 3 4


namespace boost {
namespace anys {
namespace detail {

class __attribute__((__visibility__("default"))) placeholder {
public:
    virtual ~placeholder() {}
    virtual const boost::typeindex::type_info& type() const noexcept = 0;
};

}
}
}
# 24 "/usr/include/boost/any.hpp" 2 3 4


# 1 "/usr/include/boost/type_traits/decay.hpp" 1 3 4
# 12 "/usr/include/boost/type_traits/decay.hpp" 3 4
# 1 "/usr/include/boost/type_traits/is_array.hpp" 1 3 4
# 20 "/usr/include/boost/type_traits/is_array.hpp" 3 4
namespace boost {




   template <class T> struct is_array : public false_type {};

   template <class T, std::size_t N> struct is_array<T[N]> : public true_type {};
   template <class T, std::size_t N> struct is_array<T const[N]> : public true_type{};
   template <class T, std::size_t N> struct is_array<T volatile[N]> : public true_type{};
   template <class T, std::size_t N> struct is_array<T const volatile[N]> : public true_type{};

   template <class T> struct is_array<T[]> : public true_type{};
   template <class T> struct is_array<T const[]> : public true_type{};
   template <class T> struct is_array<T const volatile[]> : public true_type{};
   template <class T> struct is_array<T volatile[]> : public true_type{};





}
# 13 "/usr/include/boost/type_traits/decay.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/is_function.hpp" 1 3 4
# 19 "/usr/include/boost/type_traits/is_function.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/is_function_cxx_11.hpp" 1 3 4
# 16 "/usr/include/boost/type_traits/detail/is_function_cxx_11.hpp" 3 4
namespace boost {

   template <class T>
   struct is_function : public false_type {};
# 36 "/usr/include/boost/type_traits/detail/is_function_cxx_11.hpp" 3 4
   template <class Ret, class...Args , bool NE>
   struct is_function<Ret (Args...)noexcept(NE)> : public true_type {};

   template <class Ret, class ...Args , bool NE>
   struct is_function<Ret(Args..., ...)noexcept(NE)> : public true_type {};



   template <class Ret, class...Args , bool NE>
   struct is_function<Ret (Args...)const noexcept(NE)> : public true_type {};

   template <class Ret, class ...Args , bool NE>
   struct is_function<Ret(Args..., ...)const noexcept(NE)> : public true_type {};



   template <class Ret, class...Args , bool NE>
   struct is_function<Ret (Args...)volatile noexcept(NE)> : public true_type {};

   template <class Ret, class ...Args , bool NE>
   struct is_function<Ret(Args..., ...)volatile noexcept(NE)> : public true_type {};


   template <class Ret, class...Args , bool NE>
   struct is_function<Ret (Args...)const volatile noexcept(NE)> : public true_type {};

   template <class Ret, class ...Args , bool NE>
   struct is_function<Ret(Args..., ...)const volatile noexcept(NE)> : public true_type {};




   template <class Ret, class...Args , bool NE>
   struct is_function<Ret (Args...)& noexcept(NE)> : public true_type {};

   template <class Ret, class ...Args , bool NE>
   struct is_function<Ret(Args..., ...)& noexcept(NE)> : public true_type {};


   template <class Ret, class...Args , bool NE>
   struct is_function<Ret (Args...)const & noexcept(NE)> : public true_type {};

   template <class Ret, class ...Args , bool NE>
   struct is_function<Ret(Args..., ...)const & noexcept(NE)> : public true_type {};


   template <class Ret, class...Args , bool NE>
   struct is_function<Ret (Args...)volatile & noexcept(NE)> : public true_type {};

   template <class Ret, class ...Args , bool NE>
   struct is_function<Ret(Args..., ...)volatile & noexcept(NE)> : public true_type {};


   template <class Ret, class...Args , bool NE>
   struct is_function<Ret (Args...)const volatile & noexcept(NE)> : public true_type {};

   template <class Ret, class ...Args , bool NE>
   struct is_function<Ret(Args..., ...)const volatile & noexcept(NE)> : public true_type {};




   template <class Ret, class...Args , bool NE>
   struct is_function<Ret (Args...)&& noexcept(NE)> : public true_type {};

   template <class Ret, class ...Args , bool NE>
   struct is_function<Ret(Args..., ...)&& noexcept(NE)> : public true_type {};


   template <class Ret, class...Args , bool NE>
   struct is_function<Ret (Args...)const && noexcept(NE)> : public true_type {};

   template <class Ret, class ...Args , bool NE>
   struct is_function<Ret(Args..., ...)const && noexcept(NE)> : public true_type {};


   template <class Ret, class...Args , bool NE>
   struct is_function<Ret (Args...)volatile && noexcept(NE)> : public true_type {};

   template <class Ret, class ...Args , bool NE>
   struct is_function<Ret(Args..., ...)volatile && noexcept(NE)> : public true_type {};


   template <class Ret, class...Args , bool NE>
   struct is_function<Ret (Args...)const volatile && noexcept(NE)> : public true_type {};

   template <class Ret, class ...Args , bool NE>
   struct is_function<Ret(Args..., ...)const volatile && noexcept(NE)> : public true_type {};
# 669 "/usr/include/boost/type_traits/detail/is_function_cxx_11.hpp" 3 4
}
# 20 "/usr/include/boost/type_traits/is_function.hpp" 2 3 4
# 14 "/usr/include/boost/type_traits/decay.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/remove_bounds.hpp" 1 3 4
# 12 "/usr/include/boost/type_traits/remove_bounds.hpp" 3 4
# 1 "/usr/include/boost/type_traits/remove_extent.hpp" 1 3 4
# 16 "/usr/include/boost/type_traits/remove_extent.hpp" 3 4
namespace boost {

template <class T> struct remove_extent{ typedef T type; };


template <typename T, std::size_t N> struct remove_extent<T[N]> { typedef T type; };
template <typename T, std::size_t N> struct remove_extent<T const[N]> { typedef T const type; };
template <typename T, std::size_t N> struct remove_extent<T volatile [N]> { typedef T volatile type; };
template <typename T, std::size_t N> struct remove_extent<T const volatile [N]> { typedef T const volatile type; };

template <typename T> struct remove_extent<T[]> { typedef T type; };
template <typename T> struct remove_extent<T const[]> { typedef T const type; };
template <typename T> struct remove_extent<T volatile[]> { typedef T volatile type; };
template <typename T> struct remove_extent<T const volatile[]> { typedef T const volatile type; };





   template <class T> using remove_extent_t = typename remove_extent<T>::type;



}
# 13 "/usr/include/boost/type_traits/remove_bounds.hpp" 2 3 4

namespace boost
{

template <class T> struct remove_bounds : public remove_extent<T> {};



template <class T> using remove_bounds_t = typename remove_bounds<T>::type;




}
# 15 "/usr/include/boost/type_traits/decay.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/add_pointer.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/add_pointer.hpp" 3 4
namespace boost {
# 50 "/usr/include/boost/type_traits/add_pointer.hpp" 3 4
template <typename T>
struct add_pointer
{
    typedef typename remove_reference<T>::type no_ref_type;
    typedef no_ref_type* type;
};





   template <class T> using add_pointer_t = typename add_pointer<T>::type;



}
# 16 "/usr/include/boost/type_traits/decay.hpp" 2 3 4



namespace boost
{

   namespace detail
   {

      template <class T, bool Array, bool Function> struct decay_imp { typedef typename remove_cv<T>::type type; };
      template <class T> struct decay_imp<T, true, false> { typedef typename remove_bounds<T>::type* type; };
      template <class T> struct decay_imp<T, false, true> { typedef T* type; };

   }

    template< class T >
    struct decay
    {
    private:
        typedef typename remove_reference<T>::type Ty;
    public:
       typedef typename boost::detail::decay_imp<Ty, boost::is_array<Ty>::value, boost::is_function<Ty>::value>::type type;
    };



   template <class T> using decay_t = typename decay<T>::type;



}
# 27 "/usr/include/boost/any.hpp" 2 3 4

# 1 "/usr/include/boost/type_traits/add_reference.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/add_reference.hpp" 3 4
namespace boost {

namespace detail {






template <typename T>
struct add_reference_impl
{
    typedef T& type;
};


template <typename T>
struct add_reference_impl<T&&>
{
    typedef T&& type;
};


}

template <class T> struct add_reference
{
   typedef typename boost::detail::add_reference_impl<T>::type type;
};
template <class T> struct add_reference<T&>
{
   typedef T& type;
};


template <> struct add_reference<void> { typedef void type; };

template <> struct add_reference<const void> { typedef const void type; };
template <> struct add_reference<const volatile void> { typedef const volatile void type; };
template <> struct add_reference<volatile void> { typedef volatile void type; };




template <class T> using add_reference_t = typename add_reference<T>::type;




}
# 29 "/usr/include/boost/any.hpp" 2 3 4




# 1 "/usr/include/boost/core/enable_if.hpp" 1 3 4
# 24 "/usr/include/boost/core/enable_if.hpp" 3 4
namespace boost
{
  template<typename T, typename R=void>
  struct enable_if_has_type
  {
    typedef R type;
  };

  template <bool B, class T = void>
  struct enable_if_c {
    typedef T type;
  };

  template <class T>
  struct enable_if_c<false, T> {};

  template <class Cond, class T = void>
  struct enable_if : public enable_if_c<Cond::value, T> {};

  template <bool B, class T>
  struct lazy_enable_if_c {
    typedef typename T::type type;
  };

  template <class T>
  struct lazy_enable_if_c<false, T> {};

  template <class Cond, class T>
  struct lazy_enable_if : public lazy_enable_if_c<Cond::value, T> {};


  template <bool B, class T = void>
  struct disable_if_c {
    typedef T type;
  };

  template <class T>
  struct disable_if_c<true, T> {};

  template <class Cond, class T = void>
  struct disable_if : public disable_if_c<Cond::value, T> {};

  template <bool B, class T>
  struct lazy_disable_if_c {
    typedef typename T::type type;
  };

  template <class T>
  struct lazy_disable_if_c<true, T> {};

  template <class Cond, class T>
  struct lazy_disable_if : public lazy_disable_if_c<Cond::value, T> {};

}
# 34 "/usr/include/boost/any.hpp" 2 3 4
# 1 "/usr/include/boost/core/addressof.hpp" 1 3 4
# 34 "/usr/include/boost/core/addressof.hpp" 3 4
namespace boost {

template<class T>
constexpr inline T*
addressof(T& o) noexcept
{
    return __builtin_addressof(o);
}

}
# 266 "/usr/include/boost/core/addressof.hpp" 3 4
namespace boost {

template<class T>
const T* addressof(const T&&) = delete;

}
# 35 "/usr/include/boost/any.hpp" 2 3 4



namespace boost
{


    class any
    {
    public:


        constexpr any() noexcept
          : content(0)
        {
        }







        template<typename ValueType>
        any(const ValueType & value)
          : content(new holder<
                typename remove_cv<typename decay<const ValueType>::type>::type
            >(value))
        {
            static_assert(!anys::detail::is_basic_any<ValueType>::value, "boost::any shall not be constructed from boost::anys::basic_any");



        }
# 78 "/usr/include/boost/any.hpp" 3 4
        any(const any & other)
          : content(other.content ? other.content->clone() : 0)
        {
        }
# 90 "/usr/include/boost/any.hpp" 3 4
        any(any&& other) noexcept
          : content(other.content)
        {
            other.content = 0;
        }
# 103 "/usr/include/boost/any.hpp" 3 4
        template<typename ValueType>
        any(ValueType&& value
            , typename boost::disable_if<boost::is_same<any&, ValueType> >::type* = 0
            , typename boost::disable_if<boost::is_const<ValueType> >::type* = 0)
          : content(new holder< typename decay<ValueType>::type >(static_cast<ValueType&&>(value)))
        {
            static_assert(!anys::detail::is_basic_any<typename boost::decay<ValueType>::type>::value, "boost::any shall not be constructed from boost::anys::basic_any");



        }





        ~any() noexcept
        {
            delete content;
        }

    public:





        any & swap(any & rhs) noexcept
        {
            placeholder* tmp = content;
            content = rhs.content;
            rhs.content = tmp;
            return *this;
        }
# 147 "/usr/include/boost/any.hpp" 3 4
        any & operator=(const any& rhs)
        {
            any(rhs).swap(*this);
            return *this;
        }
# 183 "/usr/include/boost/any.hpp" 3 4
        any & operator=(any&& rhs) noexcept
        {
            rhs.swap(*this);
            any().swap(rhs);
            return *this;
        }
# 200 "/usr/include/boost/any.hpp" 3 4
        template <class ValueType>
        any & operator=(ValueType&& rhs)
        {
            static_assert(!anys::detail::is_basic_any<typename boost::decay<ValueType>::type>::value, "boost::anys::basic_any shall not be assigned into boost::any");



            any(static_cast<ValueType&&>(rhs)).swap(*this);
            return *this;
        }


    public:



        bool empty() const noexcept
        {
            return !content;
        }


        void clear() noexcept
        {
            any().swap(*this);
        }







        const boost::typeindex::type_info& type() const noexcept
        {
            return content ? content->type() : boost::typeindex::type_id<void>().type_info();
        }


    private:




        class __attribute__((__visibility__("default"))) placeholder: public boost::anys::detail::placeholder
        {
        public:
            virtual placeholder * clone() const = 0;
        };

        template<typename ValueType>
        class holder

          final

          : public placeholder
        {
        public:

            holder(const ValueType & value)
              : held(value)
            {
            }


            holder(ValueType&& value)
              : held(static_cast< ValueType&& >(value))
            {
            }

        public:

            const boost::typeindex::type_info& type() const noexcept override
            {
                return boost::typeindex::type_id<ValueType>().type_info();
            }

            placeholder * clone() const override
            {
                return new holder(held);
            }

        public:

            ValueType held;

        private:
            holder & operator=(const holder &);
        };



    private:
        template<typename ValueType>
        friend ValueType * unsafe_any_cast(any *) noexcept;

        friend class boost::anys::unique_any;







        placeholder * content;

    };



    inline void swap(any & lhs, any & rhs) noexcept
    {
        lhs.swap(rhs);
    }
# 322 "/usr/include/boost/any.hpp" 3 4
    template<typename ValueType>
    inline ValueType * unsafe_any_cast(any * operand) noexcept
    {
        return boost::addressof(
            static_cast<any::holder<ValueType> *>(operand->content)->held
        );
    }

    template<typename ValueType>
    inline const ValueType * unsafe_any_cast(const any * operand) noexcept
    {
        return boost::unsafe_any_cast<ValueType>(const_cast<any *>(operand));
    }




    template<typename ValueType>
    ValueType * any_cast(any * operand) noexcept
    {
        return operand && operand->type() == boost::typeindex::type_id<ValueType>()
            ? boost::unsafe_any_cast<typename boost::remove_cv<ValueType>::type>(operand)
            : 0;
    }



    template<typename ValueType>
    inline const ValueType * any_cast(const any * operand) noexcept
    {
        return boost::any_cast<ValueType>(const_cast<any *>(operand));
    }




    template<typename ValueType>
    ValueType any_cast(any & operand)
    {
        typedef typename remove_reference<ValueType>::type nonref;

        nonref * result = boost::any_cast<nonref>(boost::addressof(operand));
        if(!result)
            boost::throw_exception(bad_any_cast());





        typedef typename boost::conditional<
            boost::is_reference<ValueType>::value,
            ValueType,
            typename boost::add_reference<ValueType>::type
        >::type ref_type;





        return static_cast<ref_type>(*result);



    }




    template<typename ValueType>
    inline ValueType any_cast(const any & operand)
    {
        typedef typename remove_reference<ValueType>::type nonref;
        return boost::any_cast<const nonref &>(const_cast<any &>(operand));
    }





    template<typename ValueType>
    inline ValueType any_cast(any&& operand)
    {
        static_assert(boost::is_rvalue_reference<ValueType&&>::value || boost::is_const< typename boost::remove_reference<ValueType>::type >::value, "boost::any_cast shall not be used for getting nonconst references to temporary objects");




        return boost::any_cast<ValueType>(operand);
    }

}
# 32 "/home/avi/scylla-maint/seastar/include/seastar/util/program-options.hh" 2
# 56 "/home/avi/scylla-maint/seastar/include/seastar/util/program-options.hh"
namespace seastar {

namespace program_options {
# 73 "/home/avi/scylla-maint/seastar/include/seastar/util/program-options.hh"
class string_map final : private std::unordered_map<sstring, sstring> {
private:
    using base = std::unordered_map<sstring, sstring>;
public:
    using base::value_type;
    using base::key_type;
    using base::mapped_type;

    using base::base;
    using base::at;
    using base::find;
    using base::count;
    using base::emplace;
    using base::clear;
    using base::operator[];
    using base::begin;
    using base::end;

    friend bool operator==(const string_map&, const string_map&);
    friend bool operator!=(const string_map&, const string_map&);
};

inline bool operator==(const string_map& lhs, const string_map& rhs) {
    return static_cast<const string_map::base&>(lhs) == static_cast<const string_map::base&>(rhs);
}

inline bool operator!=(const string_map& lhs, const string_map& rhs) {
    return !(lhs == rhs);
}




sstring get_or_default(const string_map&, const sstring& key, const sstring& def = sstring());

std::istream& operator>>(std::istream& is, string_map&);
std::ostream& operator<<(std::ostream& os, const string_map&);






void validate(boost::any& out, const std::vector<std::string>& in, string_map*, int);

using list_base_hook = boost::intrusive::list_base_hook<boost::intrusive::link_mode<boost::intrusive::auto_unlink>>;

}


enum class log_level;
enum class logger_timestamp_style;
enum class logger_ostream_type;
namespace memory {
    enum class alloc_failure_kind;
}

namespace program_options {






class option_group;




class options_descriptor {
public:






    virtual bool visit_group_start(const std::string& name, bool used) = 0;




    virtual void visit_group_end() = 0;
# 164 "/home/avi/scylla-maint/seastar/include/seastar/util/program-options.hh"
    virtual bool visit_value_metadata(const std::string& name, const std::string& description, bool used) = 0;


    virtual void visit_value() = 0;

    virtual void visit_value(const bool* default_val) = 0;

    virtual void visit_value(const int* default_val) = 0;

    virtual void visit_value(const unsigned* default_val) = 0;

    virtual void visit_value(const float* default_val) = 0;

    virtual void visit_value(const double* default_val) = 0;

    virtual void visit_value(const std::string* default_val) = 0;

    virtual void visit_value(const std::set<unsigned>* default_val) = 0;

    virtual void visit_value(const log_level* default_val) = 0;

    virtual void visit_value(const logger_timestamp_style* default_val) = 0;

    virtual void visit_value(const logger_ostream_type* default_val) = 0;

    virtual void visit_value(const memory::alloc_failure_kind* default_val) = 0;

    virtual void visit_value(const std::unordered_map<sstring, log_level>* default_val) = 0;


    virtual void visit_selection_value(const std::vector<std::string>& candidate_names, const std::size_t* default_candidate) = 0;
};




class options_mutator {
public:






    virtual bool visit_group_start(const std::string& name, bool used) = 0;




    virtual void visit_group_end() = 0;
# 222 "/home/avi/scylla-maint/seastar/include/seastar/util/program-options.hh"
    virtual bool visit_value_metadata(const std::string& name, bool used) = 0;


    virtual bool visit_value() = 0;

    virtual bool visit_value(bool& val) = 0;

    virtual bool visit_value(int& val) = 0;

    virtual bool visit_value(unsigned& val) = 0;

    virtual bool visit_value(float& val) = 0;

    virtual bool visit_value(double& val) = 0;

    virtual bool visit_value(std::string& val) = 0;

    virtual bool visit_value(std::set<unsigned>& val) = 0;

    virtual bool visit_value(log_level& val) = 0;

    virtual bool visit_value(logger_timestamp_style& val) = 0;

    virtual bool visit_value(logger_ostream_type& val) = 0;

    virtual bool visit_value(memory::alloc_failure_kind& val) = 0;

    virtual bool visit_value(std::unordered_map<sstring, log_level>& val) = 0;


    virtual bool visit_selection_value(const std::vector<std::string>& candidate_names, std::size_t& selected_candidate) = 0;
};


struct unused {};

class basic_value;
# 292 "/home/avi/scylla-maint/seastar/include/seastar/util/program-options.hh"
class option_group : public list_base_hook {
    friend class basic_value;

public:
    using value_list_type = boost::intrusive::list<
            basic_value,
            boost::intrusive::base_hook<list_base_hook>,
            boost::intrusive::constant_time_size<false>>;

    using option_group_list_type = boost::intrusive::list<
            option_group,
            boost::intrusive::base_hook<list_base_hook>,
            boost::intrusive::constant_time_size<false>>;

private:
    option_group* _parent;
    bool _used = true;
    std::string _name;
    value_list_type _values;
    option_group_list_type _subgroups;

public:





    explicit option_group(option_group* parent, std::string name);





    explicit option_group(option_group* parent, std::string name, unused);
    option_group(option_group&&);
    option_group(const option_group&) = delete;
    virtual ~option_group() = default;

    option_group& operator=(option_group&&) = delete;
    option_group& operator=(const option_group&) = delete;


    operator bool () const { return !_values.empty(); }
    bool used() const { return _used; }
    const std::string& name() const { return _name; }
    const value_list_type& values() const { return _values; }
    value_list_type& values() { return _values; }
# 366 "/home/avi/scylla-maint/seastar/include/seastar/util/program-options.hh"
    void describe(options_descriptor& descriptor) const;
# 376 "/home/avi/scylla-maint/seastar/include/seastar/util/program-options.hh"
    void mutate(options_mutator& mutator);
};




class basic_value : public list_base_hook {
    friend class option_group;

public:
    option_group* _group;
    bool _used = true;
    std::string _name;
    std::string _description;

private:
    virtual void do_describe(options_descriptor& descriptor) const = 0;
    virtual void do_mutate(options_mutator& mutator) = 0;

public:
    basic_value(option_group& group, bool used, std::string name, std::string description);
    basic_value(basic_value&&);
    basic_value(const basic_value&) = delete;
    virtual ~basic_value() = default;

    basic_value& operator=(basic_value&&) = delete;
    basic_value& operator=(const basic_value&) = delete;

    bool used() const { return _used; }
    const std::string& name() const { return _name; }
    const std::string& description() const { return _description; }

    void describe(options_descriptor& descriptor) const;
    void mutate(options_mutator& mutator);
};




template <typename T = std::monostate>
class value : public basic_value {
    std::optional<T> _value;
    bool _defaulted = true;

private:
    virtual void do_describe(options_descriptor& descriptor) const override {
        auto* val = _value ? &*_value : nullptr;
        descriptor.visit_value(val);
    }
    virtual void do_mutate(options_mutator& mutator) override {
        T val;
        if (mutator.visit_value(val)) {
            _value = std::move(val);
            _defaulted = false;
        }
    }
    void do_set_value(T value, bool defaulted) {
        _value = std::move(value);
        _defaulted = defaulted;
    }

public:






    value(option_group& group, std::string name, std::optional<T> default_value, std::string description)
        : basic_value(group, true, std::move(name), std::move(description))
        , _value(std::move(default_value))
    { }

    value(option_group& group, std::string name, unused)
        : basic_value(group, false, std::move(name), {})
    { }
    value(value&&) = default;

    operator bool () const { return bool(_value); }

    bool defaulted() const { return _defaulted; }

    const T& get_value() const { return _value.value(); }
    T& get_value() { return _value.value(); }
    void set_default_value(T value) { do_set_value(std::move(value), true); }
    void set_value(T value) { do_set_value(std::move(value), false); }
};




template <>
class value<std::monostate> : public basic_value {
    std::optional<bool> _set;

private:
    virtual void do_describe(options_descriptor& descriptor) const override {
        descriptor.visit_value();
    }
    virtual void do_mutate(options_mutator& mutator) override {
        bool is_set = mutator.visit_value();
        if (_set.has_value()) {

            if (is_set) {
                _set = true;
            }
        } else {
            _set = is_set;
        }
    }

public:





    value(option_group& group, std::string name, std::string description)
        : basic_value(group, true, std::move(name), std::move(description))
    { }

    value(option_group& group, std::string name, unused)
        : basic_value(group, false, std::move(name), {})
    { }

    operator bool () const { return _set ? _set.value() : false; }
    void set_value() { _set = true; }
    void unset_value() { _set = false; }
};
# 516 "/home/avi/scylla-maint/seastar/include/seastar/util/program-options.hh"
template <typename T = std::monostate>
class selection_value : public basic_value {
public:
    using deleter = std::function<void(T*)>;
    using value_handle = std::unique_ptr<T, deleter>;
    struct candidate {
        std::string name;
        value_handle value;
        std::unique_ptr<option_group> opts;
    };
    using candidates = std::vector<candidate>;

private:
    static constexpr size_t no_selected_candidate = -1;

private:
    candidates _candidates;
    size_t _selected_candidate = no_selected_candidate;
    bool _defaulted = true;

private:
    std::vector<std::string> get_candidate_names() const {
        std::vector<std::string> candidate_names;
        candidate_names.reserve(_candidates.size());
        for (const auto& c : _candidates) {
            candidate_names.push_back(c.name);
        }
        return candidate_names;
    }
    virtual void do_describe(options_descriptor& descriptor) const override {
        descriptor.visit_selection_value(get_candidate_names(), _selected_candidate == no_selected_candidate ? nullptr : &_selected_candidate);
        for (auto& c : _candidates) {
            if (c.opts) {
                c.opts->describe(descriptor);
            }
        }
    }
    virtual void do_mutate(options_mutator& mutator) override {
        if (mutator.visit_selection_value(get_candidate_names(), _selected_candidate)) {
            _defaulted = false;
        }
        if (_selected_candidate != no_selected_candidate) {
            auto& c = _candidates.at(_selected_candidate);
            if (c.opts) {
                c.opts->mutate(mutator);
            }
        }
    }
    size_t find_candidate(const std::string& candidate_name) {
        auto it = find_if(_candidates.begin(), _candidates.end(), [&] (const auto& candidate) {
            return candidate.name == candidate_name;
        });
        if (it == _candidates.end()) {
            throw std::invalid_argument(fmt::format("find_candidate(): failed to find candidate {}", candidate_name));
        }
        return it - _candidates.begin();
    }

    option_group* do_select_candidate(std::string candidate_name, bool defaulted) {
        _selected_candidate = find_candidate(candidate_name);
        _defaulted = defaulted;
        return _candidates.at(_selected_candidate).opts.get();
    }

public:







    selection_value(option_group& group, std::string name, candidates candidates, std::string default_candidate, std::string description)
        : basic_value(group, true, std::move(name), std::move(description))
        , _candidates(std::move(candidates))
        , _selected_candidate(find_candidate(default_candidate))
    { }
    selection_value(option_group& group, std::string name, candidates candidates, std::string description)
        : basic_value(group, true, std::move(name), std::move(description))
        , _candidates(std::move(candidates))
    { }

    selection_value(option_group& group, std::string name, unused)
        : basic_value(group, false, std::move(name), {})
    { }

    operator bool () const { return _selected_candidate != no_selected_candidate; }

    bool defaulted() const { return _defaulted; }

    const std::string& get_selected_candidate_name() const { return _candidates.at(_selected_candidate).name; }

    const option_group* get_selected_candidate_opts() const { return _candidates.at(_selected_candidate).opts.get(); }

    option_group* get_selected_candidate_opts() { return _candidates.at(_selected_candidate).opts.get(); }
    T& get_selected_candidate() const { return *_candidates.at(_selected_candidate).value; }



    option_group* select_candidate(std::string candidate_name) { return do_select_candidate(candidate_name, false); }



    option_group* select_default_candidate(std::string candidate_name) { return do_select_candidate(candidate_name, true); }
};



}


}
# 42 "/home/avi/scylla-maint/seastar/include/seastar/net/api.hh" 2


namespace seastar {

inline
bool is_ip_unspecified(const ipv4_addr& addr) noexcept {
    return addr.is_ip_unspecified();
}

inline
bool is_port_unspecified(const ipv4_addr& addr) noexcept {
    return addr.is_port_unspecified();
}

inline
socket_address make_ipv4_address(const ipv4_addr& addr) noexcept {
    return socket_address(addr);
}

inline
socket_address make_ipv4_address(uint32_t ip, uint16_t port) noexcept {
    return make_ipv4_address(ipv4_addr(ip, port));
}

namespace net {


struct tcp_keepalive_params {
    std::chrono::seconds idle;
    std::chrono::seconds interval;
    unsigned count;
};


struct sctp_keepalive_params {
    std::chrono::seconds interval;
    unsigned count;
};

using keepalive_params = std::variant<tcp_keepalive_params, sctp_keepalive_params>;


class connected_socket_impl;
class socket_impl;

class server_socket_impl;
class datagram_channel_impl;
class get_impl;


class datagram_impl {
public:
    virtual ~datagram_impl() {};
    virtual socket_address get_src() = 0;
    virtual socket_address get_dst() = 0;
    virtual uint16_t get_dst_port() = 0;
    virtual packet& get_data() = 0;
};

using udp_datagram_impl = datagram_impl;

class datagram final {
private:
    std::unique_ptr<datagram_impl> _impl;
public:
    datagram(std::unique_ptr<datagram_impl>&& impl) noexcept : _impl(std::move(impl)) {};
    socket_address get_src() { return _impl->get_src(); }
    socket_address get_dst() { return _impl->get_dst(); }
    uint16_t get_dst_port() { return _impl->get_dst_port(); }
    packet& get_data() { return _impl->get_data(); }
};

using udp_datagram = datagram;

class datagram_channel {
private:
    std::unique_ptr<datagram_channel_impl> _impl;
public:
    datagram_channel() noexcept;
    datagram_channel(std::unique_ptr<datagram_channel_impl>) noexcept;
    ~datagram_channel();

    datagram_channel(datagram_channel&&) noexcept;
    datagram_channel& operator=(datagram_channel&&) noexcept;

    socket_address local_address() const;

    future<datagram> receive();
    future<> send(const socket_address& dst, const char* msg);
    future<> send(const socket_address& dst, packet p);
    bool is_closed() const;

    void shutdown_input();

    void shutdown_output();





    void close();
};

using udp_channel = datagram_channel;

class network_interface_impl;

}
# 160 "/home/avi/scylla-maint/seastar/include/seastar/net/api.hh"
struct connected_socket_input_stream_config final {

    unsigned buffer_size = 8192;



    unsigned min_buffer_size = 512;



    unsigned max_buffer_size = 128 * 1024;
};


struct session_dn {
    sstring subject;
    sstring issuer;
};





class connected_socket {
    friend class net::get_impl;
    std::unique_ptr<net::connected_socket_impl> _csi;
public:

    connected_socket() noexcept;
    ~connected_socket();


    explicit connected_socket(std::unique_ptr<net::connected_socket_impl> csi) noexcept;


    connected_socket(connected_socket&& cs) noexcept;

    connected_socket& operator=(connected_socket&& cs) noexcept;





    input_stream<char> input(connected_socket_input_stream_config csisc = {});




    output_stream<char> output(size_t buffer_size = 8192);

    void set_nodelay(bool nodelay);



    bool get_nodelay() const;

    void set_keepalive(bool keepalive);


    bool get_keepalive() const;

    void set_keepalive_parameters(const net::keepalive_params& p);

    net::keepalive_params get_keepalive_parameters() const;



    void set_sockopt(int level, int optname, const void* data, size_t len);



    int get_sockopt(int level, int optname, void* data, size_t len) const;

    socket_address local_address() const noexcept;

    socket_address remote_address() const noexcept;







    void shutdown_output();





    void shutdown_input();







    explicit operator bool() const noexcept {
        return static_cast<bool>(_csi);
    }
# 272 "/home/avi/scylla-maint/seastar/include/seastar/net/api.hh"
    future<> wait_input_shutdown();
};
# 283 "/home/avi/scylla-maint/seastar/include/seastar/net/api.hh"
class socket {
    std::unique_ptr<net::socket_impl> _si;
public:
    socket() noexcept = default;
    ~socket();


    explicit socket(std::unique_ptr<net::socket_impl> si) noexcept;


    socket(socket&&) noexcept;

    socket& operator=(socket&&) noexcept;




    future<connected_socket> connect(socket_address sa, socket_address local = {}, transport proto = transport::TCP);


    void set_reuseaddr(bool reuseaddr);


    bool get_reuseaddr() const;




    void shutdown();
};







struct accept_result {
    connected_socket connection;
    socket_address remote_address;
};


class server_socket {
    std::unique_ptr<net::server_socket_impl> _ssi;
    bool _aborted = false;
public:
    enum class load_balancing_algorithm {


        connection_distribution,




        port,

        fixed,
        default_ = connection_distribution
    };

    server_socket() noexcept;

    explicit server_socket(std::unique_ptr<net::server_socket_impl> ssi) noexcept;


    server_socket(server_socket&& ss) noexcept;
    ~server_socket();

    server_socket& operator=(server_socket&& cs) noexcept;
# 361 "/home/avi/scylla-maint/seastar/include/seastar/net/api.hh"
    future<accept_result> accept();





    void abort_accept();
# 376 "/home/avi/scylla-maint/seastar/include/seastar/net/api.hh"
    socket_address local_address() const noexcept;
# 385 "/home/avi/scylla-maint/seastar/include/seastar/net/api.hh"
    explicit operator bool() const noexcept {
        return static_cast<bool>(_ssi);
    }
};



struct listen_options {
    bool reuse_address = false;
    server_socket::load_balancing_algorithm lba = server_socket::load_balancing_algorithm::default_;
    transport proto = transport::TCP;
    int listen_backlog = 100;
    unsigned fixed_cpu = 0u;
    std::optional<file_permissions> unix_domain_socket_permissions;
    void set_fixed_cpu(unsigned cpu) {
        lba = server_socket::load_balancing_algorithm::fixed;
        fixed_cpu = cpu;
    }
};

class network_interface {
private:
    shared_ptr<net::network_interface_impl> _impl;
public:
    network_interface() = delete;
    network_interface(shared_ptr<net::network_interface_impl>) noexcept;
    network_interface(network_interface&&) noexcept;

    network_interface& operator=(network_interface&&) noexcept;

    uint32_t index() const;
    uint32_t mtu() const;

    const sstring& name() const;
    const sstring& display_name() const;
    const std::vector<net::inet_address>& addresses() const;
    const std::vector<uint8_t> hardware_address() const;

    bool is_loopback() const;
    bool is_virtual() const;
    bool is_up() const;
    bool supports_ipv6() const;
};

class network_stack {
public:
    virtual ~network_stack() {}
    virtual server_socket listen(socket_address sa, listen_options opts) = 0;

    future<connected_socket> connect(socket_address sa, socket_address = {}, transport proto = transport::TCP);
    virtual ::seastar::socket socket() = 0;

    [[deprecated("Use `make_[un]bound_datagram_channel` instead")]]
    virtual net::udp_channel make_udp_channel(const socket_address& = {}) = 0;

    virtual net::datagram_channel make_unbound_datagram_channel(sa_family_t) = 0;
    virtual net::datagram_channel make_bound_datagram_channel(const socket_address& local) = 0;
    virtual future<> initialize() {
        return make_ready_future();
    }
    virtual bool has_per_core_namespace() = 0;



    virtual bool supports_ipv6() const {
        return false;
    }






    virtual std::vector<network_interface> network_interfaces();
};

struct network_stack_entry {
    using factory_func = noncopyable_function<future<std::unique_ptr<network_stack>> (const program_options::option_group&)>;

    sstring name;
    std::unique_ptr<program_options::option_group> opts;
    factory_func factory;
    bool is_default;
};

}
# 32 "/home/avi/scylla-maint/seastar/include/seastar/rpc/rpc.hh" 2


# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/condition-variable.hh" 1
# 36 "/home/avi/scylla-maint/seastar/include/seastar/core/condition-variable.hh"
namespace seastar {
# 45 "/home/avi/scylla-maint/seastar/include/seastar/core/condition-variable.hh"
class broken_condition_variable : public std::exception {
public:

    virtual const char* what() const noexcept;
};



class condition_variable_timed_out : public std::exception {
public:

    virtual const char* what() const noexcept;
};
# 72 "/home/avi/scylla-maint/seastar/include/seastar/core/condition-variable.hh"
class condition_variable {
private:


    struct waiter : public boost::intrusive::list_base_hook<boost::intrusive::link_mode<boost::intrusive::auto_unlink>> {
        waiter() = default;
        waiter(waiter&&) = default;
        waiter(const waiter&) = delete;
        waiter& operator=(const waiter&) = delete;
        virtual ~waiter() = default;
        void timeout() noexcept;

        virtual void signal() noexcept = 0;
        virtual void set_exception(std::exception_ptr) noexcept = 0;
    };

    struct promise_waiter : public waiter, public promise<> {
        void signal() noexcept override {
            set_value();



            delete this;
        }
        void set_exception(std::exception_ptr ep) noexcept override {
            promise<>::set_exception(std::move(ep));

            delete this;
        }
    };

    struct [[nodiscard("must co_await a when() call")]] awaiter : public waiter {
        condition_variable* _cv;
        promise<> _p;

        awaiter(condition_variable* cv)
            : _cv(cv)
        {}

        void signal() noexcept override {
            _p.set_value();
        }
        void set_exception(std::exception_ptr ep) noexcept override {
            _p.set_exception(std::move(ep));
        }
        auto operator co_await() {
            if (_cv->check_and_consume_signal()) {
                return ::seastar::internal::awaiter<false, void>(make_ready_future<>());
            }
            _cv->add_waiter(*this);
            return ::seastar::internal::awaiter<false, void>(_p.get_future());
        }
    };

    template<typename Clock, typename Duration>
    struct [[nodiscard("must co_await a when() call")]] timeout_awaiter : public awaiter, public timer<Clock> {
        using my_type = timeout_awaiter<Clock, Duration>;
        using time_point = std::chrono::time_point<Clock, Duration>;

        time_point _timeout;

        timeout_awaiter(condition_variable* cv, time_point timeout)
            : awaiter(cv)
            , _timeout(timeout)
        {}
        void signal() noexcept override {
            this->cancel();
            awaiter::signal();
        }
        void set_exception(std::exception_ptr ep) noexcept override {
            this->cancel();
            awaiter::set_exception(std::move(ep));
        }
        auto operator co_await() {
            if (_cv->check_and_consume_signal()) {
                return ::seastar::internal::awaiter<false, void>(make_ready_future<>());
            }
            this->set_callback(std::bind(&waiter::timeout, this));
            this->arm(_timeout);
            return awaiter::operator co_await();
        }
    };

    template<typename Func, typename Base>
    struct [[nodiscard("must co_await a when() call")]] predicate_awaiter : public Base {
        Func _func;
        template<typename... Args>
        predicate_awaiter(Func func, Args&& ...args)
            : Base(std::forward<Args>(args)...)
            , _func(std::move(func))
        {}
        void signal() noexcept override {
            if (_func()) {
                Base::signal();
            } else {




                Base::_cv->add_waiter(*this);
            }
        }
        auto operator co_await() {
            if (_func()) {
                return ::seastar::internal::awaiter<false, void>(make_ready_future<>());
            } else {
                Base::_cv->check_and_consume_signal();
                return Base::operator co_await();
            }
        }
    };

    boost::intrusive::list<waiter, boost::intrusive::constant_time_size<false>> _waiters;
    std::exception_ptr _ex;
    bool _signalled = false;

    void add_waiter(waiter&) noexcept;
    void timeout(waiter&) noexcept;
    bool wakeup_first() noexcept;
    bool check_and_consume_signal() noexcept;
public:



    condition_variable() noexcept = default;
    condition_variable(condition_variable&& rhs) noexcept = default;
    ~condition_variable();






    future<> wait() noexcept {
        if (check_and_consume_signal()) {
            return make_ready_future();
        }
        auto* w = new promise_waiter;
        auto f = w->get_future();
        add_waiter(*w);
        return f;
    }
# 222 "/home/avi/scylla-maint/seastar/include/seastar/core/condition-variable.hh"
    template<typename Clock = typename timer<>::clock, typename Duration = typename Clock::duration>
    future<> wait(std::chrono::time_point<Clock, Duration> timeout) noexcept {
        if (check_and_consume_signal()) {
            return make_ready_future();
        }
        struct timeout_waiter : public promise_waiter, public timer<Clock> {};

        auto w = std::make_unique<timeout_waiter>();
        auto f = w->get_future();

        w->set_callback(std::bind(&waiter::timeout, w.get()));
        w->arm(timeout);
        add_waiter(*w.release());
        return f;
    }
# 245 "/home/avi/scylla-maint/seastar/include/seastar/core/condition-variable.hh"
    template<typename Rep, typename Period>
    future<> wait(std::chrono::duration<Rep, Period> timeout) noexcept {
        return wait(timer<>::clock::now() + timeout);
    }
# 257 "/home/avi/scylla-maint/seastar/include/seastar/core/condition-variable.hh"
    template<typename Pred>
    requires std::is_invocable_r_v<bool, Pred>
    future<> wait(Pred&& pred) noexcept {
        return do_until(std::forward<Pred>(pred), [this] {
            return wait();
        });
    }
# 274 "/home/avi/scylla-maint/seastar/include/seastar/core/condition-variable.hh"
    template<typename Clock = typename timer<>::clock, typename Duration = typename Clock::duration, typename Pred>
    requires std::is_invocable_r_v<bool, Pred>
    future<> wait(std::chrono::time_point<Clock, Duration> timeout, Pred&& pred) noexcept {
        return do_until(std::forward<Pred>(pred), [this, timeout] {
            return wait(timeout);
        });
    }
# 291 "/home/avi/scylla-maint/seastar/include/seastar/core/condition-variable.hh"
    template<typename Rep, typename Period, typename Pred>
    requires std::is_invocable_r_v<bool, Pred>
    future<> wait(std::chrono::duration<Rep, Period> timeout, Pred&& pred) noexcept {
        return wait(timer<>::clock::now() + timeout, std::forward<Pred>(pred));
    }







    awaiter when() noexcept {
        return awaiter{this};
    }
# 315 "/home/avi/scylla-maint/seastar/include/seastar/core/condition-variable.hh"
    template<typename Clock = typename timer<>::clock, typename Duration = typename Clock::duration>
    timeout_awaiter<Clock, Duration> when(std::chrono::time_point<Clock, Duration> timeout) noexcept {
        return timeout_awaiter<Clock, Duration>{this, timeout};
    }
# 328 "/home/avi/scylla-maint/seastar/include/seastar/core/condition-variable.hh"
    template<typename Rep, typename Period>
    auto when(std::chrono::duration<Rep, Period> timeout) noexcept {
        return when(timer<>::clock::now() + timeout);
    }
# 341 "/home/avi/scylla-maint/seastar/include/seastar/core/condition-variable.hh"
    template<typename Pred>
    requires std::is_invocable_r_v<bool, Pred>
    auto when(Pred&& pred) noexcept {
        return predicate_awaiter<Pred, awaiter>{std::forward<Pred>(pred), when()};
    }
# 357 "/home/avi/scylla-maint/seastar/include/seastar/core/condition-variable.hh"
    template<typename Clock = typename timer<>::clock, typename Duration = typename Clock::duration, typename Pred>
    requires std::is_invocable_r_v<bool, Pred>
    auto when(std::chrono::time_point<Clock, Duration> timeout, Pred&& pred) noexcept {
        return predicate_awaiter<Pred, timeout_awaiter<Clock, Duration>>{std::forward<Pred>(pred), when(timeout)};
    }
# 373 "/home/avi/scylla-maint/seastar/include/seastar/core/condition-variable.hh"
    template<typename Rep, typename Period, typename Pred>
    requires std::is_invocable_r_v<bool, Pred>
    auto when(std::chrono::duration<Rep, Period> timeout, Pred&& pred) noexcept {
        return when(timer<>::clock::now() + timeout, std::forward<Pred>(pred));
    }



    bool has_waiters() const noexcept {
        return !_waiters.empty();
    }


    void signal() noexcept;


    void broadcast() noexcept;




    void broken() noexcept;

    void broken(std::exception_ptr) noexcept;
};





}
# 35 "/home/avi/scylla-maint/seastar/include/seastar/rpc/rpc.hh" 2
# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/gate.hh" 1
# 30 "/home/avi/scylla-maint/seastar/include/seastar/core/gate.hh"
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 1 3
# 42 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 3


# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 45 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 2 3
# 31 "/home/avi/scylla-maint/seastar/include/seastar/core/gate.hh" 2
# 40 "/home/avi/scylla-maint/seastar/include/seastar/core/gate.hh"
namespace seastar {







class gate_closed_exception : public std::exception {
public:
    virtual const char* what() const noexcept override {
        return "gate closed";
    }
};







class gate {
    size_t _count = 0;
    std::optional<promise<>> _stopped;





    void assert_not_held_when_moved() const noexcept {}
    void assert_not_held_when_destroyed() const noexcept {}


public:

    gate() noexcept {};
    gate(const gate&) = delete;
    gate(gate&& x) noexcept
        : _count(std::exchange(x._count, 0)), _stopped(std::exchange(x._stopped, std::nullopt)) {
        x.assert_not_held_when_moved();
    }
    gate& operator=(gate&& x) noexcept {
        if (this != &x) {
            (static_cast <bool> (!_count && "gate reassigned with outstanding requests") ? void (0) : __assert_fail ("!_count && \"gate reassigned with outstanding requests\"", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
            x.assert_not_held_when_moved();
            _count = std::exchange(x._count, 0);
            _stopped = std::exchange(x._stopped, std::nullopt);
        }
        return *this;
    }
    ~gate() {
        (static_cast <bool> (!_count && "gate destroyed with outstanding requests") ? void (0) : __assert_fail ("!_count && \"gate destroyed with outstanding requests\"", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        assert_not_held_when_destroyed();
    }




    bool try_enter() noexcept {
        bool opened = !_stopped;
        if (opened) {
            ++_count;
        }
        return opened;
    }




    void enter() {
        if (!try_enter()) {
            throw gate_closed_exception();
        }
    }




    void leave() noexcept {
        --_count;
        if (!_count && _stopped) {
            _stopped->set_value();
        }
    }
# 133 "/home/avi/scylla-maint/seastar/include/seastar/core/gate.hh"
    void check() {
        if (_stopped) {
            throw gate_closed_exception();
        }
    }





    future<> close() noexcept {
        (static_cast <bool> (!_stopped && "seastar::gate::close() cannot be called more than once") ? void (0) : __assert_fail ("!_stopped && \"seastar::gate::close() cannot be called more than once\"", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        _stopped = std::make_optional(promise<>());
        if (!_count) {
            _stopped->set_value();
        }
        return _stopped->get_future();
    }


    size_t get_count() const noexcept {
        return _count;
    }


    bool is_closed() const noexcept {
        return bool(_stopped);
    }
# 171 "/home/avi/scylla-maint/seastar/include/seastar/core/gate.hh"
    class holder {
        gate* _g;
# 187 "/home/avi/scylla-maint/seastar/include/seastar/core/gate.hh"
        void debug_hold_gate() noexcept {}
        void debug_release_gate() noexcept {}




        gate* release_gate() noexcept {
            auto* g = std::exchange(_g, nullptr);
            if (g) {
                debug_release_gate();
            }
            return g;
        }

        friend class gate;
    public:


        holder() noexcept : _g(nullptr) { }



        explicit holder(gate& g) : _g(&g) {
            _g->enter();
            debug_hold_gate();
        }






        holder(const holder& x) noexcept : _g(x._g) {
            if (_g) {
                _g->_count++;
                debug_hold_gate();
            }
        }




        holder(holder&& x) noexcept : _g(std::move(x).release_gate()) {
            debug_hold_gate();
        }


        ~holder() {
            release();
        }







        holder& operator=(const holder& x) noexcept {
            if (x._g != _g) {
                release();
                _g = x._g;
                if (_g) {
                    _g->_count++;
                    debug_hold_gate();
                }
            }
            return *this;
        }





        holder& operator=(holder&& x) noexcept {
            if (&x != this) {
                release();
                _g = std::move(x).release_gate();
                debug_hold_gate();
            }
            return *this;
        }


        void release() noexcept {
            if (auto g = release_gate()) {
                g->leave();
            }
        }
    };



    holder hold() {
        return holder(*this);
    }

private:







};
# 303 "/home/avi/scylla-maint/seastar/include/seastar/core/gate.hh"
namespace internal {

template <typename Func>
inline
auto
invoke_func_with_gate(gate::holder&& gh, Func&& func) noexcept {
    return futurize_invoke(std::forward<Func>(func)).finally([gh = std::forward<gate::holder>(gh)] {});
}

}
# 323 "/home/avi/scylla-maint/seastar/include/seastar/core/gate.hh"
template <typename Func>
inline
auto
with_gate(gate& g, Func&& func) {
    return internal::invoke_func_with_gate(g.hold(), std::forward<Func>(func));
}
# 342 "/home/avi/scylla-maint/seastar/include/seastar/core/gate.hh"
template <typename Func>
inline
auto
try_with_gate(gate& g, Func&& func) noexcept {
    if (g.is_closed()) {
        using futurator = futurize<std::invoke_result_t<Func>>;
        return futurator::make_exception_future(gate_closed_exception());
    }
    return internal::invoke_func_with_gate(g.hold(), std::forward<Func>(func));
}



}
# 36 "/home/avi/scylla-maint/seastar/include/seastar/rpc/rpc.hh" 2
# 1 "/home/avi/scylla-maint/seastar/include/seastar/rpc/rpc_types.hh" 1
# 28 "/home/avi/scylla-maint/seastar/include/seastar/rpc/rpc_types.hh"
# 1 "/usr/include/fmt/std.h" 1 3 4
# 13 "/usr/include/fmt/std.h" 3 4
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdlib" 1 3 4
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdlib" 3
# 14 "/usr/include/fmt/std.h" 2 3 4


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/thread" 1 3 4
# 33 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/thread" 3
# 42 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/thread" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/stop_token" 1 3
# 35 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/stop_token" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 36 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/stop_token" 2 3




# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/std_thread.h" 1 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/std_thread.h" 3
# 52 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/std_thread.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{



  template<typename, typename> class formatter;
# 82 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/std_thread.h" 3
  class thread
  {
  public:

    using native_handle_type = __gthread_t;
# 96 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/std_thread.h" 3
    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 struct hash<id>;

      friend bool
      operator==(id __x, id __y) noexcept;


      friend strong_ordering
      operator<=>(id __x, id __y) noexcept;





      template<class _CharT, class _Traits>
 friend basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __out, id __id);


      friend formatter<id, char>;
      friend formatter<id, wchar_t>;

    };

  private:
    id _M_id;




    template<typename _Tp>
      using __not_same = __not_<is_same<__remove_cvref_t<_Tp>, thread>>;

  public:
    thread() noexcept = default;


  private:






    static void
    _M_thread_deps_never_run() {




    }

  public:
    template<typename _Callable, typename... _Args,
      typename = _Require<__not_same<_Callable>>>
      explicit
      thread(_Callable&& __f, _Args&&... __args)
      {
 static_assert( __is_invocable<typename decay<_Callable>::type,
          typename decay<_Args>::type...>::value,
   "std::thread arguments must be invocable after conversion to rvalues"
   );

 using _Wrapper = _Call_wrapper<_Callable, _Args...>;


 _M_start_thread(_State_ptr(new _State_impl<_Wrapper>(
       std::forward<_Callable>(__f), std::forward<_Args>(__args)...)),
     _M_thread_deps_never_run);
      }


    ~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:



    struct _State
    {
      virtual ~_State();
      virtual void _M_run() = 0;
    };
    using _State_ptr = unique_ptr<_State>;

  private:
    template<typename _Callable>
      struct _State_impl : public _State
      {
 _Callable _M_func;

 template<typename... _Args>
   _State_impl(_Args&&... __args)
   : _M_func(std::forward<_Args>(__args)...)
   { }

 void
 _M_run() { _M_func(); }
      };

    void
    _M_start_thread(_State_ptr, void (*)());
# 278 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/std_thread.h" 3
  private:

    template<typename _Tuple>
      struct _Invoker
      {
 template<typename... _Args>
   explicit
   _Invoker(_Args&&... __args)
   : _M_t(std::forward<_Args>(__args)...)
   { }

 _Tuple _M_t;

 template<typename>
   struct __result;
 template<typename _Fn, typename... _Args>
   struct __result<tuple<_Fn, _Args...>>
   : __invoke_result<_Fn, _Args...>
   { };

 template<size_t... _Ind>
   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<tuple_size<_Tuple>::value>::__type;
   return _M_invoke(_Indices());
 }
      };

  public:

    template<typename... _Tp>
      using _Call_wrapper = _Invoker<tuple<typename decay<_Tp>::type...>>;


  };
# 327 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/std_thread.h" 3
  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;
  }





  template<>
    struct hash<thread::id>
    : public __hash_base<size_t, thread::id>
    {
      size_t
      operator()(const thread::id& __id) const noexcept
      { return std::_Hash_impl::hash(__id._M_thread); }
    };

  namespace this_thread
  {

    inline thread::id
    get_id() noexcept
    {



      return thread::id(pthread_self());



    }


    inline void
    yield() noexcept
    {

      __gthread_yield();

    }

  }




}
# 41 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/stop_token" 2 3

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/semaphore" 1 3
# 33 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/semaphore" 3




# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/semaphore_base.h" 1 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/semaphore_base.h" 3




# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/atomic_timed_wait.h" 1 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/atomic_timed_wait.h" 3





# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/this_thread_sleep.h" 1 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/this_thread_sleep.h" 3





# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cerrno" 1 3
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cerrno" 3
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/this_thread_sleep.h" 2 3



namespace std __attribute__ ((__visibility__ ("default")))
{
# 56 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/this_thread_sleep.h" 3
  namespace this_thread
  {
# 66 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/this_thread_sleep.h" 3
    template<typename _Rep, typename _Period>
      inline void
      sleep_for(const chrono::duration<_Rep, _Period>& __rtime)
      {
 if (__rtime <= __rtime.zero())
   return;
 auto __s = chrono::duration_cast<chrono::seconds>(__rtime);
 auto __ns = chrono::duration_cast<chrono::nanoseconds>(__rtime - __s);

 struct ::timespec __ts =
   {
     static_cast<std::time_t>(__s.count()),
     static_cast<long>(__ns.count())
   };
 while (::nanosleep(&__ts, &__ts) == -1 && (*__errno_location ()) == 4)
   { }



      }


    template<typename _Clock, typename _Duration>
      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();
   }
      }

  }




}
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/atomic_timed_wait.h" 2 3



# 1 "/usr/include/sys/time.h" 1 3 4
# 34 "/usr/include/sys/time.h" 3 4
extern "C" {
# 52 "/usr/include/sys/time.h" 3 4
struct timezone
  {
    int tz_minuteswest;
    int tz_dsttime;
  };
# 67 "/usr/include/sys/time.h" 3 4
extern int gettimeofday (struct timeval *__restrict __tv,
    void *__restrict __tz) noexcept (true) __attribute__ ((__nonnull__ (1)));
# 86 "/usr/include/sys/time.h" 3 4
extern int settimeofday (const struct timeval *__tv,
    const struct timezone *__tz)
     noexcept (true);





extern int adjtime (const struct timeval *__delta,
      struct timeval *__olddelta) noexcept (true);
# 114 "/usr/include/sys/time.h" 3 4
enum __itimer_which
  {

    ITIMER_REAL = 0,


    ITIMER_VIRTUAL = 1,



    ITIMER_PROF = 2

  };



struct itimerval
  {

    struct timeval it_interval;

    struct timeval it_value;
  };






typedef int __itimer_which_t;





extern int getitimer (__itimer_which_t __which,
        struct itimerval *__value) noexcept (true);




extern int setitimer (__itimer_which_t __which,
        const struct itimerval *__restrict __new,
        struct itimerval *__restrict __old) noexcept (true);




extern int utimes (const char *__file, const struct timeval __tvp[2])
     noexcept (true) __attribute__ ((__nonnull__ (1)));
# 189 "/usr/include/sys/time.h" 3 4
extern int lutimes (const char *__file, const struct timeval __tvp[2])
     noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int futimes (int __fd, const struct timeval __tvp[2]) noexcept (true);
# 214 "/usr/include/sys/time.h" 3 4
extern int futimesat (int __fd, const char *__file,
        const struct timeval __tvp[2]) noexcept (true);
# 258 "/usr/include/sys/time.h" 3 4
}
# 44 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/atomic_timed_wait.h" 2 3


namespace std __attribute__ ((__visibility__ ("default")))
{


  namespace __detail
  {
    using __wait_clock_t = chrono::steady_clock;

    template<typename _Clock, typename _Dur>
      __wait_clock_t::time_point
      __to_wait_clock(const chrono::time_point<_Clock, _Dur>& __atime) noexcept
      {
 const typename _Clock::time_point __c_entry = _Clock::now();
 const __wait_clock_t::time_point __w_entry = __wait_clock_t::now();
 const auto __delta = __atime - __c_entry;
 using __w_dur = typename __wait_clock_t::duration;
 return __w_entry + chrono::ceil<__w_dur>(__delta);
      }

    template<typename _Dur>
      __wait_clock_t::time_point
      __to_wait_clock(const chrono::time_point<__wait_clock_t,
            _Dur>& __atime) noexcept
      {
 using __w_dur = typename __wait_clock_t::duration;
 return chrono::ceil<__w_dur>(__atime);
      }




    template<typename _Dur>
      bool
      __platform_wait_until_impl(const __platform_wait_t* __addr,
     __platform_wait_t __old,
     const chrono::time_point<__wait_clock_t, _Dur>&
          __atime) noexcept
      {
 auto __s = chrono::time_point_cast<chrono::seconds>(__atime);
 auto __ns = chrono::duration_cast<chrono::nanoseconds>(__atime - __s);

 struct timespec __rt =
 {
   static_cast<std::time_t>(__s.time_since_epoch().count()),
   static_cast<long>(__ns.count())
 };

 auto __e = syscall (202, __addr,
       static_cast<int>(__futex_wait_flags::
      __wait_bitset_private),
       __old, &__rt, nullptr,
       static_cast<int>(__futex_wait_flags::
      __bitset_match_any));

 if (__e)
   {
     if ((*__errno_location ()) == 110)
       return false;
     if ((*__errno_location ()) != 4 && (*__errno_location ()) != 11)
       __throw_system_error((*__errno_location ()));
   }
 return true;
      }


    template<typename _Clock, typename _Dur>
      bool
      __platform_wait_until(const __platform_wait_t* __addr, __platform_wait_t __old,
       const chrono::time_point<_Clock, _Dur>& __atime)
      {
 if constexpr (is_same_v<__wait_clock_t, _Clock>)
   {
     return __platform_wait_until_impl(__addr, __old, __atime);
   }
 else
   {
     if (!__platform_wait_until_impl(__addr, __old,
         __to_wait_clock(__atime)))
       {



  if (_Clock::now() < __atime)
    return true;
       }
     return false;
   }
      }
# 143 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/atomic_timed_wait.h" 3
    template<typename _Clock, typename _Dur>
      bool
      __cond_wait_until_impl(__condvar& __cv, mutex& __mx,
        const chrono::time_point<_Clock, _Dur>& __atime)
      {
 static_assert(std::__is_one_of<_Clock, chrono::steady_clock,
            chrono::system_clock>::value);

 auto __s = chrono::time_point_cast<chrono::seconds>(__atime);
 auto __ns = chrono::duration_cast<chrono::nanoseconds>(__atime - __s);

 __gthread_time_t __ts =
   {
     static_cast<std::time_t>(__s.time_since_epoch().count()),
     static_cast<long>(__ns.count())
   };


 if constexpr (is_same_v<chrono::steady_clock, _Clock>)
   __cv.wait_until(__mx, 1, __ts);
 else

   __cv.wait_until(__mx, __ts);
 return _Clock::now() < __atime;
      }


    template<typename _Clock, typename _Dur>
      bool
      __cond_wait_until(__condvar& __cv, mutex& __mx,
   const chrono::time_point<_Clock, _Dur>& __atime)
      {

 if constexpr (is_same_v<_Clock, chrono::steady_clock>)
   return __detail::__cond_wait_until_impl(__cv, __mx, __atime);
 else

 if constexpr (is_same_v<_Clock, chrono::system_clock>)
   return __detail::__cond_wait_until_impl(__cv, __mx, __atime);
 else
   {
     if (__cond_wait_until_impl(__cv, __mx,
           __to_wait_clock(__atime)))
       {



  if (_Clock::now() < __atime)
    return true;
       }
     return false;
   }
      }


    struct __timed_waiter_pool : __waiter_pool_base
    {

      template<typename _Clock, typename _Dur>
 bool
 _M_do_wait_until(__platform_wait_t* __addr, __platform_wait_t __old,
    const chrono::time_point<_Clock, _Dur>& __atime)
 {

   return __platform_wait_until(__addr, __old, __atime);
# 219 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/atomic_timed_wait.h" 3
 }
    };

    struct __timed_backoff_spin_policy
    {
      __wait_clock_t::time_point _M_deadline;
      __wait_clock_t::time_point _M_t0;

      template<typename _Clock, typename _Dur>
 __timed_backoff_spin_policy(chrono::time_point<_Clock, _Dur>
          __deadline = _Clock::time_point::max(),
        chrono::time_point<_Clock, _Dur>
          __t0 = _Clock::now()) noexcept
   : _M_deadline(__to_wait_clock(__deadline))
   , _M_t0(__to_wait_clock(__t0))
 { }

      bool
      operator()() const noexcept
      {
 using namespace literals::chrono_literals;
 auto __now = __wait_clock_t::now();
 if (_M_deadline <= __now)
   return false;



 auto __elapsed = __now - _M_t0;
 if (__elapsed > 128ms)
   {
     this_thread::sleep_for(64ms);
   }
 else if (__elapsed > 64us)
   {
     this_thread::sleep_for(__elapsed / 2);
   }
 else if (__elapsed > 4us)
   {
     __thread_yield();
   }
 else
   return false;
 return true;
      }
    };

    template<typename _EntersWait>
      struct __timed_waiter : __waiter_base<__timed_waiter_pool>
      {
 using __base_type = __waiter_base<__timed_waiter_pool>;

 template<typename _Tp>
   __timed_waiter(const _Tp* __addr) noexcept
   : __base_type(__addr)
 {
   if constexpr (_EntersWait::value)
     _M_w._M_enter_wait();
 }

 ~__timed_waiter()
 {
   if constexpr (_EntersWait::value)
     _M_w._M_leave_wait();
 }


 template<typename _Tp, typename _ValFn,
   typename _Clock, typename _Dur>
   bool
   _M_do_wait_until_v(_Tp __old, _ValFn __vfn,
        const chrono::time_point<_Clock, _Dur>&
        __atime) noexcept
   {
     __platform_wait_t __val;
     if (_M_do_spin(__old, std::move(__vfn), __val,
      __timed_backoff_spin_policy(__atime)))
       return true;
     return __base_type::_M_w._M_do_wait_until(__base_type::_M_addr, __val, __atime);
   }


 template<typename _Pred,
   typename _Clock, typename _Dur>
   bool
   _M_do_wait_until(_Pred __pred, __platform_wait_t __val,
     const chrono::time_point<_Clock, _Dur>&
             __atime) noexcept
   {
     for (auto __now = _Clock::now(); __now < __atime;
    __now = _Clock::now())
       {
  if (__base_type::_M_w._M_do_wait_until(
        __base_type::_M_addr, __val, __atime)
      && __pred())
    return true;

  if (__base_type::_M_do_spin(__pred, __val,
          __timed_backoff_spin_policy(__atime, __now)))
    return true;
       }
     return false;
   }


 template<typename _Pred,
   typename _Clock, typename _Dur>
   bool
   _M_do_wait_until(_Pred __pred,
      const chrono::time_point<_Clock, _Dur>&
        __atime) noexcept
   {
     __platform_wait_t __val;
     if (__base_type::_M_do_spin(__pred, __val,
     __timed_backoff_spin_policy(__atime)))
       return true;
     return _M_do_wait_until(__pred, __val, __atime);
   }

 template<typename _Tp, typename _ValFn,
   typename _Rep, typename _Period>
   bool
   _M_do_wait_for_v(_Tp __old, _ValFn __vfn,
      const chrono::duration<_Rep, _Period>&
        __rtime) noexcept
   {
     __platform_wait_t __val;
     if (_M_do_spin_v(__old, std::move(__vfn), __val))
       return true;

     if (!__rtime.count())
       return false;

     auto __reltime = chrono::ceil<__wait_clock_t::duration>(__rtime);

     return __base_type::_M_w._M_do_wait_until(
       __base_type::_M_addr,
       __val,
       chrono::steady_clock::now() + __reltime);
   }

 template<typename _Pred,
   typename _Rep, typename _Period>
   bool
   _M_do_wait_for(_Pred __pred,
    const chrono::duration<_Rep, _Period>& __rtime) noexcept
   {
     __platform_wait_t __val;
     if (__base_type::_M_do_spin(__pred, __val))
       return true;

     if (!__rtime.count())
       return false;

     auto __reltime = chrono::ceil<__wait_clock_t::duration>(__rtime);

     return _M_do_wait_until(__pred, __val,
        chrono::steady_clock::now() + __reltime);
   }
      };

    using __enters_timed_wait = __timed_waiter<std::true_type>;
    using __bare_timed_wait = __timed_waiter<std::false_type>;
  }


  template<typename _Tp, typename _ValFn,
    typename _Clock, typename _Dur>
    bool
    __atomic_wait_address_until_v(const _Tp* __addr, _Tp&& __old, _ValFn&& __vfn,
   const chrono::time_point<_Clock, _Dur>&
       __atime) noexcept
    {
      __detail::__enters_timed_wait __w{__addr};
      return __w._M_do_wait_until_v(__old, __vfn, __atime);
    }

  template<typename _Tp, typename _Pred,
    typename _Clock, typename _Dur>
    bool
    __atomic_wait_address_until(const _Tp* __addr, _Pred __pred,
    const chrono::time_point<_Clock, _Dur>&
             __atime) noexcept
    {
      __detail::__enters_timed_wait __w{__addr};
      return __w._M_do_wait_until(__pred, __atime);
    }

  template<typename _Pred,
    typename _Clock, typename _Dur>
    bool
    __atomic_wait_address_until_bare(const __detail::__platform_wait_t* __addr,
    _Pred __pred,
    const chrono::time_point<_Clock, _Dur>&
             __atime) noexcept
    {
      __detail::__bare_timed_wait __w{__addr};
      return __w._M_do_wait_until(__pred, __atime);
    }

  template<typename _Tp, typename _ValFn,
    typename _Rep, typename _Period>
    bool
    __atomic_wait_address_for_v(const _Tp* __addr, _Tp&& __old, _ValFn&& __vfn,
        const chrono::duration<_Rep, _Period>& __rtime) noexcept
    {
      __detail::__enters_timed_wait __w{__addr};
      return __w._M_do_wait_for_v(__old, __vfn, __rtime);
    }

  template<typename _Tp, typename _Pred,
    typename _Rep, typename _Period>
    bool
    __atomic_wait_address_for(const _Tp* __addr, _Pred __pred,
        const chrono::duration<_Rep, _Period>& __rtime) noexcept
    {

      __detail::__enters_timed_wait __w{__addr};
      return __w._M_do_wait_for(__pred, __rtime);
    }

  template<typename _Pred,
    typename _Rep, typename _Period>
    bool
    __atomic_wait_address_for_bare(const __detail::__platform_wait_t* __addr,
   _Pred __pred,
   const chrono::duration<_Rep, _Period>& __rtime) noexcept
    {
      __detail::__bare_timed_wait __w{__addr};
      return __w._M_do_wait_for(__pred, __rtime);
    }

}
# 39 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/semaphore_base.h" 2 3




# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cerrno" 1 3
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cerrno" 3
# 44 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/semaphore_base.h" 2 3

# 1 "/usr/include/semaphore.h" 1 3 4
# 28 "/usr/include/semaphore.h" 3 4
# 1 "/usr/include/bits/semaphore.h" 1 3 4
# 23 "/usr/include/bits/semaphore.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 24 "/usr/include/bits/semaphore.h" 2 3 4
# 35 "/usr/include/bits/semaphore.h" 3 4
typedef union
{
  char __size[32];
  long int __align;
} sem_t;
# 29 "/usr/include/semaphore.h" 2 3 4


extern "C" {



extern int sem_init (sem_t *__sem, int __pshared, unsigned int __value)
  noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int sem_destroy (sem_t *__sem) noexcept (true) __attribute__ ((__nonnull__ (1)));


extern sem_t *sem_open (const char *__name, int __oflag, ...)
  noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int sem_close (sem_t *__sem) noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int sem_unlink (const char *__name) noexcept (true) __attribute__ ((__nonnull__ (1)));





extern int sem_wait (sem_t *__sem) __attribute__ ((__nonnull__ (1)));







extern int sem_timedwait (sem_t *__restrict __sem,
     const struct timespec *__restrict __abstime)
  __attribute__ ((__nonnull__ (1, 2)));
# 81 "/usr/include/semaphore.h" 3 4
extern int sem_clockwait (sem_t *__restrict __sem,
     clockid_t clock,
     const struct timespec *__restrict __abstime)
  __attribute__ ((__nonnull__ (1, 3)));
# 100 "/usr/include/semaphore.h" 3 4
extern int sem_trywait (sem_t *__sem) noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int sem_post (sem_t *__sem) noexcept (true) __attribute__ ((__nonnull__ (1)));


extern int sem_getvalue (sem_t *__restrict __sem, int *__restrict __sval)
  noexcept (true) __attribute__ ((__nonnull__ (1, 2)));


}
# 46 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/semaphore_base.h" 2 3


namespace std __attribute__ ((__visibility__ ("default")))
{



  struct __platform_semaphore
  {
    using __clock_t = chrono::system_clock;

    static constexpr ptrdiff_t _S_max = (2147483647);




    explicit __platform_semaphore(ptrdiff_t __count) noexcept
    {
      sem_init(&_M_semaphore, 0, __count);
    }

    __platform_semaphore(const __platform_semaphore&) = delete;
    __platform_semaphore& operator=(const __platform_semaphore&) = delete;

    ~__platform_semaphore()
    { sem_destroy(&_M_semaphore); }

    inline __attribute__((__always_inline__)) void
    _M_acquire() noexcept
    {
      for (;;)
 {
   auto __err = sem_wait(&_M_semaphore);
   if (__err && ((*__errno_location ()) == 4))
     continue;
   else if (__err)
     std::__terminate();
   else
     break;
 }
    }

    inline __attribute__((__always_inline__)) bool
    _M_try_acquire() noexcept
    {
      for (;;)
 {
   auto __err = sem_trywait(&_M_semaphore);
   if (__err && ((*__errno_location ()) == 4))
     continue;
   else if (__err && ((*__errno_location ()) == 11))
     return false;
   else if (__err)
     std::__terminate();
   else
     break;
 }
      return true;
    }

    inline __attribute__((__always_inline__)) void
    _M_release(std::ptrdiff_t __update) noexcept
    {
      for(; __update != 0; --__update)
 {
    auto __err = sem_post(&_M_semaphore);
    if (__err)
      std::__terminate();
 }
    }

    bool
    _M_try_acquire_until_impl(const chrono::time_point<__clock_t>& __atime)
      noexcept
    {

      auto __s = chrono::time_point_cast<chrono::seconds>(__atime);
      auto __ns = chrono::duration_cast<chrono::nanoseconds>(__atime - __s);

      struct timespec __ts =
      {
 static_cast<std::time_t>(__s.time_since_epoch().count()),
 static_cast<long>(__ns.count())
      };

      for (;;)
 {
   if (auto __err = sem_timedwait(&_M_semaphore, &__ts))
     {
       if ((*__errno_location ()) == 4)
  continue;
       else if ((*__errno_location ()) == 110 || (*__errno_location ()) == 22)
  return false;
       else
  std::__terminate();
     }
   else
     break;
 }
      return true;
    }

    template<typename _Clock, typename _Duration>
      bool
      _M_try_acquire_until(const chrono::time_point<_Clock,
      _Duration>& __atime) noexcept
      {
 if constexpr (std::is_same_v<__clock_t, _Clock>)
   {
     return _M_try_acquire_until_impl(__atime);
   }
 else
   {
     const typename _Clock::time_point __c_entry = _Clock::now();
     const auto __s_entry = __clock_t::now();
     const auto __delta = __atime - __c_entry;
     const auto __s_atime = __s_entry + __delta;
     if (_M_try_acquire_until_impl(__s_atime))
       return true;




     return (_Clock::now() < __atime);
   }
      }

    template<typename _Rep, typename _Period>
      inline __attribute__((__always_inline__)) bool
      _M_try_acquire_for(const chrono::duration<_Rep, _Period>& __rtime)
 noexcept
      { return _M_try_acquire_until(__clock_t::now() + __rtime); }

  private:
    sem_t _M_semaphore;
  };



  struct __atomic_semaphore
  {
    static constexpr ptrdiff_t _S_max = __gnu_cxx::__int_traits<int>::__max;
    explicit __atomic_semaphore(__detail::__platform_wait_t __count) noexcept
      : _M_counter(__count)
    {
      do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__count >= 0 && __count <= _S_max), false)) std::__glibcxx_assert_fail(); } while (false);
    }

    __atomic_semaphore(const __atomic_semaphore&) = delete;
    __atomic_semaphore& operator=(const __atomic_semaphore&) = delete;

    static inline __attribute__((__always_inline__)) bool
    _S_do_try_acquire(__detail::__platform_wait_t* __counter) noexcept
    {
      auto __old = __atomic_impl::load(__counter, memory_order::acquire);
      if (__old == 0)
 return false;

      return __atomic_impl::compare_exchange_strong(__counter,
          __old, __old - 1,
          memory_order::acquire,
          memory_order::relaxed);
    }

    inline __attribute__((__always_inline__)) void
    _M_acquire() noexcept
    {
      auto const __pred =
 [this] { return _S_do_try_acquire(&this->_M_counter); };
      std::__atomic_wait_address_bare(&_M_counter, __pred);
    }

    bool
    _M_try_acquire() noexcept
    {
      auto const __pred =
 [this] { return _S_do_try_acquire(&this->_M_counter); };
      return std::__detail::__atomic_spin(__pred);
    }

    template<typename _Clock, typename _Duration>
      inline __attribute__((__always_inline__)) bool
      _M_try_acquire_until(const chrono::time_point<_Clock,
      _Duration>& __atime) noexcept
      {
 auto const __pred =
   [this] { return _S_do_try_acquire(&this->_M_counter); };

 return __atomic_wait_address_until_bare(&_M_counter, __pred, __atime);
      }

    template<typename _Rep, typename _Period>
      inline __attribute__((__always_inline__)) bool
      _M_try_acquire_for(const chrono::duration<_Rep, _Period>& __rtime)
 noexcept
      {
 auto const __pred =
   [this] { return _S_do_try_acquire(&this->_M_counter); };

 return __atomic_wait_address_for_bare(&_M_counter, __pred, __rtime);
      }

    inline __attribute__((__always_inline__)) void
    _M_release(ptrdiff_t __update) noexcept
    {
      if (0 < __atomic_impl::fetch_add(&_M_counter, __update, memory_order_release))
 return;
      if (__update > 1)
 __atomic_notify_address_bare(&_M_counter, true);
      else
 __atomic_notify_address_bare(&_M_counter, true);


    }

  private:
    alignas(__detail::__platform_wait_alignment)
    __detail::__platform_wait_t _M_counter;
  };





  using __semaphore_impl = __atomic_semaphore;





}
# 38 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/semaphore" 2 3


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 41 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/semaphore" 2 3


namespace std __attribute__ ((__visibility__ ("default")))
{


  template<ptrdiff_t __least_max_value = __semaphore_impl::_S_max>
    class counting_semaphore
    {
      static_assert(__least_max_value >= 0);
      static_assert(__least_max_value <= __semaphore_impl::_S_max);

      __semaphore_impl _M_sem;

    public:
      explicit counting_semaphore(ptrdiff_t __desired) noexcept
 : _M_sem(__desired)
      { }

      ~counting_semaphore() = default;

      counting_semaphore(const counting_semaphore&) = delete;
      counting_semaphore& operator=(const counting_semaphore&) = delete;

      static constexpr ptrdiff_t
      max() noexcept
      { return __least_max_value; }

      void
      release(ptrdiff_t __update = 1) noexcept(noexcept(_M_sem._M_release(1)))
      { _M_sem._M_release(__update); }

      void
      acquire() noexcept(noexcept(_M_sem._M_acquire()))
      { _M_sem._M_acquire(); }

      bool
      try_acquire() noexcept(noexcept(_M_sem._M_try_acquire()))
      { return _M_sem._M_try_acquire(); }

      template<typename _Rep, typename _Period>
 bool
 try_acquire_for(const std::chrono::duration<_Rep, _Period>& __rtime)
 { return _M_sem._M_try_acquire_for(__rtime); }

      template<typename _Clock, typename _Dur>
 bool
 try_acquire_until(const std::chrono::time_point<_Clock, _Dur>& __atime)
 { return _M_sem._M_try_acquire_until(__atime); }
    };

  using binary_semaphore = std::counting_semaphore<1>;


}
# 43 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/stop_token" 2 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<bool>(_M_state) && _M_state->_M_stop_possible();
    }

    [[nodiscard]]
    bool
    stop_requested() const noexcept
    {
      return static_cast<bool>(_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<typename _Callback>
      friend class stop_callback;

    static void
    _S_yield() noexcept
    {

      __builtin_ia32_pause();

      this_thread::yield();
    }
# 135 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/stop_token" 3
    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<value_type> _M_owners{1};
      std::atomic<value_type> _M_value{_S_ssrc_counter_inc};
      _Stop_cb* _M_head = nullptr;
      std::thread::id _M_requester;

      _Stop_state_t() = default;

      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 = this_thread::get_id();

 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;


  if (!__gnu_cxx::__is_single_threaded())
    __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();







 if (!(_M_requester == this_thread::get_id()))
   {

     __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;

      [[__gnu__::__access__(__none__, 2)]]
      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;
# 468 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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<bool>(_M_state);
    }

    [[nodiscard]]
    bool
    stop_requested() const noexcept
    {
      return static_cast<bool>(_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<typename _Callback>
    class [[nodiscard]] stop_callback
    {
      static_assert(is_nothrow_destructible_v<_Callback>);
      static_assert(is_invocable_v<_Callback>);

    public:
      using callback_type = _Callback;

      template<typename _Cb,
               enable_if_t<is_constructible_v<_Callback, _Cb>, 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<typename _Cb,
               enable_if_t<is_constructible_v<_Callback, _Cb>, 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<typename _Cb>
   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<typename _Callback>
    stop_callback(stop_token, _Callback) -> stop_callback<_Callback>;


}
# 43 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/thread" 2 3







# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 51 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/thread" 2 3





namespace std __attribute__ ((__visibility__ ("default")))
{
# 74 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/thread" 3
  inline strong_ordering
  operator<=>(thread::id __x, thread::id __y) noexcept
  { return __x._M_thread <=> __y._M_thread; }
# 103 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/thread" 3
  template<class _CharT, class _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __out, thread::id __id)
    {

      using __output_type
 = __conditional_t<is_pointer<thread::native_handle_type>::value,
     const void*,
     thread::native_handle_type>;

      if (__id == thread::id())
 return __out << "thread::id of a non-executing thread";
      else
 return __out << static_cast<__output_type>(__id._M_thread);
    }






    template<typename _Callable, typename... _Args>
      constexpr bool __pmf_expects_stop_token = false;

    template<typename _Callable, typename _Obj, typename... _Args>
      constexpr bool __pmf_expects_stop_token<_Callable, _Obj, _Args...>
 = __and_<is_member_function_pointer<remove_reference_t<_Callable>>,
   is_invocable<_Callable, _Obj, stop_token, _Args...>>::value;
# 148 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/thread" 3
  class jthread
  {
  public:
    using id = thread::id;
    using native_handle_type = thread::native_handle_type;

    jthread() noexcept
    : _M_stop_source{nostopstate}
    { }

    template<typename _Callable, typename... _Args,
      typename = enable_if_t<!is_same_v<remove_cvref_t<_Callable>,
            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<typename _Callable, typename... _Args>
      static thread
      _S_create(stop_source& __ssrc, _Callable&& __f, _Args&&... __args)
      {

 if constexpr (__pmf_expects_stop_token<_Callable, _Args...>)
   return _S_create_pmf(__ssrc, __f, std::forward<_Args>(__args)...);
 else

 if constexpr(is_invocable_v<decay_t<_Callable>, 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<_Callable>,
      decay_t<_Args>...>,
     "std::jthread arguments must be invocable after"
     " conversion to rvalues");
     return thread{std::forward<_Callable>(__f),
     std::forward<_Args>(__args)...};
   }
      }


    template<typename _Callable, typename _Obj, typename... _Args>
      static thread
      _S_create_pmf(stop_source& __ssrc, _Callable __f, _Obj&& __obj,
      _Args&&... __args)
      {
 return thread{__f, std::forward<_Obj>(__obj), __ssrc.get_token(),
        std::forward<_Args>(__args)...};
      }


    stop_source _M_stop_source;
    thread _M_thread;
  };



  template<typename _CharT>
    requires is_pointer_v<thread::native_handle_type>
      || is_integral_v<thread::native_handle_type>
    class formatter<thread::id, _CharT>
    {
    public:
      constexpr typename basic_format_parse_context<_CharT>::iterator
      parse(basic_format_parse_context<_CharT>& __pc)
      {
 __format::_Spec<_CharT> __spec{};
 const auto __last = __pc.end();
 auto __first = __pc.begin();

 auto __finalize = [this, &__spec] {
   _M_spec = __spec;
 };

 auto __finished = [&] {
   if (__first == __last || *__first == '}')
     {
       __finalize();
       return true;
     }
   return false;
 };

 if (__finished())
   return __first;

 __first = __spec._M_parse_fill_and_align(__first, __last);
 if (__finished())
   return __first;

 __first = __spec._M_parse_width(__first, __last, __pc);
 if (__finished())
   return __first;

 __throw_format_error("format error: invalid format-spec for "
        "std::thread::id");
      }

      template<typename _Out>
 typename basic_format_context<_Out, _CharT>::iterator
 format(thread::id __id, basic_format_context<_Out, _CharT>& __fc) const
 {
   basic_string_view<_CharT> __sv;
   if constexpr (is_same_v<_CharT, char>)
     __sv = "{}thread::id of a non-executing thread";
   else
     __sv = L"{}thread::id of a non-executing thread";
   basic_string<_CharT> __str;
   if (__id == thread::id())
     __sv.remove_prefix(2);
   else
     {
       using _FmtStr = __format::_Runtime_format_string<_CharT>;

       using __output_type
  = __conditional_t<is_pointer_v<thread::native_handle_type>,
      const void*,
      thread::native_handle_type>;
       auto __o = static_cast<__output_type>(__id._M_thread);
       __sv = __str = std::format(_FmtStr(__sv.substr(0, 2)), __o);
     }
   return __format::__write_padded_as_spec(__sv, __sv.size(),
        __fc, _M_spec,
        __format::_Align_right);
 }

    private:
      __format::_Spec<_CharT> _M_spec;
    };





}
# 17 "/usr/include/fmt/std.h" 2 3 4
# 84 "/usr/include/fmt/std.h" 3 4
namespace fmt { inline namespace v10 {

namespace detail {

template <typename Char, typename PathChar>
auto get_path_string(const std::filesystem::path& p,
                     const std::basic_string<PathChar>& native) {
  if constexpr (std::is_same_v<Char, char> && std::is_same_v<PathChar, wchar_t>)
    return to_utf8<wchar_t>(native, to_utf8_error_policy::replace);
  else
    return p.string<Char>();
}

template <typename Char, typename PathChar>
void write_escaped_path(basic_memory_buffer<Char>& quoted,
                        const std::filesystem::path& p,
                        const std::basic_string<PathChar>& native) {
  if constexpr (std::is_same_v<Char, char> &&
                std::is_same_v<PathChar, wchar_t>) {
    auto buf = basic_memory_buffer<wchar_t>();
    write_escaped_string<wchar_t>(std::back_inserter(buf), native);
    bool valid = to_utf8<wchar_t>::convert(quoted, {buf.data(), buf.size()});
    ((valid) ? (void)0 : fmt::detail::assert_fail("/usr/include/fmt/std.h", 106, ("invalid utf16")));
  } else if constexpr (std::is_same_v<Char, PathChar>) {
    write_escaped_string<std::filesystem::path::value_type>(
        std::back_inserter(quoted), native);
  } else {
    write_escaped_string<Char>(std::back_inserter(quoted), p.string<Char>());
  }
}

}


template <typename Char> struct formatter<std::filesystem::path, Char> {
 private:
  format_specs<Char> specs_;
  detail::arg_ref<Char> width_ref_;
  bool debug_ = false;
  char path_type_ = 0;

 public:
  constexpr void set_debug_format(bool set = true) { debug_ = set; }

  template <typename ParseContext> constexpr auto parse(ParseContext& ctx) {
    auto it = ctx.begin(), end = ctx.end();
    if (it == end) return it;

    it = detail::parse_align(it, end, specs_);
    if (it == end) return it;

    it = detail::parse_dynamic_spec(it, end, specs_.width, width_ref_, ctx);
    if (it != end && *it == '?') {
      debug_ = true;
      ++it;
    }
    if (it != end && (*it == 'g')) path_type_ = *it++;
    return it;
  }

  template <typename FormatContext>
  auto format(const std::filesystem::path& p, FormatContext& ctx) const {
    auto specs = specs_;



    auto path_string = !path_type_ ? p.native() : p.generic_string();


    detail::handle_dynamic_spec<detail::width_checker>(specs.width, width_ref_,
                                                       ctx);
    if (!debug_) {
      auto s = detail::get_path_string<Char>(p, path_string);
      return detail::write(ctx.out(), basic_string_view<Char>(s), specs);
    }
    auto quoted = basic_memory_buffer<Char>();
    detail::write_escaped_path(quoted, p, path_string);
    return detail::write(ctx.out(),
                         basic_string_view<Char>(quoted.data(), quoted.size()),
                         specs);
  }
};
} }


namespace fmt { inline namespace v10 {

template <std::size_t N, typename Char>
struct formatter<std::bitset<N>, Char> : nested_formatter<string_view> {
 private:

  struct writer {
    const std::bitset<N>& bs;

    template <typename OutputIt>
    constexpr auto operator()(OutputIt out) -> OutputIt {
      for (auto pos = N; pos > 0; --pos) {
        out = detail::write<Char>(out, bs[pos - 1] ? Char('1') : Char('0'));
      }

      return out;
    }
  };

 public:
  template <typename FormatContext>
  auto format(const std::bitset<N>& bs, FormatContext& ctx) const
      -> decltype(ctx.out()) {
    return write_padded(ctx, writer{bs});
  }
};


template <typename Char>
struct formatter<std::thread::id, Char> : basic_ostream_formatter<Char> {};
} }


namespace fmt { inline namespace v10 {

template <typename T, typename Char>
struct formatter<std::optional<T>, Char,
                 std::enable_if_t<is_formattable<T, Char>::value>> {
 private:
  formatter<T, Char> underlying_;
  static constexpr basic_string_view<Char> optional =
      detail::string_literal<Char, 'o', 'p', 't', 'i', 'o', 'n', 'a', 'l',
                             '('>{};
  static constexpr basic_string_view<Char> none =
      detail::string_literal<Char, 'n', 'o', 'n', 'e'>{};

  template <class U>
  constexpr static auto maybe_set_debug_format(U& u, bool set)
      -> decltype(u.set_debug_format(set)) {
    u.set_debug_format(set);
  }

  template <class U>
  constexpr static void maybe_set_debug_format(U&, ...) {}

 public:
  template <typename ParseContext> constexpr auto parse(ParseContext& ctx) {
    maybe_set_debug_format(underlying_, true);
    return underlying_.parse(ctx);
  }

  template <typename FormatContext>
  auto format(const std::optional<T>& opt, FormatContext& ctx) const
      -> decltype(ctx.out()) {
    if (!opt) return detail::write<Char>(ctx.out(), none);

    auto out = ctx.out();
    out = detail::write<Char>(out, optional);
    ctx.advance_to(out);
    out = underlying_.format(*opt, ctx);
    return detail::write(out, ')');
  }
};
} }



namespace fmt { inline namespace v10 {

template <> struct formatter<std::source_location> {
  template <typename ParseContext> constexpr auto parse(ParseContext& ctx) {
    return ctx.begin();
  }

  template <typename FormatContext>
  auto format(const std::source_location& loc, FormatContext& ctx) const
      -> decltype(ctx.out()) {
    auto out = ctx.out();
    out = detail::write(out, loc.file_name());
    out = detail::write(out, ':');
    out = detail::write<char>(out, loc.line());
    out = detail::write(out, ':');
    out = detail::write<char>(out, loc.column());
    out = detail::write(out, ": ");
    out = detail::write(out, loc.function_name());
    return out;
  }
};
} }



namespace fmt { inline namespace v10 {
namespace detail {

template <typename T>
using variant_index_sequence =
    std::make_index_sequence<std::variant_size<T>::value>;

template <typename> struct is_variant_like_ : std::false_type {};
template <typename... Types>
struct is_variant_like_<std::variant<Types...>> : std::true_type {};


template <typename T, typename C> class is_variant_formattable_ {
  template <std::size_t... Is>
  static std::conjunction<
      is_formattable<std::variant_alternative_t<Is, T>, C>...>
      check(std::index_sequence<Is...>);

 public:
  static constexpr const bool value =
      decltype(check(variant_index_sequence<T>{}))::value;
};

template <typename Char, typename OutputIt, typename T>
auto write_variant_alternative(OutputIt out, const T& v) -> OutputIt {
  if constexpr (is_string<T>::value)
    return write_escaped_string<Char>(out, detail::to_string_view(v));
  else if constexpr (std::is_same_v<T, Char>)
    return write_escaped_char(out, v);
  else
    return write<Char>(out, v);
}

}

template <typename T> struct is_variant_like {
  static constexpr const bool value = detail::is_variant_like_<T>::value;
};

template <typename T, typename C> struct is_variant_formattable {
  static constexpr const bool value =
      detail::is_variant_formattable_<T, C>::value;
};


template <typename Char> struct formatter<std::monostate, Char> {
  template <typename ParseContext>
  constexpr auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
    return ctx.begin();
  }

  template <typename FormatContext>
  auto format(const std::monostate&, FormatContext& ctx) const
      -> decltype(ctx.out()) {
    return detail::write<Char>(ctx.out(), "monostate");
  }
};


template <typename Variant, typename Char>
struct formatter<
    Variant, Char,
    std::enable_if_t<std::conjunction_v<
        is_variant_like<Variant>, is_variant_formattable<Variant, Char>>>> {
  template <typename ParseContext>
  constexpr auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
    return ctx.begin();
  }

  template <typename FormatContext>
  auto format(const Variant& value, FormatContext& ctx) const
      -> decltype(ctx.out()) {
    auto out = ctx.out();

    out = detail::write<Char>(out, "variant(");
    try {
      std::visit(
          [&](const auto& v) {
            out = detail::write_variant_alternative<Char>(out, v);
          },
          value);
    }
    catch (const std::bad_variant_access&) {
      detail::write<Char>(out, "valueless by exception");
    }
    *out++ = ')';
    return out;
  }
};
} }


namespace fmt { inline namespace v10 {

template <typename Char> struct formatter<std::error_code, Char> {
  template <typename ParseContext>
  constexpr auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
    return ctx.begin();
  }

  template <typename FormatContext>
  constexpr auto format(const std::error_code& ec, FormatContext& ctx) const
      -> decltype(ctx.out()) {
    auto out = ctx.out();
    out = detail::write_bytes(out, ec.category().name(), format_specs<Char>());
    out = detail::write<Char>(out, Char(':'));
    out = detail::write<Char>(out, ec.value());
    return out;
  }
};


template <typename T, typename Char>
struct formatter<
    T, Char,
    typename std::enable_if<std::is_base_of<std::exception, T>::value>::type> {
 private:
  bool with_typename_ = false;

 public:
  constexpr auto parse(basic_format_parse_context<Char>& ctx)
      -> decltype(ctx.begin()) {
    auto it = ctx.begin();
    auto end = ctx.end();
    if (it == end || *it == '}') return it;
    if (*it == 't') {
      ++it;
      with_typename_ = 1 != 0;
    }
    return it;
  }

  template <typename OutputIt>
  auto format(const std::exception& ex,
              basic_format_context<OutputIt, Char>& ctx) const -> OutputIt {
    format_specs<Char> spec;
    auto out = ctx.out();
    if (!with_typename_)
      return detail::write_bytes(out, string_view(ex.what()), spec);


    const std::type_info& ti = typeid(ex);

    int status = 0;
    std::size_t size = 0;
    std::unique_ptr<char, void (*)(void*)> demangled_name_ptr(
        abi::__cxa_demangle(ti.name(), nullptr, &size, &status), &std::free);

    string_view demangled_name_view;
    if (demangled_name_ptr) {
      demangled_name_view = demangled_name_ptr.get();
# 430 "/usr/include/fmt/std.h" 3 4
      if (demangled_name_view.starts_with("std::")) {
        char* begin = demangled_name_ptr.get();
        char* to = begin + 5;
        for (char *from = to, *end = begin + demangled_name_view.size();
             from < end;) {

          if (from[0] == '_' && from[1] == '_') {
            char* next = from + 1;
            while (next < end && *next != ':') next++;
            if (next[0] == ':' && next[1] == ':') {
              from = next + 2;
              continue;
            }
          }
          *to++ = *from++;
        }
        demangled_name_view = {begin, detail::to_unsigned(to - begin)};
      }
    } else {
      demangled_name_view = string_view(ti.name());
    }
    out = detail::write_bytes(out, demangled_name_view, spec);
# 462 "/usr/include/fmt/std.h" 3 4
    *out++ = ':';
    *out++ = ' ';
    return detail::write_bytes(out, string_view(ex.what()), spec);

  }
};

namespace detail {

template <typename T, typename Enable = void>
struct has_flip : std::false_type {};

template <typename T>
struct has_flip<T, void_t<decltype(std::declval<T>().flip())>>
    : std::true_type {};

template <typename T> struct is_bit_reference_like {
  static constexpr const bool value =
      std::is_convertible<T, bool>::value &&
      std::is_nothrow_assignable<T, bool>::value && has_flip<T>::value;
};
# 495 "/usr/include/fmt/std.h" 3 4
}





template <typename BitRef, typename Char>
struct formatter<BitRef, Char,
                 enable_if_t<detail::is_bit_reference_like<BitRef>::value>>
    : formatter<bool, Char> {
  template <typename FormatContext>
  constexpr auto format(const BitRef& v, FormatContext& ctx) const
      -> decltype(ctx.out()) {
    return formatter<bool, Char>::format(v, ctx);
  }
};


template <typename T, typename Char>
struct formatter<std::atomic<T>, Char,
                 enable_if_t<is_formattable<T, Char>::value>>
    : formatter<T, Char> {
  template <typename FormatContext>
  auto format(const std::atomic<T>& v, FormatContext& ctx) const
      -> decltype(ctx.out()) {
    return formatter<T, Char>::format(v.load(), ctx);
  }
};



template <typename Char>
struct formatter<std::atomic_flag, Char> : formatter<bool, Char> {
  template <typename FormatContext>
  auto format(const std::atomic_flag& v, FormatContext& ctx) const
      -> decltype(ctx.out()) {
    return formatter<bool, Char>::format(v.test(), ctx);
  }
};


} }
# 29 "/home/avi/scylla-maint/seastar/include/seastar/rpc/rpc_types.hh" 2






# 1 "/usr/include/boost/type.hpp" 1 3 4








namespace boost {



  template <class T>
  struct type {};

}
# 36 "/home/avi/scylla-maint/seastar/include/seastar/rpc/rpc_types.hh" 2



# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/circular_buffer.hh" 1
# 24 "/home/avi/scylla-maint/seastar/include/seastar/core/circular_buffer.hh"
# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/transfer.hh" 1
# 43 "/home/avi/scylla-maint/seastar/include/seastar/core/transfer.hh"
namespace seastar {


template <typename T, typename Alloc>
inline
void
transfer_pass1(Alloc& a, T* from, T* to,
        std::enable_if_t<std::is_nothrow_move_constructible_v<T>>* = nullptr) {
    std::allocator_traits<Alloc>::construct(a, to, std::move(*from));
    std::allocator_traits<Alloc>::destroy(a, from);
}

template <typename T, typename Alloc>
inline
void
transfer_pass2(Alloc&, T*, T*,
        std::enable_if_t<std::is_nothrow_move_constructible_v<T>>* = nullptr) {
}

template <typename T, typename Alloc>
inline
void
transfer_pass1(Alloc& a, T* from, T* to,
        std::enable_if_t<!std::is_nothrow_move_constructible_v<T>>* = nullptr) {
    std::allocator_traits<Alloc>::construct(a, to, *from);
}

template <typename T, typename Alloc>
inline
void
transfer_pass2(Alloc& a, T* from, T*,
        std::enable_if_t<!std::is_nothrow_move_constructible_v<T>>* = nullptr) {
    std::allocator_traits<Alloc>::destroy(a, from);
}

}
# 25 "/home/avi/scylla-maint/seastar/include/seastar/core/circular_buffer.hh" 2
# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/bitops.hh" 1
# 30 "/home/avi/scylla-maint/seastar/include/seastar/core/bitops.hh"
namespace seastar {



inline
constexpr unsigned count_leading_zeros(unsigned x) {
    return __builtin_clz(x);
}

inline
constexpr unsigned count_leading_zeros(unsigned long x) {
    return __builtin_clzl(x);
}

inline
constexpr unsigned count_leading_zeros(unsigned long long x) {
    return __builtin_clzll(x);
}

inline
constexpr unsigned count_trailing_zeros(unsigned x) {
    return __builtin_ctz(x);
}

inline
constexpr unsigned count_trailing_zeros(unsigned long x) {
    return __builtin_ctzl(x);
}

inline
constexpr unsigned count_trailing_zeros(unsigned long long x) {
    return __builtin_ctzll(x);
}

template<std::integral T>
inline constexpr unsigned log2ceil(T n) {
    if (n == 1) {
        return 0;
    }
    return std::numeric_limits<T>::digits - count_leading_zeros(n - 1);
}

template<std::integral T>
inline constexpr unsigned log2floor(T n) {
    return std::numeric_limits<T>::digits - count_leading_zeros(n) - 1;
}



}
# 26 "/home/avi/scylla-maint/seastar/include/seastar/core/circular_buffer.hh" 2







namespace seastar {
# 62 "/home/avi/scylla-maint/seastar/include/seastar/core/circular_buffer.hh"
template <typename T, typename Alloc = std::allocator<T>>
class circular_buffer {
    struct impl : Alloc {
        T* storage = nullptr;

        size_t begin = 0;
        size_t end = 0;
        size_t capacity = 0;

        impl(Alloc a) noexcept : Alloc(std::move(a)) { }
        void reset() {
            storage = {};
            begin = 0;
            end = 0;
            capacity = 0;
        }
    };
    static_assert(!std::is_default_constructible_v<Alloc>
                  || std::is_nothrow_default_constructible_v<Alloc>);
    static_assert(std::is_nothrow_move_constructible_v<Alloc>);
    impl _impl;
public:
    using value_type = T;
    using size_type = size_t;
    using reference = T&;
    using pointer = T*;
    using const_reference = const T&;
    using const_pointer = const T*;
public:
    circular_buffer() noexcept requires std::default_initializable<Alloc> : circular_buffer(Alloc()) {}
    circular_buffer(Alloc alloc) noexcept;
    circular_buffer(circular_buffer&& X) noexcept;
    circular_buffer(const circular_buffer& X) = delete;
    ~circular_buffer();
    circular_buffer& operator=(const circular_buffer&) = delete;
    circular_buffer& operator=(circular_buffer&& b) noexcept;
    void push_front(const T& data);
    void push_front(T&& data);
    template <typename... A>
    void emplace_front(A&&... args);
    void push_back(const T& data);
    void push_back(T&& data);
    template <typename... A>
    void emplace_back(A&&... args);
    T& front() noexcept;
    const T& front() const noexcept;
    T& back() noexcept;
    const T& back() const noexcept;
    void pop_front() noexcept;
    void pop_back() noexcept;
    bool empty() const noexcept;
    size_t size() const noexcept;
    size_t capacity() const noexcept;
    void reserve(size_t);
    void clear() noexcept;
    T& operator[](size_t idx) noexcept;
    const T& operator[](size_t idx) const noexcept;
    template <typename Func>
    void for_each(Func func);


    T& access_element_unsafe(size_t idx) noexcept;
private:
    void expand();
    void expand(size_t);
    void maybe_expand(size_t nr = 1);
    size_t mask(size_t idx) const;

    template<typename CB, typename ValueType>
    struct cbiterator {
        using iterator_category = std::random_access_iterator_tag;
        using value_type = ValueType;
        using difference_type = std::ptrdiff_t;
        using pointer = ValueType*;
        using reference = ValueType&;

        ValueType& operator*() const noexcept { return cb->_impl.storage[cb->mask(idx)]; }
        ValueType* operator->() const noexcept { return &cb->_impl.storage[cb->mask(idx)]; }

        cbiterator<CB, ValueType>& operator++() noexcept {
            idx++;
            return *this;
        }

        cbiterator<CB, ValueType> operator++(int) noexcept {
            auto v = *this;
            idx++;
            return v;
        }

        cbiterator<CB, ValueType>& operator--() noexcept {
            idx--;
            return *this;
        }

        cbiterator<CB, ValueType> operator--(int) noexcept {
            auto v = *this;
            idx--;
            return v;
        }
        cbiterator<CB, ValueType> operator+(difference_type n) const noexcept {
            return cbiterator<CB, ValueType>(cb, idx + n);
        }
        cbiterator<CB, ValueType> operator-(difference_type n) const noexcept {
            return cbiterator<CB, ValueType>(cb, idx - n);
        }
        cbiterator<CB, ValueType>& operator+=(difference_type n) noexcept {
            idx += n;
            return *this;
        }
        cbiterator<CB, ValueType>& operator-=(difference_type n) noexcept {
            idx -= n;
            return *this;
        }
        bool operator==(const cbiterator<CB, ValueType>& rhs) const noexcept {
            return idx == rhs.idx;
        }
        bool operator!=(const cbiterator<CB, ValueType>& rhs) const noexcept {
            return idx != rhs.idx;
        }
        bool operator<(const cbiterator<CB, ValueType>& rhs) const noexcept {
            return *this - rhs < 0;
        }
        bool operator>(const cbiterator<CB, ValueType>& rhs) const noexcept {
            return *this - rhs > 0;
        }
        bool operator>=(const cbiterator<CB, ValueType>& rhs) const noexcept {
            return *this - rhs >= 0;
        }
        bool operator<=(const cbiterator<CB, ValueType>& rhs) const noexcept {
            return *this - rhs <= 0;
        }
       difference_type operator-(const cbiterator<CB, ValueType>& rhs) const noexcept {
            return idx - rhs.idx;
        }
        cbiterator() = default;
    private:
        CB* cb{nullptr};
        size_t idx{0};
        cbiterator(CB* b, size_t i) noexcept : cb(b), idx(i) {}
        friend class circular_buffer;
    };
    friend class iterator;

public:
    typedef cbiterator<circular_buffer, T> iterator;
    typedef cbiterator<const circular_buffer, const T> const_iterator;

    iterator begin() noexcept {
        return iterator(this, _impl.begin);
    }
    const_iterator begin() const noexcept {
        return const_iterator(this, _impl.begin);
    }
    iterator end() noexcept {
        return iterator(this, _impl.end);
    }
    const_iterator end() const noexcept {
        return const_iterator(this, _impl.end);
    }
    const_iterator cbegin() const noexcept {
        return const_iterator(this, _impl.begin);
    }
    const_iterator cend() const noexcept {
        return const_iterator(this, _impl.end);
    }
    iterator erase(iterator first, iterator last) noexcept;
};

template <typename T, typename Alloc>
inline
size_t
circular_buffer<T, Alloc>::mask(size_t idx) const {
    return idx & (_impl.capacity - 1);
}

template <typename T, typename Alloc>
inline
bool
circular_buffer<T, Alloc>::empty() const noexcept {
    return _impl.begin == _impl.end;
}

template <typename T, typename Alloc>
inline
size_t
circular_buffer<T, Alloc>::size() const noexcept {
    return _impl.end - _impl.begin;
}

template <typename T, typename Alloc>
inline
size_t
circular_buffer<T, Alloc>::capacity() const noexcept {
    return _impl.capacity;
}

template <typename T, typename Alloc>
inline
void
circular_buffer<T, Alloc>::reserve(size_t size) {
    if (capacity() < size) {

        expand(size_t(1) << log2ceil(size));
    }
}

template <typename T, typename Alloc>
inline
void
circular_buffer<T, Alloc>::clear() noexcept {
    erase(begin(), end());
}

template <typename T, typename Alloc>
inline
circular_buffer<T, Alloc>::circular_buffer(Alloc alloc) noexcept
    : _impl(std::move(alloc)) {
}

template <typename T, typename Alloc>
inline
circular_buffer<T, Alloc>::circular_buffer(circular_buffer&& x) noexcept
    : _impl(std::move(x._impl)) {
    x._impl.reset();
}

template <typename T, typename Alloc>
inline
circular_buffer<T, Alloc>& circular_buffer<T, Alloc>::operator=(circular_buffer&& x) noexcept {
    if (this != &x) {
        this->~circular_buffer();
        new (this) circular_buffer(std::move(x));
    }
    return *this;
}

template <typename T, typename Alloc>
template <typename Func>
inline
void
circular_buffer<T, Alloc>::for_each(Func func) {
    auto s = _impl.storage;
    auto m = _impl.capacity - 1;
    for (auto i = _impl.begin; i != _impl.end; ++i) {
        func(s[i & m]);
    }
}

template <typename T, typename Alloc>
inline
circular_buffer<T, Alloc>::~circular_buffer() {
    for_each([this] (T& obj) {
        std::allocator_traits<Alloc>::destroy(_impl, &obj);
    });
    _impl.deallocate(_impl.storage, _impl.capacity);
}

template <typename T, typename Alloc>
void
circular_buffer<T, Alloc>::expand() {
    expand(std::max<size_t>(_impl.capacity * 2, 1));
}

template <typename T, typename Alloc>
void
circular_buffer<T, Alloc>::expand(size_t new_cap) {
    auto new_storage = _impl.allocate(new_cap);
    auto p = new_storage;
    try {
        for_each([this, &p] (T& obj) {
            transfer_pass1(_impl, &obj, p);
            p++;
        });
    } catch (...) {
        while (p != new_storage) {
            std::allocator_traits<Alloc>::destroy(_impl, --p);
        }
        _impl.deallocate(new_storage, new_cap);
        throw;
    }
    p = new_storage;
    for_each([this, &p] (T& obj) {
        transfer_pass2(_impl, &obj, p++);
    });
    std::swap(_impl.storage, new_storage);
    std::swap(_impl.capacity, new_cap);
    _impl.begin = 0;
    _impl.end = p - _impl.storage;
    _impl.deallocate(new_storage, new_cap);
}

template <typename T, typename Alloc>
inline
void
circular_buffer<T, Alloc>::maybe_expand(size_t nr) {
    if (_impl.end - _impl.begin + nr > _impl.capacity) {
        expand();
    }
}

template <typename T, typename Alloc>
inline
void
circular_buffer<T, Alloc>::push_front(const T& data) {
    maybe_expand();
    auto p = &_impl.storage[mask(_impl.begin - 1)];
    std::allocator_traits<Alloc>::construct(_impl, p, data);
    --_impl.begin;
}

template <typename T, typename Alloc>
inline
void
circular_buffer<T, Alloc>::push_front(T&& data) {
    maybe_expand();
    auto p = &_impl.storage[mask(_impl.begin - 1)];
    std::allocator_traits<Alloc>::construct(_impl, p, std::move(data));
    --_impl.begin;
}

template <typename T, typename Alloc>
template <typename... Args>
inline
void
circular_buffer<T, Alloc>::emplace_front(Args&&... args) {
    maybe_expand();
    auto p = &_impl.storage[mask(_impl.begin - 1)];
    std::allocator_traits<Alloc>::construct(_impl, p, std::forward<Args>(args)...);
    --_impl.begin;
}

template <typename T, typename Alloc>
inline
void
circular_buffer<T, Alloc>::push_back(const T& data) {
    maybe_expand();
    auto p = &_impl.storage[mask(_impl.end)];
    std::allocator_traits<Alloc>::construct(_impl, p, data);
    ++_impl.end;
}

template <typename T, typename Alloc>
inline
void
circular_buffer<T, Alloc>::push_back(T&& data) {
    maybe_expand();
    auto p = &_impl.storage[mask(_impl.end)];
    std::allocator_traits<Alloc>::construct(_impl, p, std::move(data));
    ++_impl.end;
}

template <typename T, typename Alloc>
template <typename... Args>
inline
void
circular_buffer<T, Alloc>::emplace_back(Args&&... args) {
    maybe_expand();
    auto p = &_impl.storage[mask(_impl.end)];
    std::allocator_traits<Alloc>::construct(_impl, p, std::forward<Args>(args)...);
    ++_impl.end;
}

template <typename T, typename Alloc>
inline
T&
circular_buffer<T, Alloc>::front() noexcept {
    return _impl.storage[mask(_impl.begin)];
}

template <typename T, typename Alloc>
inline
const T&
circular_buffer<T, Alloc>::front() const noexcept {
    return _impl.storage[mask(_impl.begin)];
}

template <typename T, typename Alloc>
inline
T&
circular_buffer<T, Alloc>::back() noexcept {
    return _impl.storage[mask(_impl.end - 1)];
}

template <typename T, typename Alloc>
inline
const T&
circular_buffer<T, Alloc>::back() const noexcept {
    return _impl.storage[mask(_impl.end - 1)];
}

template <typename T, typename Alloc>
inline
void
circular_buffer<T, Alloc>::pop_front() noexcept {
    std::allocator_traits<Alloc>::destroy(_impl, &front());
    ++_impl.begin;
}

template <typename T, typename Alloc>
inline
void
circular_buffer<T, Alloc>::pop_back() noexcept {
    std::allocator_traits<Alloc>::destroy(_impl, &back());
    --_impl.end;
}

template <typename T, typename Alloc>
inline
T&
circular_buffer<T, Alloc>::operator[](size_t idx) noexcept {
    return _impl.storage[mask(_impl.begin + idx)];
}

template <typename T, typename Alloc>
inline
const T&
circular_buffer<T, Alloc>::operator[](size_t idx) const noexcept {
    return _impl.storage[mask(_impl.begin + idx)];
}

template <typename T, typename Alloc>
inline
T&
circular_buffer<T, Alloc>::access_element_unsafe(size_t idx) noexcept {
    return _impl.storage[mask(_impl.begin + idx)];
}

template <typename T, typename Alloc>
inline
typename circular_buffer<T, Alloc>::iterator
circular_buffer<T, Alloc>::erase(iterator first, iterator last) noexcept {
    static_assert(std::is_nothrow_move_assignable_v<T>, "erase() assumes move assignment does not throw");
    if (first == last) {
        return last;
    }


    if (std::distance(begin(), first) < std::distance(last, end())) {
        auto new_start = std::move_backward(begin(), first, last);
        for (auto i = begin(); i < new_start; ++i) {
            std::allocator_traits<Alloc>::destroy(_impl, &*i);
        }
        _impl.begin = new_start.idx;
        return last;
    } else {
        auto new_end = std::move(last, end(), first);
        for (auto i = new_end, e = end(); i < e; ++i) {
            std::allocator_traits<Alloc>::destroy(_impl, &*i);
        }
        _impl.end = new_end.idx;
        return first;
    }
}

}
# 40 "/home/avi/scylla-maint/seastar/include/seastar/rpc/rpc_types.hh" 2
# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/simple-stream.hh" 1
# 34 "/home/avi/scylla-maint/seastar/include/seastar/core/simple-stream.hh"
namespace seastar {



class measuring_output_stream {
    size_t _size = 0;
public:
    void write(const char*, size_t size) {
        _size += size;
    }

    size_t size() const {
        return _size;
    }
};

template<typename>
class memory_output_stream;

class simple_memory_input_stream;

template<typename Iterator>
class fragmented_memory_input_stream;

template<typename Iterator>
class memory_input_stream;

class simple_memory_output_stream {
    char* _p = nullptr;
    size_t _size = 0;
public:
    using has_with_stream = std::false_type;
    simple_memory_output_stream() {}
    simple_memory_output_stream(char* p, size_t size, size_t start = 0) : _p(p + start), _size(size) {}
    char* begin() { return _p; }

    [[gnu::always_inline]]
    void skip(size_t size) {
        if (size > _size) {
            throw std::out_of_range("serialization buffer overflow");
        }
        _p += size;
        _size -= size;
    }

    [[gnu::always_inline]]
    simple_memory_output_stream write_substream(size_t size) {
       if (size > _size) {
           throw std::out_of_range("serialization buffer overflow");
       }
       simple_memory_output_stream substream(_p, size);
       skip(size);
       return substream;
    }

    [[gnu::always_inline]]
    void write(const char* p, size_t size) {
        if (size > _size) {
            throw std::out_of_range("serialization buffer overflow");
        }
        std::copy_n(p, size, _p);
        skip(size);
    }

    [[gnu::always_inline]]
    void fill(char c, size_t size) {
        if (size > _size) {
            throw std::out_of_range("serialization buffer overflow");
        }
        std::fill_n(_p, size, c);
        skip(size);
    }

    [[gnu::always_inline]]
    size_t size() const {
        return _size;
    }





    simple_memory_input_stream to_input_stream() const;
};

template<typename Iterator>
class fragmented_memory_output_stream {
    using simple = simple_memory_output_stream ;

    Iterator _it;
    simple _current;
    size_t _size = 0;

    friend class memory_input_stream<Iterator>;
private:
    template<typename Func>

    void for_each_fragment(size_t size, Func&& func) {
        if (size > _size) {
            throw std::out_of_range("serialization buffer overflow");
        }
        _size -= size;
        while (size) {
            if (!_current.size()) {
                _current = simple(reinterpret_cast<char*>((*_it).get_write()), (*_it).size());
                _it++;
            }
            auto this_size = std::min(_current.size(), size);
            func(_current.write_substream(this_size));
            size -= this_size;
        }
    }
    fragmented_memory_output_stream(Iterator it, simple_memory_output_stream bv, size_t size)
        : _it(it), _current(bv), _size(size) { }
public:
    using has_with_stream = std::false_type;
    using iterator_type = Iterator;

    fragmented_memory_output_stream() = default;

    fragmented_memory_output_stream(Iterator it, size_t size)
        : _it(it), _size(size) {
    }

    void skip(size_t size) {
        for_each_fragment(size, [] (auto) { });
    }
    memory_output_stream<Iterator> write_substream(size_t size) {
        if (size > _size) {
            throw std::out_of_range("serialization buffer overflow");
        }
        if (_current.size() >= size) {
            _size -= size;
            return _current.write_substream(size);
        }
        fragmented_memory_output_stream substream(_it, _current, size);
        skip(size);
        return substream;
    }
    void write(const char* p, size_t size) {
        for_each_fragment(size, [&p] (auto bv) {
            std::copy_n(p, bv.size(), bv.begin());
            p += bv.size();
        });
    }
    void fill(char c, size_t size) {
        for_each_fragment(size, [c] (simple fragment) {
            std::fill_n(fragment.begin(), fragment.size(), c);
        });
    }
    size_t size() const {
        return _size;
    }




    fragmented_memory_input_stream<Iterator> to_input_stream() const;
};

template<typename Iterator>
class memory_output_stream {
public:
    using simple = simple_memory_output_stream;
    using fragmented = fragmented_memory_output_stream<Iterator>;

private:
    const bool _is_simple;
    using fragmented_type = fragmented;
    union {
        simple _simple;
        fragmented_type _fragmented;
    };
public:
    template<typename StreamVisitor>
    [[gnu::always_inline]]
    decltype(auto) with_stream(StreamVisitor&& visitor) {
        if (__builtin_expect(_is_simple, true)) {
            return visitor(_simple);
        }
        return visitor(_fragmented);
    }

    template<typename StreamVisitor>
    [[gnu::always_inline]]
    decltype(auto) with_stream(StreamVisitor&& visitor) const {
        if (__builtin_expect(_is_simple, true)) {
            return visitor(_simple);
        }
        return visitor(_fragmented);
    }
public:
    using has_with_stream = std::true_type;
    using iterator_type = Iterator;
    memory_output_stream()
            : _is_simple(true), _simple() {}
    memory_output_stream(simple stream)
            : _is_simple(true), _simple(std::move(stream)) {}
    memory_output_stream(fragmented stream)
            : _is_simple(false), _fragmented(std::move(stream)) {}

    [[gnu::always_inline]]
    memory_output_stream(const memory_output_stream& other) noexcept : _is_simple(other._is_simple) {





        static_assert(std::is_nothrow_copy_constructible_v<fragmented>,
                      "seastar::memory_output_stream::fragmented should be copy constructible");
        static_assert(std::is_nothrow_copy_constructible_v<simple>,
                      "seastar::memory_output_stream::simple should be copy constructible");
        if (_is_simple) {
            new (&_simple) simple(other._simple);
        } else {
            new (&_fragmented) fragmented_type(other._fragmented);
        }
    }

    [[gnu::always_inline]]
    memory_output_stream(memory_output_stream&& other) noexcept : _is_simple(other._is_simple) {
        if (_is_simple) {
            new (&_simple) simple(std::move(other._simple));
        } else {
            new (&_fragmented) fragmented_type(std::move(other._fragmented));
        }
    }

    [[gnu::always_inline]]
    memory_output_stream& operator=(const memory_output_stream& other) noexcept {

        static_assert(std::is_nothrow_copy_constructible_v<memory_output_stream>,
                      "memory_output_stream copy constructor shouldn't throw");
        if (this != &other) {
            this->~memory_output_stream();
            new (this) memory_output_stream(other);
        }
        return *this;
    }

    [[gnu::always_inline]]
    memory_output_stream& operator=(memory_output_stream&& other) noexcept {
        if (this != &other) {
            this->~memory_output_stream();
            new (this) memory_output_stream(std::move(other));
        }
        return *this;
    }

    [[gnu::always_inline]]
    ~memory_output_stream() {
        if (_is_simple) {
            _simple.~simple();
        } else {
            _fragmented.~fragmented_type();
        }
    }

    [[gnu::always_inline]]
    void skip(size_t size) {
        with_stream([size] (auto& stream) {
            stream.skip(size);
        });
    }

    [[gnu::always_inline]]
    memory_output_stream write_substream(size_t size) {
        return with_stream([size] (auto& stream) -> memory_output_stream {
            return stream.write_substream(size);
        });
    }

    [[gnu::always_inline]]
    void write(const char* p, size_t size) {
        with_stream([p, size] (auto& stream) {
            stream.write(p, size);
        });
    }

    [[gnu::always_inline]]
    void fill(char c, size_t size) {
        with_stream([c, size] (auto& stream) {
            stream.fill(c, size);
        });
    }

    [[gnu::always_inline]]
    size_t size() const {
        return with_stream([] (auto& stream) {
            return stream.size();
        });
    }

    memory_input_stream<Iterator> to_input_stream() const;
};

class simple_memory_input_stream {
    using simple = simple_memory_input_stream;

    const char* _p = nullptr;
    size_t _size = 0;
public:
    using has_with_stream = std::false_type;
    simple_memory_input_stream() = default;
    simple_memory_input_stream(const char* p, size_t size) : _p(p), _size(size) {}

    const char* begin() const { return _p; }

    [[gnu::always_inline]]
    void skip(size_t size) {
        if (size > _size) {
            throw std::out_of_range("deserialization buffer underflow");
        }
        _p += size;
        _size -= size;
    }

    [[gnu::always_inline]]
    simple read_substream(size_t size) {
        if (size > _size) {
            throw std::out_of_range("deserialization buffer underflow");
        }
        simple substream(_p, size);
        skip(size);
        return substream;
    }

    [[gnu::always_inline]]
    void read(char* p, size_t size) {
        if (size > _size) {
            throw std::out_of_range("deserialization buffer underflow");
        }
        std::copy_n(_p, size, p);
        skip(size);
    }

    template<typename Output>
    [[gnu::always_inline]]
    void copy_to(Output& out) const {
        out.write(_p, _size);
    }

    [[gnu::always_inline]]
    size_t size() const {
        return _size;
    }
};

template<typename Iterator>
class fragmented_memory_input_stream {
    using simple = simple_memory_input_stream;
    using fragmented = fragmented_memory_input_stream;

    Iterator _it;
    simple _current;
    size_t _size;
private:
    template<typename Func>

    void for_each_fragment(size_t size, Func&& func) {
        if (size > _size) {
            throw std::out_of_range("deserialization buffer underflow");
        }
        _size -= size;
        while (size) {
            if (!_current.size()) {
                _current = simple(reinterpret_cast<const char*>((*_it).begin()), (*_it).size());
                _it++;
            }
            auto this_size = std::min(_current.size(), size);
            func(_current.read_substream(this_size));
            size -= this_size;
        }
    }
    fragmented_memory_input_stream(Iterator it, simple bv, size_t size)
        : _it(it), _current(bv), _size(size) { }
    friend class fragmented_memory_output_stream<Iterator>;
public:
    using has_with_stream = std::false_type;
    using iterator_type = Iterator;
    fragmented_memory_input_stream(Iterator it, size_t size)
        : _it(it), _size(size) {
    }

    void skip(size_t size) {
        for_each_fragment(size, [] (auto) { });
    }
    fragmented read_substream(size_t size) {
        if (size > _size) {
            throw std::out_of_range("deserialization buffer underflow");
        }
        fragmented substream(_it, _current, size);
        skip(size);
        return substream;
    }
    void read(char* p, size_t size) {
        for_each_fragment(size, [&p] (auto bv) {
            p = std::copy_n(bv.begin(), bv.size(), p);
        });
    }
    template<typename Output>
    void copy_to(Output& out) {
        for_each_fragment(_size, [&out] (auto bv) {
            bv.copy_to(out);
        });
    }
    size_t size() const {
        return _size;
    }

    const char* first_fragment_data() const { return _current.begin(); }
    size_t first_fragment_size() const { return _current.size(); }
    Iterator fragment_iterator() const { return _it; }
};
# 463 "/home/avi/scylla-maint/seastar/include/seastar/core/simple-stream.hh"
template<typename Iterator>
class memory_input_stream {
public:
    using simple = simple_memory_input_stream;
    using fragmented = fragmented_memory_input_stream<Iterator>;
private:
    const bool _is_simple;
    using fragmented_type = fragmented;
    union {
        simple _simple;
        fragmented_type _fragmented;
    };
public:
    template<typename StreamVisitor>
    [[gnu::always_inline]]
    decltype(auto) with_stream(StreamVisitor&& visitor) {
        if (__builtin_expect(_is_simple, true)) {
            return visitor(_simple);
        }
        return visitor(_fragmented);
    }

    template<typename StreamVisitor>
    [[gnu::always_inline]]
    decltype(auto) with_stream(StreamVisitor&& visitor) const {
        if (__builtin_expect(_is_simple, true)) {
            return visitor(_simple);
        }
        return visitor(_fragmented);
    }
public:
    using has_with_stream = std::true_type;
    using iterator_type = Iterator;
    memory_input_stream(simple stream)
            : _is_simple(true), _simple(std::move(stream)) {}
    memory_input_stream(fragmented stream)
            : _is_simple(false), _fragmented(std::move(stream)) {}

    [[gnu::always_inline]]
    memory_input_stream(const memory_input_stream& other) noexcept : _is_simple(other._is_simple) {





        static_assert(std::is_nothrow_copy_constructible_v<fragmented>,
                      "seastar::memory_input_stream::fragmented should be copy constructible");
        static_assert(std::is_nothrow_copy_constructible_v<simple>,
                      "seastar::memory_input_stream::simple should be copy constructible");
        if (_is_simple) {
            new (&_simple) simple(other._simple);
        } else {
            new (&_fragmented) fragmented_type(other._fragmented);
        }
    }

    [[gnu::always_inline]]
    memory_input_stream(memory_input_stream&& other) noexcept : _is_simple(other._is_simple) {
        if (_is_simple) {
            new (&_simple) simple(std::move(other._simple));
        } else {
            new (&_fragmented) fragmented_type(std::move(other._fragmented));
        }
    }

    [[gnu::always_inline]]
    memory_input_stream& operator=(const memory_input_stream& other) noexcept {

        static_assert(std::is_nothrow_copy_constructible_v<memory_input_stream>,
                      "memory_input_stream copy constructor shouldn't throw");
        if (this != &other) {
            this->~memory_input_stream();
            new (this) memory_input_stream(other);
        }
        return *this;
    }

    [[gnu::always_inline]]
    memory_input_stream& operator=(memory_input_stream&& other) noexcept {
        if (this != &other) {
            this->~memory_input_stream();
            new (this) memory_input_stream(std::move(other));
        }
        return *this;
    }

    [[gnu::always_inline]]
    ~memory_input_stream() {
        if (_is_simple) {
            _simple.~simple_memory_input_stream();
        } else {
            _fragmented.~fragmented_type();
        }
    }

    [[gnu::always_inline]]
    void skip(size_t size) {
        with_stream([size] (auto& stream) {
            stream.skip(size);
        });
    }

    [[gnu::always_inline]]
    memory_input_stream read_substream(size_t size) {
        return with_stream([size] (auto& stream) -> memory_input_stream {
            return stream.read_substream(size);
        });
    }

    [[gnu::always_inline]]
    void read(char* p, size_t size) {
        with_stream([p, size] (auto& stream) {
            stream.read(p, size);
        });
    }

    template<typename Output>
    [[gnu::always_inline]]
    void copy_to(Output& out) {
        with_stream([&out] (auto& stream) {
            stream.copy_to(out);
        });
    }

    [[gnu::always_inline]]
    size_t size() const {
        return with_stream([] (auto& stream) {
            return stream.size();
        });
    }

    template<typename Stream, typename StreamVisitor>
    friend decltype(auto) with_serialized_stream(Stream& stream, StreamVisitor&& visitor);
};



inline simple_memory_input_stream simple_memory_output_stream::to_input_stream() const {
    return simple_memory_input_stream(_p, _size);
}

template<typename Iterator>
inline fragmented_memory_input_stream<Iterator> fragmented_memory_output_stream<Iterator>::to_input_stream() const {
    return fragmented_memory_input_stream<Iterator>(_it, _current.to_input_stream(), _size);
}

template<typename Iterator>
inline memory_input_stream<Iterator> memory_output_stream<Iterator>::to_input_stream() const {
    return with_stream(make_visitor(
        [] (const simple_memory_output_stream& ostream) -> memory_input_stream<Iterator> {
            return ostream.to_input_stream();
        },
        [] (const fragmented_memory_output_stream<Iterator>& ostream) -> memory_input_stream<Iterator> {
            return ostream.to_input_stream();
        }
    ));
}
# 635 "/home/avi/scylla-maint/seastar/include/seastar/core/simple-stream.hh"
template<typename Stream, typename StreamVisitor, typename = std::enable_if_t<Stream::has_with_stream::value>>
[[gnu::always_inline]]
 inline decltype(auto)
 with_serialized_stream(Stream& stream, StreamVisitor&& visitor) {
    return stream.with_stream(std::forward<StreamVisitor>(visitor));
}

template<typename Stream, typename StreamVisitor, typename = std::enable_if_t<!Stream::has_with_stream::value>, typename = void>
[[gnu::always_inline]]
 inline decltype(auto)
 with_serialized_stream(Stream& stream, StreamVisitor&& visitor) {
    return visitor(stream);
}

using simple_input_stream = simple_memory_input_stream;
using simple_output_stream = simple_memory_output_stream;



}
# 41 "/home/avi/scylla-maint/seastar/include/seastar/rpc/rpc_types.hh" 2

# 1 "/usr/include/boost/functional/hash.hpp" 1 3 4
# 43 "/home/avi/scylla-maint/seastar/include/seastar/rpc/rpc_types.hh" 2
# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/sharded.hh" 1
# 24 "/home/avi/scylla-maint/seastar/include/seastar/core/sharded.hh"
# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/smp.hh" 1
# 27 "/home/avi/scylla-maint/seastar/include/seastar/core/smp.hh"
# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/metrics_registration.hh" 1
# 52 "/home/avi/scylla-maint/seastar/include/seastar/core/metrics_registration.hh"
namespace seastar {

namespace metrics {

namespace impl {
class metric_groups_def;
struct metric_definition_impl;
class metric_groups_impl;
}



using group_name_type = sstring;
class metric_groups;

class metric_definition {
    std::unique_ptr<impl::metric_definition_impl> _impl;
public:
    metric_definition(const impl::metric_definition_impl& impl) noexcept;
    metric_definition(metric_definition&& m) noexcept;
    ~metric_definition();
    friend metric_groups;
    friend impl::metric_groups_impl;
};

class metric_group_definition {
public:
    group_name_type name;
    std::initializer_list<metric_definition> metrics;
    metric_group_definition(const group_name_type& name, std::initializer_list<metric_definition> l);
    metric_group_definition(const metric_group_definition&) = delete;
    ~metric_group_definition();
};
# 94 "/home/avi/scylla-maint/seastar/include/seastar/core/metrics_registration.hh"
class metric_groups {
    std::unique_ptr<impl::metric_groups_def> _impl;
public:
    metric_groups() noexcept;
    metric_groups(metric_groups&&) = default;
    virtual ~metric_groups();
    metric_groups& operator=(metric_groups&&) = default;





    metric_groups(std::initializer_list<metric_group_definition> mg);
# 128 "/home/avi/scylla-maint/seastar/include/seastar/core/metrics_registration.hh"
    metric_groups& add_group(const group_name_type& name, const std::initializer_list<metric_definition>& l);
# 146 "/home/avi/scylla-maint/seastar/include/seastar/core/metrics_registration.hh"
    metric_groups& add_group(const group_name_type& name, const std::vector<metric_definition>& l);




    void clear();
};







class metric_group : public metric_groups {
public:
    metric_group() noexcept;
    metric_group(const metric_group&) = delete;
    metric_group(metric_group&&) = default;
    virtual ~metric_group();
    metric_group& operator=(metric_group&&) = default;






    metric_group(const group_name_type& name, std::initializer_list<metric_definition> l);
};



}
}
# 28 "/home/avi/scylla-maint/seastar/include/seastar/core/smp.hh" 2

# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/reactor_config.hh" 1
# 25 "/home/avi/scylla-maint/seastar/include/seastar/core/reactor_config.hh"
# 1 "/home/avi/scylla-maint/seastar/include/seastar/util/memory_diagnostics.hh" 1
# 28 "/home/avi/scylla-maint/seastar/include/seastar/util/memory_diagnostics.hh"
namespace seastar {



enum class log_level;

namespace memory {






enum class alloc_failure_kind {

    none,


    critical,

    all,
};





void set_dump_memory_diagnostics_on_alloc_failure_kind(alloc_failure_kind);





void set_dump_memory_diagnostics_on_alloc_failure_kind(std::string_view);


using memory_diagnostics_writer = noncopyable_function<void(std::string_view)>;
# 82 "/home/avi/scylla-maint/seastar/include/seastar/util/memory_diagnostics.hh"
void set_additional_diagnostics_producer(noncopyable_function<void(memory_diagnostics_writer)> producer);






sstring generate_memory_diagnostics_report();



namespace internal {






void log_memory_diagnostics_report(log_level lvl);
}

}
}
# 26 "/home/avi/scylla-maint/seastar/include/seastar/core/reactor_config.hh" 2


namespace seastar {


struct reactor_config {
    bool auto_handle_sigint_sigterm = true;
    unsigned max_networking_aio_io_control_blocks = 10000;
};


class reactor_backend_selector;
class network_stack_factory;



struct reactor_options : public program_options::option_group {







    program_options::selection_value<network_stack_factory> network_stack;

    program_options::value<> poll_mode;



    program_options::value<unsigned> idle_poll_time_us;



    program_options::value<bool> poll_aio;



    program_options::value<double> task_quota_ms;



    program_options::value<double> io_latency_goal_ms;







    program_options::value<double> io_flow_ratio_threshold;





    program_options::value<unsigned> max_task_backlog;




    program_options::value<unsigned> blocked_reactor_notify_ms;



    program_options::value<unsigned> blocked_reactor_reports_per_minute;



    program_options::value<bool> blocked_reactor_report_format_oneline;

    program_options::value<> relaxed_dma;


    program_options::value<bool> linux_aio_nowait;




    program_options::value<bool> unsafe_bypass_fsync;





    program_options::value<bool> kernel_page_cache;






    program_options::value<> overprovisioned;

    program_options::value<> abort_on_seastar_bad_alloc;





    program_options::value<bool> force_aio_syscalls;
# 135 "/home/avi/scylla-maint/seastar/include/seastar/core/reactor_config.hh"
    program_options::value<memory::alloc_failure_kind> dump_memory_diagnostics_on_alloc_failure_kind;
# 144 "/home/avi/scylla-maint/seastar/include/seastar/core/reactor_config.hh"
    program_options::selection_value<reactor_backend_selector> reactor_backend;



    program_options::value<bool> aio_fsync;







    program_options::value<unsigned> max_networking_io_control_blocks;







    program_options::value<unsigned> heapprof;

    program_options::value<> no_handle_interrupt;


    std::string _argv0;
    bool _auto_handle_sigint_sigterm = true;


public:

    reactor_options(program_options::option_group* parent_group);

};

}
# 30 "/home/avi/scylla-maint/seastar/include/seastar/core/smp.hh" 2
# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/resource.hh" 1
# 24 "/home/avi/scylla-maint/seastar/include/seastar/core/resource.hh"
# 1 "/home/avi/scylla-maint/seastar/include/seastar/util/spinlock.hh" 1
# 28 "/home/avi/scylla-maint/seastar/include/seastar/util/spinlock.hh"
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 1 3
# 42 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 3


# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 45 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 2 3
# 29 "/home/avi/scylla-maint/seastar/include/seastar/util/spinlock.hh" 2


# 1 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 1 3
# 17 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
# 1 "/usr/bin/../lib/clang/18/include/mmintrin.h" 1 3
# 17 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
typedef long long __m64 __attribute__((__vector_size__(8), __aligned__(8)));

typedef long long __v1di __attribute__((__vector_size__(8)));
typedef int __v2si __attribute__((__vector_size__(8)));
typedef short __v4hi __attribute__((__vector_size__(8)));
typedef char __v8qi __attribute__((__vector_size__(8)));
# 36 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ void __attribute__((__always_inline__, __nodebug__,
                                      __target__("mmx,no-evex512")))
_mm_empty(void) {
  __builtin_ia32_emms();
}
# 53 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_cvtsi32_si64(int __i)
{
    return (__m64)__builtin_ia32_vec_init_v2si(__i, 0);
}
# 70 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ int __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_cvtsi64_si32(__m64 __m)
{
    return __builtin_ia32_vec_ext_v2si((__v2si)__m, 0);
}
# 86 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_cvtsi64_m64(long long __i)
{
    return (__m64)__i;
}
# 102 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ long long __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_cvtm64_si64(__m64 __m)
{
    return (long long)__m;
}
# 132 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_packs_pi16(__m64 __m1, __m64 __m2)
{
    return (__m64)__builtin_ia32_packsswb((__v4hi)__m1, (__v4hi)__m2);
}
# 162 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_packs_pi32(__m64 __m1, __m64 __m2)
{
    return (__m64)__builtin_ia32_packssdw((__v2si)__m1, (__v2si)__m2);
}
# 192 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_packs_pu16(__m64 __m1, __m64 __m2)
{
    return (__m64)__builtin_ia32_packuswb((__v4hi)__m1, (__v4hi)__m2);
}
# 219 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_unpackhi_pi8(__m64 __m1, __m64 __m2)
{
    return (__m64)__builtin_ia32_punpckhbw((__v8qi)__m1, (__v8qi)__m2);
}
# 242 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_unpackhi_pi16(__m64 __m1, __m64 __m2)
{
    return (__m64)__builtin_ia32_punpckhwd((__v4hi)__m1, (__v4hi)__m2);
}
# 263 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_unpackhi_pi32(__m64 __m1, __m64 __m2)
{
    return (__m64)__builtin_ia32_punpckhdq((__v2si)__m1, (__v2si)__m2);
}
# 290 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_unpacklo_pi8(__m64 __m1, __m64 __m2)
{
    return (__m64)__builtin_ia32_punpcklbw((__v8qi)__m1, (__v8qi)__m2);
}
# 313 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_unpacklo_pi16(__m64 __m1, __m64 __m2)
{
    return (__m64)__builtin_ia32_punpcklwd((__v4hi)__m1, (__v4hi)__m2);
}
# 334 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_unpacklo_pi32(__m64 __m1, __m64 __m2)
{
    return (__m64)__builtin_ia32_punpckldq((__v2si)__m1, (__v2si)__m2);
}
# 355 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_add_pi8(__m64 __m1, __m64 __m2)
{
    return (__m64)__builtin_ia32_paddb((__v8qi)__m1, (__v8qi)__m2);
}
# 376 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_add_pi16(__m64 __m1, __m64 __m2)
{
    return (__m64)__builtin_ia32_paddw((__v4hi)__m1, (__v4hi)__m2);
}
# 397 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_add_pi32(__m64 __m1, __m64 __m2)
{
    return (__m64)__builtin_ia32_paddd((__v2si)__m1, (__v2si)__m2);
}
# 419 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_adds_pi8(__m64 __m1, __m64 __m2)
{
    return (__m64)__builtin_ia32_paddsb((__v8qi)__m1, (__v8qi)__m2);
}
# 442 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_adds_pi16(__m64 __m1, __m64 __m2)
{
    return (__m64)__builtin_ia32_paddsw((__v4hi)__m1, (__v4hi)__m2);
}
# 464 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_adds_pu8(__m64 __m1, __m64 __m2)
{
    return (__m64)__builtin_ia32_paddusb((__v8qi)__m1, (__v8qi)__m2);
}
# 486 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_adds_pu16(__m64 __m1, __m64 __m2)
{
    return (__m64)__builtin_ia32_paddusw((__v4hi)__m1, (__v4hi)__m2);
}
# 507 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_sub_pi8(__m64 __m1, __m64 __m2)
{
    return (__m64)__builtin_ia32_psubb((__v8qi)__m1, (__v8qi)__m2);
}
# 528 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_sub_pi16(__m64 __m1, __m64 __m2)
{
    return (__m64)__builtin_ia32_psubw((__v4hi)__m1, (__v4hi)__m2);
}
# 549 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_sub_pi32(__m64 __m1, __m64 __m2)
{
    return (__m64)__builtin_ia32_psubd((__v2si)__m1, (__v2si)__m2);
}
# 572 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_subs_pi8(__m64 __m1, __m64 __m2)
{
    return (__m64)__builtin_ia32_psubsb((__v8qi)__m1, (__v8qi)__m2);
}
# 595 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_subs_pi16(__m64 __m1, __m64 __m2)
{
    return (__m64)__builtin_ia32_psubsw((__v4hi)__m1, (__v4hi)__m2);
}
# 619 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_subs_pu8(__m64 __m1, __m64 __m2)
{
    return (__m64)__builtin_ia32_psubusb((__v8qi)__m1, (__v8qi)__m2);
}
# 643 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_subs_pu16(__m64 __m1, __m64 __m2)
{
    return (__m64)__builtin_ia32_psubusw((__v4hi)__m1, (__v4hi)__m2);
}
# 670 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_madd_pi16(__m64 __m1, __m64 __m2)
{
    return (__m64)__builtin_ia32_pmaddwd((__v4hi)__m1, (__v4hi)__m2);
}
# 691 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_mulhi_pi16(__m64 __m1, __m64 __m2)
{
    return (__m64)__builtin_ia32_pmulhw((__v4hi)__m1, (__v4hi)__m2);
}
# 712 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_mullo_pi16(__m64 __m1, __m64 __m2)
{
    return (__m64)__builtin_ia32_pmullw((__v4hi)__m1, (__v4hi)__m2);
}
# 735 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_sll_pi16(__m64 __m, __m64 __count)
{
    return (__m64)__builtin_ia32_psllw((__v4hi)__m, __count);
}
# 757 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_slli_pi16(__m64 __m, int __count)
{
    return (__m64)__builtin_ia32_psllwi((__v4hi)__m, __count);
}
# 780 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_sll_pi32(__m64 __m, __m64 __count)
{
    return (__m64)__builtin_ia32_pslld((__v2si)__m, __count);
}
# 802 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_slli_pi32(__m64 __m, int __count)
{
    return (__m64)__builtin_ia32_pslldi((__v2si)__m, __count);
}
# 822 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_sll_si64(__m64 __m, __m64 __count)
{
    return (__m64)__builtin_ia32_psllq((__v1di)__m, __count);
}
# 842 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_slli_si64(__m64 __m, int __count)
{
    return (__m64)__builtin_ia32_psllqi((__v1di)__m, __count);
}
# 866 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_sra_pi16(__m64 __m, __m64 __count)
{
    return (__m64)__builtin_ia32_psraw((__v4hi)__m, __count);
}
# 889 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_srai_pi16(__m64 __m, int __count)
{
    return (__m64)__builtin_ia32_psrawi((__v4hi)__m, __count);
}
# 913 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_sra_pi32(__m64 __m, __m64 __count)
{
    return (__m64)__builtin_ia32_psrad((__v2si)__m, __count);
}
# 936 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_srai_pi32(__m64 __m, int __count)
{
    return (__m64)__builtin_ia32_psradi((__v2si)__m, __count);
}
# 959 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_srl_pi16(__m64 __m, __m64 __count)
{
    return (__m64)__builtin_ia32_psrlw((__v4hi)__m, __count);
}
# 981 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_srli_pi16(__m64 __m, int __count)
{
    return (__m64)__builtin_ia32_psrlwi((__v4hi)__m, __count);
}
# 1004 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_srl_pi32(__m64 __m, __m64 __count)
{
    return (__m64)__builtin_ia32_psrld((__v2si)__m, __count);
}
# 1026 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_srli_pi32(__m64 __m, int __count)
{
    return (__m64)__builtin_ia32_psrldi((__v2si)__m, __count);
}
# 1046 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_srl_si64(__m64 __m, __m64 __count)
{
    return (__m64)__builtin_ia32_psrlq((__v1di)__m, __count);
}
# 1067 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_srli_si64(__m64 __m, int __count)
{
    return (__m64)__builtin_ia32_psrlqi((__v1di)__m, __count);
}
# 1085 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_and_si64(__m64 __m1, __m64 __m2)
{
    return __builtin_ia32_pand((__v1di)__m1, (__v1di)__m2);
}
# 1106 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_andnot_si64(__m64 __m1, __m64 __m2)
{
    return __builtin_ia32_pandn((__v1di)__m1, (__v1di)__m2);
}
# 1124 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_or_si64(__m64 __m1, __m64 __m2)
{
    return __builtin_ia32_por((__v1di)__m1, (__v1di)__m2);
}
# 1142 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_xor_si64(__m64 __m1, __m64 __m2)
{
    return __builtin_ia32_pxor((__v1di)__m1, (__v1di)__m2);
}
# 1164 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_cmpeq_pi8(__m64 __m1, __m64 __m2)
{
    return (__m64)__builtin_ia32_pcmpeqb((__v8qi)__m1, (__v8qi)__m2);
}
# 1186 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_cmpeq_pi16(__m64 __m1, __m64 __m2)
{
    return (__m64)__builtin_ia32_pcmpeqw((__v4hi)__m1, (__v4hi)__m2);
}
# 1208 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_cmpeq_pi32(__m64 __m1, __m64 __m2)
{
    return (__m64)__builtin_ia32_pcmpeqd((__v2si)__m1, (__v2si)__m2);
}
# 1230 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_cmpgt_pi8(__m64 __m1, __m64 __m2)
{
    return (__m64)__builtin_ia32_pcmpgtb((__v8qi)__m1, (__v8qi)__m2);
}
# 1252 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_cmpgt_pi16(__m64 __m1, __m64 __m2)
{
    return (__m64)__builtin_ia32_pcmpgtw((__v4hi)__m1, (__v4hi)__m2);
}
# 1274 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_cmpgt_pi32(__m64 __m1, __m64 __m2)
{
    return (__m64)__builtin_ia32_pcmpgtd((__v2si)__m1, (__v2si)__m2);
}
# 1287 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_setzero_si64(void)
{
    return __extension__ (__m64){ 0LL };
}
# 1308 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_set_pi32(int __i1, int __i0)
{
    return (__m64)__builtin_ia32_vec_init_v2si(__i0, __i1);
}
# 1331 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_set_pi16(short __s3, short __s2, short __s1, short __s0)
{
    return (__m64)__builtin_ia32_vec_init_v4hi(__s0, __s1, __s2, __s3);
}
# 1362 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_set_pi8(char __b7, char __b6, char __b5, char __b4, char __b3, char __b2,
            char __b1, char __b0)
{
    return (__m64)__builtin_ia32_vec_init_v8qi(__b0, __b1, __b2, __b3,
                                               __b4, __b5, __b6, __b7);
}
# 1383 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_set1_pi32(int __i)
{
    return _mm_set_pi32(__i, __i);
}
# 1402 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_set1_pi16(short __w)
{
    return _mm_set_pi16(__w, __w, __w, __w);
}
# 1420 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_set1_pi8(char __b)
{
    return _mm_set_pi8(__b, __b, __b, __b, __b, __b, __b, __b);
}
# 1441 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_setr_pi32(int __i0, int __i1)
{
    return _mm_set_pi32(__i1, __i0);
}
# 1464 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_setr_pi16(short __w0, short __w1, short __w2, short __w3)
{
    return _mm_set_pi16(__w3, __w2, __w1, __w0);
}
# 1495 "/usr/bin/../lib/clang/18/include/mmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,no-evex512"), __min_vector_width__(64)))
_mm_setr_pi8(char __b0, char __b1, char __b2, char __b3, char __b4, char __b5,
             char __b6, char __b7)
{
    return _mm_set_pi8(__b7, __b6, __b5, __b4, __b3, __b2, __b1, __b0);
}
# 18 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 2 3

typedef int __v4si __attribute__((__vector_size__(16)));
typedef float __v4sf __attribute__((__vector_size__(16)));
typedef float __m128 __attribute__((__vector_size__(16), __aligned__(16)));

typedef float __m128_u __attribute__((__vector_size__(16), __aligned__(1)));


typedef unsigned int __v4su __attribute__((__vector_size__(16)));




# 1 "/usr/bin/../lib/clang/18/include/mm_malloc.h" 1 3
# 13 "/usr/bin/../lib/clang/18/include/mm_malloc.h" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/stdlib.h" 1 3
# 36 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/stdlib.h" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdlib" 1 3
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdlib" 3
# 37 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/stdlib.h" 2 3

using std::abort;
using std::atexit;
using std::exit;


  using std::at_quick_exit;


  using std::quick_exit;


  using std::_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;
# 14 "/usr/bin/../lib/clang/18/include/mm_malloc.h" 2 3
# 25 "/usr/bin/../lib/clang/18/include/mm_malloc.h" 3
extern "C" int posix_memalign(void **__memptr, size_t __alignment, size_t __size);




static __inline__ void *__attribute__((__always_inline__, __nodebug__,
                                       __malloc__, __alloc_size__(1),
                                       __alloc_align__(2)))
_mm_malloc(size_t __size, size_t __align) {
  if (__align == 1) {
    return malloc(__size);
  }

  if (!(__align & (__align - 1)) && __align < sizeof(void *))
    __align = sizeof(void *);

  void *__mallocedMemory;





  if (posix_memalign(&__mallocedMemory, __align, __size))
    return 0;


  return __mallocedMemory;
}

static __inline__ void __attribute__((__always_inline__, __nodebug__))
_mm_free(void *__p)
{





  free(__p);

}
# 32 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 2 3
# 57 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_add_ss(__m128 __a, __m128 __b)
{
  __a[0] += __b[0];
  return __a;
}
# 77 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_add_ps(__m128 __a, __m128 __b)
{
  return (__m128)((__v4sf)__a + (__v4sf)__b);
}
# 99 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_sub_ss(__m128 __a, __m128 __b)
{
  __a[0] -= __b[0];
  return __a;
}
# 120 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_sub_ps(__m128 __a, __m128 __b)
{
  return (__m128)((__v4sf)__a - (__v4sf)__b);
}
# 142 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_mul_ss(__m128 __a, __m128 __b)
{
  __a[0] *= __b[0];
  return __a;
}
# 162 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_mul_ps(__m128 __a, __m128 __b)
{
  return (__m128)((__v4sf)__a * (__v4sf)__b);
}
# 184 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_div_ss(__m128 __a, __m128 __b)
{
  __a[0] /= __b[0];
  return __a;
}
# 203 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_div_ps(__m128 __a, __m128 __b)
{
  return (__m128)((__v4sf)__a / (__v4sf)__b);
}
# 221 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_sqrt_ss(__m128 __a)
{
  return (__m128)__builtin_ia32_sqrtss((__v4sf)__a);
}
# 238 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_sqrt_ps(__m128 __a)
{
  return __builtin_ia32_sqrtps((__v4sf)__a);
}
# 256 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_rcp_ss(__m128 __a)
{
  return (__m128)__builtin_ia32_rcpss((__v4sf)__a);
}
# 273 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_rcp_ps(__m128 __a)
{
  return (__m128)__builtin_ia32_rcpps((__v4sf)__a);
}
# 292 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_rsqrt_ss(__m128 __a)
{
  return __builtin_ia32_rsqrtss((__v4sf)__a);
}
# 309 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_rsqrt_ps(__m128 __a)
{
  return __builtin_ia32_rsqrtps((__v4sf)__a);
}
# 332 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_min_ss(__m128 __a, __m128 __b)
{
  return __builtin_ia32_minss((__v4sf)__a, (__v4sf)__b);
}
# 351 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_min_ps(__m128 __a, __m128 __b)
{
  return __builtin_ia32_minps((__v4sf)__a, (__v4sf)__b);
}
# 374 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_max_ss(__m128 __a, __m128 __b)
{
  return __builtin_ia32_maxss((__v4sf)__a, (__v4sf)__b);
}
# 393 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_max_ps(__m128 __a, __m128 __b)
{
  return __builtin_ia32_maxps((__v4sf)__a, (__v4sf)__b);
}
# 411 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_and_ps(__m128 __a, __m128 __b)
{
  return (__m128)((__v4su)__a & (__v4su)__b);
}
# 433 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_andnot_ps(__m128 __a, __m128 __b)
{
  return (__m128)(~(__v4su)__a & (__v4su)__b);
}
# 451 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_or_ps(__m128 __a, __m128 __b)
{
  return (__m128)((__v4su)__a | (__v4su)__b);
}
# 470 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_xor_ps(__m128 __a, __m128 __b)
{
  return (__m128)((__v4su)__a ^ (__v4su)__b);
}
# 492 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_cmpeq_ss(__m128 __a, __m128 __b)
{
  return (__m128)__builtin_ia32_cmpeqss((__v4sf)__a, (__v4sf)__b);
}
# 510 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_cmpeq_ps(__m128 __a, __m128 __b)
{
  return (__m128)__builtin_ia32_cmpeqps((__v4sf)__a, (__v4sf)__b);
}
# 533 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_cmplt_ss(__m128 __a, __m128 __b)
{
  return (__m128)__builtin_ia32_cmpltss((__v4sf)__a, (__v4sf)__b);
}
# 552 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_cmplt_ps(__m128 __a, __m128 __b)
{
  return (__m128)__builtin_ia32_cmpltps((__v4sf)__a, (__v4sf)__b);
}
# 576 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_cmple_ss(__m128 __a, __m128 __b)
{
  return (__m128)__builtin_ia32_cmpless((__v4sf)__a, (__v4sf)__b);
}
# 595 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_cmple_ps(__m128 __a, __m128 __b)
{
  return (__m128)__builtin_ia32_cmpleps((__v4sf)__a, (__v4sf)__b);
}
# 618 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_cmpgt_ss(__m128 __a, __m128 __b)
{
  return (__m128)__builtin_shufflevector((__v4sf)__a,
                                         (__v4sf)__builtin_ia32_cmpltss((__v4sf)__b, (__v4sf)__a),
                                         4, 1, 2, 3);
}
# 639 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_cmpgt_ps(__m128 __a, __m128 __b)
{
  return (__m128)__builtin_ia32_cmpltps((__v4sf)__b, (__v4sf)__a);
}
# 663 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_cmpge_ss(__m128 __a, __m128 __b)
{
  return (__m128)__builtin_shufflevector((__v4sf)__a,
                                         (__v4sf)__builtin_ia32_cmpless((__v4sf)__b, (__v4sf)__a),
                                         4, 1, 2, 3);
}
# 684 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_cmpge_ps(__m128 __a, __m128 __b)
{
  return (__m128)__builtin_ia32_cmpleps((__v4sf)__b, (__v4sf)__a);
}
# 707 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_cmpneq_ss(__m128 __a, __m128 __b)
{
  return (__m128)__builtin_ia32_cmpneqss((__v4sf)__a, (__v4sf)__b);
}
# 726 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_cmpneq_ps(__m128 __a, __m128 __b)
{
  return (__m128)__builtin_ia32_cmpneqps((__v4sf)__a, (__v4sf)__b);
}
# 750 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_cmpnlt_ss(__m128 __a, __m128 __b)
{
  return (__m128)__builtin_ia32_cmpnltss((__v4sf)__a, (__v4sf)__b);
}
# 770 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_cmpnlt_ps(__m128 __a, __m128 __b)
{
  return (__m128)__builtin_ia32_cmpnltps((__v4sf)__a, (__v4sf)__b);
}
# 795 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_cmpnle_ss(__m128 __a, __m128 __b)
{
  return (__m128)__builtin_ia32_cmpnless((__v4sf)__a, (__v4sf)__b);
}
# 815 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_cmpnle_ps(__m128 __a, __m128 __b)
{
  return (__m128)__builtin_ia32_cmpnleps((__v4sf)__a, (__v4sf)__b);
}
# 840 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_cmpngt_ss(__m128 __a, __m128 __b)
{
  return (__m128)__builtin_shufflevector((__v4sf)__a,
                                         (__v4sf)__builtin_ia32_cmpnltss((__v4sf)__b, (__v4sf)__a),
                                         4, 1, 2, 3);
}
# 862 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_cmpngt_ps(__m128 __a, __m128 __b)
{
  return (__m128)__builtin_ia32_cmpnltps((__v4sf)__b, (__v4sf)__a);
}
# 887 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_cmpnge_ss(__m128 __a, __m128 __b)
{
  return (__m128)__builtin_shufflevector((__v4sf)__a,
                                         (__v4sf)__builtin_ia32_cmpnless((__v4sf)__b, (__v4sf)__a),
                                         4, 1, 2, 3);
}
# 909 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_cmpnge_ps(__m128 __a, __m128 __b)
{
  return (__m128)__builtin_ia32_cmpnleps((__v4sf)__b, (__v4sf)__a);
}
# 934 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_cmpord_ss(__m128 __a, __m128 __b)
{
  return (__m128)__builtin_ia32_cmpordss((__v4sf)__a, (__v4sf)__b);
}
# 954 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_cmpord_ps(__m128 __a, __m128 __b)
{
  return (__m128)__builtin_ia32_cmpordps((__v4sf)__a, (__v4sf)__b);
}
# 979 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_cmpunord_ss(__m128 __a, __m128 __b)
{
  return (__m128)__builtin_ia32_cmpunordss((__v4sf)__a, (__v4sf)__b);
}
# 999 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_cmpunord_ps(__m128 __a, __m128 __b)
{
  return (__m128)__builtin_ia32_cmpunordps((__v4sf)__a, (__v4sf)__b);
}
# 1023 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ int __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_comieq_ss(__m128 __a, __m128 __b)
{
  return __builtin_ia32_comieq((__v4sf)__a, (__v4sf)__b);
}
# 1048 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ int __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_comilt_ss(__m128 __a, __m128 __b)
{
  return __builtin_ia32_comilt((__v4sf)__a, (__v4sf)__b);
}
# 1072 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ int __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_comile_ss(__m128 __a, __m128 __b)
{
  return __builtin_ia32_comile((__v4sf)__a, (__v4sf)__b);
}
# 1096 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ int __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_comigt_ss(__m128 __a, __m128 __b)
{
  return __builtin_ia32_comigt((__v4sf)__a, (__v4sf)__b);
}
# 1120 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ int __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_comige_ss(__m128 __a, __m128 __b)
{
  return __builtin_ia32_comige((__v4sf)__a, (__v4sf)__b);
}
# 1144 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ int __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_comineq_ss(__m128 __a, __m128 __b)
{
  return __builtin_ia32_comineq((__v4sf)__a, (__v4sf)__b);
}
# 1168 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ int __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_ucomieq_ss(__m128 __a, __m128 __b)
{
  return __builtin_ia32_ucomieq((__v4sf)__a, (__v4sf)__b);
}
# 1192 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ int __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_ucomilt_ss(__m128 __a, __m128 __b)
{
  return __builtin_ia32_ucomilt((__v4sf)__a, (__v4sf)__b);
}
# 1217 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ int __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_ucomile_ss(__m128 __a, __m128 __b)
{
  return __builtin_ia32_ucomile((__v4sf)__a, (__v4sf)__b);
}
# 1242 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ int __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_ucomigt_ss(__m128 __a, __m128 __b)
{
  return __builtin_ia32_ucomigt((__v4sf)__a, (__v4sf)__b);
}
# 1267 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ int __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_ucomige_ss(__m128 __a, __m128 __b)
{
  return __builtin_ia32_ucomige((__v4sf)__a, (__v4sf)__b);
}
# 1291 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ int __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_ucomineq_ss(__m128 __a, __m128 __b)
{
  return __builtin_ia32_ucomineq((__v4sf)__a, (__v4sf)__b);
}
# 1309 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ int __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_cvtss_si32(__m128 __a)
{
  return __builtin_ia32_cvtss2si((__v4sf)__a);
}
# 1327 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ int __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_cvt_ss2si(__m128 __a)
{
  return _mm_cvtss_si32(__a);
}
# 1347 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ long long __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_cvtss_si64(__m128 __a)
{
  return __builtin_ia32_cvtss2si64((__v4sf)__a);
}
# 1365 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,sse,no-evex512"), __min_vector_width__(64)))
_mm_cvtps_pi32(__m128 __a)
{
  return (__m64)__builtin_ia32_cvtps2pi((__v4sf)__a);
}
# 1381 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,sse,no-evex512"), __min_vector_width__(64)))
_mm_cvt_ps2pi(__m128 __a)
{
  return _mm_cvtps_pi32(__a);
}
# 1400 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ int __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_cvttss_si32(__m128 __a)
{
  return __builtin_ia32_cvttss2si((__v4sf)__a);
}
# 1419 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ int __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_cvtt_ss2si(__m128 __a)
{
  return _mm_cvttss_si32(__a);
}
# 1439 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ long long __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_cvttss_si64(__m128 __a)
{
  return __builtin_ia32_cvttss2si64((__v4sf)__a);
}
# 1458 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,sse,no-evex512"), __min_vector_width__(64)))
_mm_cvttps_pi32(__m128 __a)
{
  return (__m64)__builtin_ia32_cvttps2pi((__v4sf)__a);
}
# 1475 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,sse,no-evex512"), __min_vector_width__(64)))
_mm_cvtt_ps2pi(__m128 __a)
{
  return _mm_cvttps_pi32(__a);
}
# 1497 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_cvtsi32_ss(__m128 __a, int __b)
{
  __a[0] = __b;
  return __a;
}
# 1520 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_cvt_si2ss(__m128 __a, int __b)
{
  return _mm_cvtsi32_ss(__a, __b);
}
# 1544 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_cvtsi64_ss(__m128 __a, long long __b)
{
  __a[0] = __b;
  return __a;
}
# 1570 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("mmx,sse,no-evex512"), __min_vector_width__(64)))
_mm_cvtpi32_ps(__m128 __a, __m64 __b)
{
  return __builtin_ia32_cvtpi2ps((__v4sf)__a, (__v2si)__b);
}
# 1593 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("mmx,sse,no-evex512"), __min_vector_width__(64)))
_mm_cvt_pi2ps(__m128 __a, __m64 __b)
{
  return _mm_cvtpi32_ps(__a, __b);
}
# 1610 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ float __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_cvtss_f32(__m128 __a)
{
  return __a[0];
}
# 1631 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_loadh_pi(__m128 __a, const __m64 *__p)
{
  typedef float __mm_loadh_pi_v2f32 __attribute__((__vector_size__(8)));
  struct __mm_loadh_pi_struct {
    __mm_loadh_pi_v2f32 __u;
  } __attribute__((__packed__, __may_alias__));
  __mm_loadh_pi_v2f32 __b = ((const struct __mm_loadh_pi_struct*)__p)->__u;
  __m128 __bb = __builtin_shufflevector(__b, __b, 0, 1, 0, 1);
  return __builtin_shufflevector(__a, __bb, 0, 1, 4, 5);
}
# 1658 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_loadl_pi(__m128 __a, const __m64 *__p)
{
  typedef float __mm_loadl_pi_v2f32 __attribute__((__vector_size__(8)));
  struct __mm_loadl_pi_struct {
    __mm_loadl_pi_v2f32 __u;
  } __attribute__((__packed__, __may_alias__));
  __mm_loadl_pi_v2f32 __b = ((const struct __mm_loadl_pi_struct*)__p)->__u;
  __m128 __bb = __builtin_shufflevector(__b, __b, 0, 1, 0, 1);
  return __builtin_shufflevector(__a, __bb, 4, 5, 2, 3);
}
# 1685 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_load_ss(const float *__p)
{
  struct __mm_load_ss_struct {
    float __u;
  } __attribute__((__packed__, __may_alias__));
  float __u = ((const struct __mm_load_ss_struct*)__p)->__u;
  return __extension__ (__m128){ __u, 0, 0, 0 };
}
# 1707 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_load1_ps(const float *__p)
{
  struct __mm_load1_ps_struct {
    float __u;
  } __attribute__((__packed__, __may_alias__));
  float __u = ((const struct __mm_load1_ps_struct*)__p)->__u;
  return __extension__ (__m128){ __u, __u, __u, __u };
}
# 1730 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_load_ps(const float *__p)
{
  return *(const __m128*)__p;
}
# 1747 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_loadu_ps(const float *__p)
{
  struct __loadu_ps {
    __m128_u __v;
  } __attribute__((__packed__, __may_alias__));
  return ((const struct __loadu_ps*)__p)->__v;
}
# 1769 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_loadr_ps(const float *__p)
{
  __m128 __a = _mm_load_ps(__p);
  return __builtin_shufflevector((__v4sf)__a, (__v4sf)__a, 3, 2, 1, 0);
}
# 1783 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_undefined_ps(void)
{
  return (__m128)__builtin_ia32_undef128();
}
# 1803 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_set_ss(float __w)
{
  return __extension__ (__m128){ __w, 0, 0, 0 };
}
# 1821 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_set1_ps(float __w)
{
  return __extension__ (__m128){ __w, __w, __w, __w };
}
# 1840 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_set_ps1(float __w)
{
    return _mm_set1_ps(__w);
}
# 1867 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_set_ps(float __z, float __y, float __x, float __w)
{
  return __extension__ (__m128){ __w, __x, __y, __z };
}
# 1895 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_setr_ps(float __z, float __y, float __x, float __w)
{
  return __extension__ (__m128){ __z, __y, __x, __w };
}
# 1910 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_setzero_ps(void)
{
  return __extension__ (__m128){ 0.0f, 0.0f, 0.0f, 0.0f };
}
# 1927 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ void __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_storeh_pi(__m64 *__p, __m128 __a)
{
  typedef float __mm_storeh_pi_v2f32 __attribute__((__vector_size__(8)));
  struct __mm_storeh_pi_struct {
    __mm_storeh_pi_v2f32 __u;
  } __attribute__((__packed__, __may_alias__));
  ((struct __mm_storeh_pi_struct*)__p)->__u = __builtin_shufflevector(__a, __a, 2, 3);
}
# 1948 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ void __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_storel_pi(__m64 *__p, __m128 __a)
{
  typedef float __mm_storeh_pi_v2f32 __attribute__((__vector_size__(8)));
  struct __mm_storeh_pi_struct {
    __mm_storeh_pi_v2f32 __u;
  } __attribute__((__packed__, __may_alias__));
  ((struct __mm_storeh_pi_struct*)__p)->__u = __builtin_shufflevector(__a, __a, 0, 1);
}
# 1969 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ void __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_store_ss(float *__p, __m128 __a)
{
  struct __mm_store_ss_struct {
    float __u;
  } __attribute__((__packed__, __may_alias__));
  ((struct __mm_store_ss_struct*)__p)->__u = __a[0];
}
# 1990 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ void __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_storeu_ps(float *__p, __m128 __a)
{
  struct __storeu_ps {
    __m128_u __v;
  } __attribute__((__packed__, __may_alias__));
  ((struct __storeu_ps*)__p)->__v = __a;
}
# 2011 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ void __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_store_ps(float *__p, __m128 __a)
{
  *(__m128*)__p = __a;
}
# 2030 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ void __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_store1_ps(float *__p, __m128 __a)
{
  __a = __builtin_shufflevector((__v4sf)__a, (__v4sf)__a, 0, 0, 0, 0);
  _mm_store_ps(__p, __a);
}
# 2050 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ void __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_store_ps1(float *__p, __m128 __a)
{
  _mm_store1_ps(__p, __a);
}
# 2069 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ void __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_storer_ps(float *__p, __m128 __a)
{
  __a = __builtin_shufflevector((__v4sf)__a, (__v4sf)__a, 3, 2, 1, 0);
  _mm_store_ps(__p, __a);
}
# 2127 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ void __attribute__((__always_inline__, __nodebug__, __target__("mmx,sse,no-evex512"), __min_vector_width__(64)))
_mm_stream_pi(void *__p, __m64 __a)
{
  __builtin_ia32_movntq((__m64 *)__p, __a);
}
# 2146 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ void __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_stream_ps(void *__p, __m128 __a)
{
  __builtin_nontemporal_store((__v4sf)__a, (__v4sf*)__p);
}


extern "C" {
# 2165 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
void _mm_sfence(void);


}
# 2238 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,sse,no-evex512"), __min_vector_width__(64)))
_mm_max_pi16(__m64 __a, __m64 __b)
{
  return (__m64)__builtin_ia32_pmaxsw((__v4hi)__a, (__v4hi)__b);
}
# 2257 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,sse,no-evex512"), __min_vector_width__(64)))
_mm_max_pu8(__m64 __a, __m64 __b)
{
  return (__m64)__builtin_ia32_pmaxub((__v8qi)__a, (__v8qi)__b);
}
# 2276 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,sse,no-evex512"), __min_vector_width__(64)))
_mm_min_pi16(__m64 __a, __m64 __b)
{
  return (__m64)__builtin_ia32_pminsw((__v4hi)__a, (__v4hi)__b);
}
# 2295 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,sse,no-evex512"), __min_vector_width__(64)))
_mm_min_pu8(__m64 __a, __m64 __b)
{
  return (__m64)__builtin_ia32_pminub((__v8qi)__a, (__v8qi)__b);
}
# 2313 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ int __attribute__((__always_inline__, __nodebug__, __target__("mmx,sse,no-evex512"), __min_vector_width__(64)))
_mm_movemask_pi8(__m64 __a)
{
  return __builtin_ia32_pmovmskb((__v8qi)__a);
}
# 2332 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,sse,no-evex512"), __min_vector_width__(64)))
_mm_mulhi_pu16(__m64 __a, __m64 __b)
{
  return (__m64)__builtin_ia32_pmulhuw((__v4hi)__a, (__v4hi)__b);
}
# 2398 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ void __attribute__((__always_inline__, __nodebug__, __target__("mmx,sse,no-evex512"), __min_vector_width__(64)))
_mm_maskmove_si64(__m64 __d, __m64 __n, char *__p)
{
  __builtin_ia32_maskmovq((__v8qi)__d, (__v8qi)__n, __p);
}
# 2417 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,sse,no-evex512"), __min_vector_width__(64)))
_mm_avg_pu8(__m64 __a, __m64 __b)
{
  return (__m64)__builtin_ia32_pavgb((__v8qi)__a, (__v8qi)__b);
}
# 2436 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,sse,no-evex512"), __min_vector_width__(64)))
_mm_avg_pu16(__m64 __a, __m64 __b)
{
  return (__m64)__builtin_ia32_pavgw((__v4hi)__a, (__v4hi)__b);
}
# 2458 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,sse,no-evex512"), __min_vector_width__(64)))
_mm_sad_pu8(__m64 __a, __m64 __b)
{
  return (__m64)__builtin_ia32_psadbw((__v8qi)__a, (__v8qi)__b);
}


extern "C" {
# 2518 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
unsigned int _mm_getcsr(void);
# 2572 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
void _mm_setcsr(unsigned int __i);


}
# 2637 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_unpackhi_ps(__m128 __a, __m128 __b)
{
  return __builtin_shufflevector((__v4sf)__a, (__v4sf)__b, 2, 6, 3, 7);
}
# 2659 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_unpacklo_ps(__m128 __a, __m128 __b)
{
  return __builtin_shufflevector((__v4sf)__a, (__v4sf)__b, 0, 4, 1, 5);
}
# 2681 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_move_ss(__m128 __a, __m128 __b)
{
  __a[0] = __b[0];
  return __a;
}
# 2703 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_movehl_ps(__m128 __a, __m128 __b)
{
  return __builtin_shufflevector((__v4sf)__a, (__v4sf)__b, 6, 7, 2, 3);
}
# 2724 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_movelh_ps(__m128 __a, __m128 __b)
{
  return __builtin_shufflevector((__v4sf)__a, (__v4sf)__b, 0, 1, 4, 5);
}
# 2742 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("mmx,sse,no-evex512"), __min_vector_width__(64)))
_mm_cvtpi16_ps(__m64 __a)
{
  __m64 __b, __c;
  __m128 __r;

  __b = _mm_setzero_si64();
  __b = _mm_cmpgt_pi16(__b, __a);
  __c = _mm_unpackhi_pi16(__a, __b);
  __r = _mm_setzero_ps();
  __r = _mm_cvtpi32_ps(__r, __c);
  __r = _mm_movelh_ps(__r, __r);
  __c = _mm_unpacklo_pi16(__a, __b);
  __r = _mm_cvtpi32_ps(__r, __c);

  return __r;
}
# 2772 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("mmx,sse,no-evex512"), __min_vector_width__(64)))
_mm_cvtpu16_ps(__m64 __a)
{
  __m64 __b, __c;
  __m128 __r;

  __b = _mm_setzero_si64();
  __c = _mm_unpackhi_pi16(__a, __b);
  __r = _mm_setzero_ps();
  __r = _mm_cvtpi32_ps(__r, __c);
  __r = _mm_movelh_ps(__r, __r);
  __c = _mm_unpacklo_pi16(__a, __b);
  __r = _mm_cvtpi32_ps(__r, __c);

  return __r;
}
# 2801 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("mmx,sse,no-evex512"), __min_vector_width__(64)))
_mm_cvtpi8_ps(__m64 __a)
{
  __m64 __b;

  __b = _mm_setzero_si64();
  __b = _mm_cmpgt_pi8(__b, __a);
  __b = _mm_unpacklo_pi8(__a, __b);

  return _mm_cvtpi16_ps(__b);
}
# 2826 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("mmx,sse,no-evex512"), __min_vector_width__(64)))
_mm_cvtpu8_ps(__m64 __a)
{
  __m64 __b;

  __b = _mm_setzero_si64();
  __b = _mm_unpacklo_pi8(__a, __b);

  return _mm_cvtpi16_ps(__b);
}
# 2853 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("mmx,sse,no-evex512"), __min_vector_width__(64)))
_mm_cvtpi32x2_ps(__m64 __a, __m64 __b)
{
  __m128 __c;

  __c = _mm_setzero_ps();
  __c = _mm_cvtpi32_ps(__c, __b);
  __c = _mm_movelh_ps(__c, __c);

  return _mm_cvtpi32_ps(__c, __a);
}
# 2882 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,sse,no-evex512"), __min_vector_width__(64)))
_mm_cvtps_pi16(__m128 __a)
{
  __m64 __b, __c;

  __b = _mm_cvtps_pi32(__a);
  __a = _mm_movehl_ps(__a, __a);
  __c = _mm_cvtps_pi32(__a);

  return _mm_packs_pi32(__b, __c);
}
# 2912 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,sse,no-evex512"), __min_vector_width__(64)))
_mm_cvtps_pi8(__m128 __a)
{
  __m64 __b, __c;

  __b = _mm_cvtps_pi16(__a);
  __c = _mm_setzero_si64();

  return _mm_packs_pi16(__b, __c);
}
# 2937 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
static __inline__ int __attribute__((__always_inline__, __nodebug__, __target__("sse,no-evex512"), __min_vector_width__(128)))
_mm_movemask_ps(__m128 __a)
{
  return __builtin_ia32_movmskps((__v4sf)__a);
}
# 3018 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 3
# 1 "/usr/bin/../lib/clang/18/include/emmintrin.h" 1 3
# 17 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
# 1 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 1 3
# 18 "/usr/bin/../lib/clang/18/include/emmintrin.h" 2 3

typedef double __m128d __attribute__((__vector_size__(16), __aligned__(16)));
typedef long long __m128i __attribute__((__vector_size__(16), __aligned__(16)));

typedef double __m128d_u __attribute__((__vector_size__(16), __aligned__(1)));
typedef long long __m128i_u
    __attribute__((__vector_size__(16), __aligned__(1)));


typedef double __v2df __attribute__((__vector_size__(16)));
typedef long long __v2di __attribute__((__vector_size__(16)));
typedef short __v8hi __attribute__((__vector_size__(16)));
typedef char __v16qi __attribute__((__vector_size__(16)));


typedef unsigned long long __v2du __attribute__((__vector_size__(16)));
typedef unsigned short __v8hu __attribute__((__vector_size__(16)));
typedef unsigned char __v16qu __attribute__((__vector_size__(16)));



typedef signed char __v16qs __attribute__((__vector_size__(16)));



typedef _Float16 __v8hf __attribute__((__vector_size__(16), __aligned__(16)));
typedef _Float16 __m128h __attribute__((__vector_size__(16), __aligned__(16)));
typedef _Float16 __m128h_u __attribute__((__vector_size__(16), __aligned__(1)));

typedef __bf16 __v8bf __attribute__((__vector_size__(16), __aligned__(16)));
typedef __bf16 __m128bh __attribute__((__vector_size__(16), __aligned__(16)));
# 74 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_add_sd(__m128d __a,
                                                        __m128d __b) {
  __a[0] += __b[0];
  return __a;
}
# 92 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_add_pd(__m128d __a,
                                                        __m128d __b) {
  return (__m128d)((__v2df)__a + (__v2df)__b);
}
# 114 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_sub_sd(__m128d __a,
                                                        __m128d __b) {
  __a[0] -= __b[0];
  return __a;
}
# 132 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_sub_pd(__m128d __a,
                                                        __m128d __b) {
  return (__m128d)((__v2df)__a - (__v2df)__b);
}
# 153 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_mul_sd(__m128d __a,
                                                        __m128d __b) {
  __a[0] *= __b[0];
  return __a;
}
# 171 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_mul_pd(__m128d __a,
                                                        __m128d __b) {
  return (__m128d)((__v2df)__a * (__v2df)__b);
}
# 193 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_div_sd(__m128d __a,
                                                        __m128d __b) {
  __a[0] /= __b[0];
  return __a;
}
# 212 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_div_pd(__m128d __a,
                                                        __m128d __b) {
  return (__m128d)((__v2df)__a / (__v2df)__b);
}
# 236 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_sqrt_sd(__m128d __a,
                                                         __m128d __b) {
  __m128d __c = __builtin_ia32_sqrtsd((__v2df)__b);
  return __extension__(__m128d){__c[0], __a[1]};
}
# 253 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_sqrt_pd(__m128d __a) {
  return __builtin_ia32_sqrtpd((__v2df)__a);
}
# 275 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_min_sd(__m128d __a,
                                                        __m128d __b) {
  return __builtin_ia32_minsd((__v2df)__a, (__v2df)__b);
}
# 294 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_min_pd(__m128d __a,
                                                        __m128d __b) {
  return __builtin_ia32_minpd((__v2df)__a, (__v2df)__b);
}
# 317 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_max_sd(__m128d __a,
                                                        __m128d __b) {
  return __builtin_ia32_maxsd((__v2df)__a, (__v2df)__b);
}
# 336 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_max_pd(__m128d __a,
                                                        __m128d __b) {
  return __builtin_ia32_maxpd((__v2df)__a, (__v2df)__b);
}
# 353 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_and_pd(__m128d __a,
                                                        __m128d __b) {
  return (__m128d)((__v2du)__a & (__v2du)__b);
}
# 373 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_andnot_pd(__m128d __a,
                                                           __m128d __b) {
  return (__m128d)(~(__v2du)__a & (__v2du)__b);
}
# 390 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_or_pd(__m128d __a,
                                                       __m128d __b) {
  return (__m128d)((__v2du)__a | (__v2du)__b);
}
# 407 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_xor_pd(__m128d __a,
                                                        __m128d __b) {
  return (__m128d)((__v2du)__a ^ (__v2du)__b);
}
# 425 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cmpeq_pd(__m128d __a,
                                                          __m128d __b) {
  return (__m128d)__builtin_ia32_cmpeqpd((__v2df)__a, (__v2df)__b);
}
# 444 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cmplt_pd(__m128d __a,
                                                          __m128d __b) {
  return (__m128d)__builtin_ia32_cmpltpd((__v2df)__a, (__v2df)__b);
}
# 464 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cmple_pd(__m128d __a,
                                                          __m128d __b) {
  return (__m128d)__builtin_ia32_cmplepd((__v2df)__a, (__v2df)__b);
}
# 484 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cmpgt_pd(__m128d __a,
                                                          __m128d __b) {
  return (__m128d)__builtin_ia32_cmpltpd((__v2df)__b, (__v2df)__a);
}
# 504 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cmpge_pd(__m128d __a,
                                                          __m128d __b) {
  return (__m128d)__builtin_ia32_cmplepd((__v2df)__b, (__v2df)__a);
}
# 526 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cmpord_pd(__m128d __a,
                                                           __m128d __b) {
  return (__m128d)__builtin_ia32_cmpordpd((__v2df)__a, (__v2df)__b);
}
# 549 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cmpunord_pd(__m128d __a,
                                                             __m128d __b) {
  return (__m128d)__builtin_ia32_cmpunordpd((__v2df)__a, (__v2df)__b);
}
# 569 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cmpneq_pd(__m128d __a,
                                                           __m128d __b) {
  return (__m128d)__builtin_ia32_cmpneqpd((__v2df)__a, (__v2df)__b);
}
# 589 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cmpnlt_pd(__m128d __a,
                                                           __m128d __b) {
  return (__m128d)__builtin_ia32_cmpnltpd((__v2df)__a, (__v2df)__b);
}
# 609 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cmpnle_pd(__m128d __a,
                                                           __m128d __b) {
  return (__m128d)__builtin_ia32_cmpnlepd((__v2df)__a, (__v2df)__b);
}
# 629 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cmpngt_pd(__m128d __a,
                                                           __m128d __b) {
  return (__m128d)__builtin_ia32_cmpnltpd((__v2df)__b, (__v2df)__a);
}
# 649 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cmpnge_pd(__m128d __a,
                                                           __m128d __b) {
  return (__m128d)__builtin_ia32_cmpnlepd((__v2df)__b, (__v2df)__a);
}
# 671 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cmpeq_sd(__m128d __a,
                                                          __m128d __b) {
  return (__m128d)__builtin_ia32_cmpeqsd((__v2df)__a, (__v2df)__b);
}
# 695 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cmplt_sd(__m128d __a,
                                                          __m128d __b) {
  return (__m128d)__builtin_ia32_cmpltsd((__v2df)__a, (__v2df)__b);
}
# 719 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cmple_sd(__m128d __a,
                                                          __m128d __b) {
  return (__m128d)__builtin_ia32_cmplesd((__v2df)__a, (__v2df)__b);
}
# 743 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cmpgt_sd(__m128d __a,
                                                          __m128d __b) {
  __m128d __c = __builtin_ia32_cmpltsd((__v2df)__b, (__v2df)__a);
  return __extension__(__m128d){__c[0], __a[1]};
}
# 768 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cmpge_sd(__m128d __a,
                                                          __m128d __b) {
  __m128d __c = __builtin_ia32_cmplesd((__v2df)__b, (__v2df)__a);
  return __extension__(__m128d){__c[0], __a[1]};
}
# 795 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cmpord_sd(__m128d __a,
                                                           __m128d __b) {
  return (__m128d)__builtin_ia32_cmpordsd((__v2df)__a, (__v2df)__b);
}
# 822 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cmpunord_sd(__m128d __a,
                                                             __m128d __b) {
  return (__m128d)__builtin_ia32_cmpunordsd((__v2df)__a, (__v2df)__b);
}
# 846 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cmpneq_sd(__m128d __a,
                                                           __m128d __b) {
  return (__m128d)__builtin_ia32_cmpneqsd((__v2df)__a, (__v2df)__b);
}
# 870 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cmpnlt_sd(__m128d __a,
                                                           __m128d __b) {
  return (__m128d)__builtin_ia32_cmpnltsd((__v2df)__a, (__v2df)__b);
}
# 894 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cmpnle_sd(__m128d __a,
                                                           __m128d __b) {
  return (__m128d)__builtin_ia32_cmpnlesd((__v2df)__a, (__v2df)__b);
}
# 918 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cmpngt_sd(__m128d __a,
                                                           __m128d __b) {
  __m128d __c = __builtin_ia32_cmpnltsd((__v2df)__b, (__v2df)__a);
  return __extension__(__m128d){__c[0], __a[1]};
}
# 943 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cmpnge_sd(__m128d __a,
                                                           __m128d __b) {
  __m128d __c = __builtin_ia32_cmpnlesd((__v2df)__b, (__v2df)__a);
  return __extension__(__m128d){__c[0], __a[1]};
}
# 967 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ int __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_comieq_sd(__m128d __a,
                                                       __m128d __b) {
  return __builtin_ia32_comisdeq((__v2df)__a, (__v2df)__b);
}
# 992 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ int __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_comilt_sd(__m128d __a,
                                                       __m128d __b) {
  return __builtin_ia32_comisdlt((__v2df)__a, (__v2df)__b);
}
# 1017 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ int __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_comile_sd(__m128d __a,
                                                       __m128d __b) {
  return __builtin_ia32_comisdle((__v2df)__a, (__v2df)__b);
}
# 1042 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ int __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_comigt_sd(__m128d __a,
                                                       __m128d __b) {
  return __builtin_ia32_comisdgt((__v2df)__a, (__v2df)__b);
}
# 1067 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ int __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_comige_sd(__m128d __a,
                                                       __m128d __b) {
  return __builtin_ia32_comisdge((__v2df)__a, (__v2df)__b);
}
# 1092 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ int __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_comineq_sd(__m128d __a,
                                                        __m128d __b) {
  return __builtin_ia32_comisdneq((__v2df)__a, (__v2df)__b);
}
# 1115 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ int __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_ucomieq_sd(__m128d __a,
                                                        __m128d __b) {
  return __builtin_ia32_ucomisdeq((__v2df)__a, (__v2df)__b);
}
# 1140 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ int __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_ucomilt_sd(__m128d __a,
                                                        __m128d __b) {
  return __builtin_ia32_ucomisdlt((__v2df)__a, (__v2df)__b);
}
# 1165 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ int __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_ucomile_sd(__m128d __a,
                                                        __m128d __b) {
  return __builtin_ia32_ucomisdle((__v2df)__a, (__v2df)__b);
}
# 1190 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ int __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_ucomigt_sd(__m128d __a,
                                                        __m128d __b) {
  return __builtin_ia32_ucomisdgt((__v2df)__a, (__v2df)__b);
}
# 1215 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ int __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_ucomige_sd(__m128d __a,
                                                        __m128d __b) {
  return __builtin_ia32_ucomisdge((__v2df)__a, (__v2df)__b);
}
# 1240 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ int __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_ucomineq_sd(__m128d __a,
                                                         __m128d __b) {
  return __builtin_ia32_ucomisdneq((__v2df)__a, (__v2df)__b);
}
# 1258 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cvtpd_ps(__m128d __a) {
  return __builtin_ia32_cvtpd2ps((__v2df)__a);
}
# 1276 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cvtps_pd(__m128 __a) {
  return (__m128d) __builtin_convertvector(
      __builtin_shufflevector((__v4sf)__a, (__v4sf)__a, 0, 1), __v2df);
}
# 1297 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cvtepi32_pd(__m128i __a) {
  return (__m128d) __builtin_convertvector(
      __builtin_shufflevector((__v4si)__a, (__v4si)__a, 0, 1), __v2df);
}
# 1315 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cvtpd_epi32(__m128d __a) {
  return __builtin_ia32_cvtpd2dq((__v2df)__a);
}
# 1330 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ int __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cvtsd_si32(__m128d __a) {
  return __builtin_ia32_cvtsd2si((__v2df)__a);
}
# 1353 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cvtsd_ss(__m128 __a,
                                                         __m128d __b) {
  return (__m128)__builtin_ia32_cvtsd2ss((__v4sf)__a, (__v2df)__b);
}
# 1375 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cvtsi32_sd(__m128d __a,
                                                            int __b) {
  __a[0] = __b;
  return __a;
}
# 1400 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cvtss_sd(__m128d __a,
                                                          __m128 __b) {
  __a[0] = __b[0];
  return __a;
}
# 1423 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cvttpd_epi32(__m128d __a) {
  return (__m128i)__builtin_ia32_cvttpd2dq((__v2df)__a);
}
# 1439 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ int __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cvttsd_si32(__m128d __a) {
  return __builtin_ia32_cvttsd2si((__v2df)__a);
}
# 1454 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,sse2,no-evex512"), __min_vector_width__(64))) _mm_cvtpd_pi32(__m128d __a) {
  return (__m64)__builtin_ia32_cvtpd2pi((__v2df)__a);
}
# 1472 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,sse2,no-evex512"), __min_vector_width__(64))) _mm_cvttpd_pi32(__m128d __a) {
  return (__m64)__builtin_ia32_cvttpd2pi((__v2df)__a);
}
# 1487 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("mmx,sse2,no-evex512"), __min_vector_width__(64))) _mm_cvtpi32_pd(__m64 __a) {
  return __builtin_ia32_cvtpi2pd((__v2si)__a);
}
# 1502 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ double __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cvtsd_f64(__m128d __a) {
  return __a[0];
}
# 1517 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_load_pd(double const *__dp) {
  return *(const __m128d *)__dp;
}
# 1533 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_load1_pd(double const *__dp) {
  struct __mm_load1_pd_struct {
    double __u;
  } __attribute__((__packed__, __may_alias__));
  double __u = ((const struct __mm_load1_pd_struct *)__dp)->__u;
  return __extension__(__m128d){__u, __u};
}
# 1557 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_loadr_pd(double const *__dp) {
  __m128d __u = *(const __m128d *)__dp;
  return __builtin_shufflevector((__v2df)__u, (__v2df)__u, 1, 0);
}
# 1573 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_loadu_pd(double const *__dp) {
  struct __loadu_pd {
    __m128d_u __v;
  } __attribute__((__packed__, __may_alias__));
  return ((const struct __loadu_pd *)__dp)->__v;
}
# 1591 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_loadu_si64(void const *__a) {
  struct __loadu_si64 {
    long long __v;
  } __attribute__((__packed__, __may_alias__));
  long long __u = ((const struct __loadu_si64 *)__a)->__v;
  return __extension__(__m128i)(__v2di){__u, 0LL};
}
# 1610 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_loadu_si32(void const *__a) {
  struct __loadu_si32 {
    int __v;
  } __attribute__((__packed__, __may_alias__));
  int __u = ((const struct __loadu_si32 *)__a)->__v;
  return __extension__(__m128i)(__v4si){__u, 0, 0, 0};
}
# 1629 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_loadu_si16(void const *__a) {
  struct __loadu_si16 {
    short __v;
  } __attribute__((__packed__, __may_alias__));
  short __u = ((const struct __loadu_si16 *)__a)->__v;
  return __extension__(__m128i)(__v8hi){__u, 0, 0, 0, 0, 0, 0, 0};
}
# 1648 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_load_sd(double const *__dp) {
  struct __mm_load_sd_struct {
    double __u;
  } __attribute__((__packed__, __may_alias__));
  double __u = ((const struct __mm_load_sd_struct *)__dp)->__u;
  return __extension__(__m128d){__u, 0};
}
# 1673 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_loadh_pd(__m128d __a,
                                                          double const *__dp) {
  struct __mm_loadh_pd_struct {
    double __u;
  } __attribute__((__packed__, __may_alias__));
  double __u = ((const struct __mm_loadh_pd_struct *)__dp)->__u;
  return __extension__(__m128d){__a[0], __u};
}
# 1699 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_loadl_pd(__m128d __a,
                                                          double const *__dp) {
  struct __mm_loadl_pd_struct {
    double __u;
  } __attribute__((__packed__, __may_alias__));
  double __u = ((const struct __mm_loadl_pd_struct *)__dp)->__u;
  return __extension__(__m128d){__u, __a[1]};
}
# 1719 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_undefined_pd(void) {
  return (__m128d)__builtin_ia32_undef128();
}
# 1737 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_set_sd(double __w) {
  return __extension__(__m128d){__w, 0};
}
# 1753 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_set1_pd(double __w) {
  return __extension__(__m128d){__w, __w};
}
# 1769 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_set_pd1(double __w) {
  return _mm_set1_pd(__w);
}
# 1787 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_set_pd(double __w,
                                                        double __x) {
  return __extension__(__m128d){__x, __w};
}
# 1807 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_setr_pd(double __w,
                                                         double __x) {
  return __extension__(__m128d){__w, __x};
}
# 1821 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_setzero_pd(void) {
  return __extension__(__m128d){0.0, 0.0};
}
# 1840 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_move_sd(__m128d __a,
                                                         __m128d __b) {
  __a[0] = __b[0];
  return __a;
}
# 1857 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ void __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_store_sd(double *__dp,
                                                       __m128d __a) {
  struct __mm_store_sd_struct {
    double __u;
  } __attribute__((__packed__, __may_alias__));
  ((struct __mm_store_sd_struct *)__dp)->__u = __a[0];
}
# 1878 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ void __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_store_pd(double *__dp,
                                                       __m128d __a) {
  *(__m128d *)__dp = __a;
}
# 1897 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ void __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_store1_pd(double *__dp,
                                                        __m128d __a) {
  __a = __builtin_shufflevector((__v2df)__a, (__v2df)__a, 0, 0);
  _mm_store_pd(__dp, __a);
}
# 1917 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ void __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_store_pd1(double *__dp,
                                                        __m128d __a) {
  _mm_store1_pd(__dp, __a);
}
# 1934 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ void __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_storeu_pd(double *__dp,
                                                        __m128d __a) {
  struct __storeu_pd {
    __m128d_u __v;
  } __attribute__((__packed__, __may_alias__));
  ((struct __storeu_pd *)__dp)->__v = __a;
}
# 1956 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ void __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_storer_pd(double *__dp,
                                                        __m128d __a) {
  __a = __builtin_shufflevector((__v2df)__a, (__v2df)__a, 1, 0);
  *(__m128d *)__dp = __a;
}
# 1973 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ void __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_storeh_pd(double *__dp,
                                                        __m128d __a) {
  struct __mm_storeh_pd_struct {
    double __u;
  } __attribute__((__packed__, __may_alias__));
  ((struct __mm_storeh_pd_struct *)__dp)->__u = __a[1];
}
# 1992 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ void __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_storel_pd(double *__dp,
                                                        __m128d __a) {
  struct __mm_storeh_pd_struct {
    double __u;
  } __attribute__((__packed__, __may_alias__));
  ((struct __mm_storeh_pd_struct *)__dp)->__u = __a[0];
}
# 2016 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_add_epi8(__m128i __a,
                                                          __m128i __b) {
  return (__m128i)((__v16qu)__a + (__v16qu)__b);
}
# 2037 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_add_epi16(__m128i __a,
                                                           __m128i __b) {
  return (__m128i)((__v8hu)__a + (__v8hu)__b);
}
# 2058 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_add_epi32(__m128i __a,
                                                           __m128i __b) {
  return (__m128i)((__v4su)__a + (__v4su)__b);
}
# 2075 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,sse2,no-evex512"), __min_vector_width__(64))) _mm_add_si64(__m64 __a,
                                                            __m64 __b) {
  return (__m64)__builtin_ia32_paddq((__v1di)__a, (__v1di)__b);
}
# 2096 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_add_epi64(__m128i __a,
                                                           __m128i __b) {
  return (__m128i)((__v2du)__a + (__v2du)__b);
}
# 2116 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_adds_epi8(__m128i __a,
                                                           __m128i __b) {
  return (__m128i)__builtin_elementwise_add_sat((__v16qs)__a, (__v16qs)__b);
}
# 2137 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_adds_epi16(__m128i __a,
                                                            __m128i __b) {
  return (__m128i)__builtin_elementwise_add_sat((__v8hi)__a, (__v8hi)__b);
}
# 2157 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_adds_epu8(__m128i __a,
                                                           __m128i __b) {
  return (__m128i)__builtin_elementwise_add_sat((__v16qu)__a, (__v16qu)__b);
}
# 2177 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_adds_epu16(__m128i __a,
                                                            __m128i __b) {
  return (__m128i)__builtin_elementwise_add_sat((__v8hu)__a, (__v8hu)__b);
}
# 2196 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_avg_epu8(__m128i __a,
                                                          __m128i __b) {
  return (__m128i)__builtin_ia32_pavgb128((__v16qi)__a, (__v16qi)__b);
}
# 2215 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_avg_epu16(__m128i __a,
                                                           __m128i __b) {
  return (__m128i)__builtin_ia32_pavgw128((__v8hi)__a, (__v8hi)__b);
}
# 2240 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_madd_epi16(__m128i __a,
                                                            __m128i __b) {
  return (__m128i)__builtin_ia32_pmaddwd128((__v8hi)__a, (__v8hi)__b);
}
# 2259 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_max_epi16(__m128i __a,
                                                           __m128i __b) {
  return (__m128i)__builtin_elementwise_max((__v8hi)__a, (__v8hi)__b);
}
# 2278 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_max_epu8(__m128i __a,
                                                          __m128i __b) {
  return (__m128i)__builtin_elementwise_max((__v16qu)__a, (__v16qu)__b);
}
# 2297 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_min_epi16(__m128i __a,
                                                           __m128i __b) {
  return (__m128i)__builtin_elementwise_min((__v8hi)__a, (__v8hi)__b);
}
# 2316 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_min_epu8(__m128i __a,
                                                          __m128i __b) {
  return (__m128i)__builtin_elementwise_min((__v16qu)__a, (__v16qu)__b);
}
# 2335 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_mulhi_epi16(__m128i __a,
                                                             __m128i __b) {
  return (__m128i)__builtin_ia32_pmulhw128((__v8hi)__a, (__v8hi)__b);
}
# 2354 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_mulhi_epu16(__m128i __a,
                                                             __m128i __b) {
  return (__m128i)__builtin_ia32_pmulhuw128((__v8hi)__a, (__v8hi)__b);
}
# 2373 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_mullo_epi16(__m128i __a,
                                                             __m128i __b) {
  return (__m128i)((__v8hu)__a * (__v8hu)__b);
}
# 2391 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,sse2,no-evex512"), __min_vector_width__(64))) _mm_mul_su32(__m64 __a,
                                                            __m64 __b) {
  return __builtin_ia32_pmuludq((__v2si)__a, (__v2si)__b);
}
# 2409 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_mul_epu32(__m128i __a,
                                                           __m128i __b) {
  return __builtin_ia32_pmuludq128((__v4si)__a, (__v4si)__b);
}
# 2430 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_sad_epu8(__m128i __a,
                                                          __m128i __b) {
  return __builtin_ia32_psadbw128((__v16qi)__a, (__v16qi)__b);
}
# 2447 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_sub_epi8(__m128i __a,
                                                          __m128i __b) {
  return (__m128i)((__v16qu)__a - (__v16qu)__b);
}
# 2464 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_sub_epi16(__m128i __a,
                                                           __m128i __b) {
  return (__m128i)((__v8hu)__a - (__v8hu)__b);
}
# 2481 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_sub_epi32(__m128i __a,
                                                           __m128i __b) {
  return (__m128i)((__v4su)__a - (__v4su)__b);
}
# 2499 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("mmx,sse2,no-evex512"), __min_vector_width__(64))) _mm_sub_si64(__m64 __a,
                                                            __m64 __b) {
  return (__m64)__builtin_ia32_psubq((__v1di)__a, (__v1di)__b);
}
# 2516 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_sub_epi64(__m128i __a,
                                                           __m128i __b) {
  return (__m128i)((__v2du)__a - (__v2du)__b);
}
# 2536 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_subs_epi8(__m128i __a,
                                                           __m128i __b) {
  return (__m128i)__builtin_elementwise_sub_sat((__v16qs)__a, (__v16qs)__b);
}
# 2556 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_subs_epi16(__m128i __a,
                                                            __m128i __b) {
  return (__m128i)__builtin_elementwise_sub_sat((__v8hi)__a, (__v8hi)__b);
}
# 2575 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_subs_epu8(__m128i __a,
                                                           __m128i __b) {
  return (__m128i)__builtin_elementwise_sub_sat((__v16qu)__a, (__v16qu)__b);
}
# 2594 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_subs_epu16(__m128i __a,
                                                            __m128i __b) {
  return (__m128i)__builtin_elementwise_sub_sat((__v8hu)__a, (__v8hu)__b);
}
# 2611 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_and_si128(__m128i __a,
                                                           __m128i __b) {
  return (__m128i)((__v2du)__a & (__v2du)__b);
}
# 2630 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_andnot_si128(__m128i __a,
                                                              __m128i __b) {
  return (__m128i)(~(__v2du)__a & (__v2du)__b);
}
# 2646 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_or_si128(__m128i __a,
                                                          __m128i __b) {
  return (__m128i)((__v2du)__a | (__v2du)__b);
}
# 2663 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_xor_si128(__m128i __a,
                                                           __m128i __b) {
  return (__m128i)((__v2du)__a ^ (__v2du)__b);
}
# 2706 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_slli_epi16(__m128i __a,
                                                            int __count) {
  return (__m128i)__builtin_ia32_psllwi128((__v8hi)__a, __count);
}
# 2724 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_sll_epi16(__m128i __a,
                                                           __m128i __count) {
  return (__m128i)__builtin_ia32_psllw128((__v8hi)__a, (__v8hi)__count);
}
# 2742 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_slli_epi32(__m128i __a,
                                                            int __count) {
  return (__m128i)__builtin_ia32_pslldi128((__v4si)__a, __count);
}
# 2760 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_sll_epi32(__m128i __a,
                                                           __m128i __count) {
  return (__m128i)__builtin_ia32_pslld128((__v4si)__a, (__v4si)__count);
}
# 2778 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_slli_epi64(__m128i __a,
                                                            int __count) {
  return __builtin_ia32_psllqi128((__v2di)__a, __count);
}
# 2796 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_sll_epi64(__m128i __a,
                                                           __m128i __count) {
  return __builtin_ia32_psllq128((__v2di)__a, (__v2di)__count);
}
# 2815 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_srai_epi16(__m128i __a,
                                                            int __count) {
  return (__m128i)__builtin_ia32_psrawi128((__v8hi)__a, __count);
}
# 2834 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_sra_epi16(__m128i __a,
                                                           __m128i __count) {
  return (__m128i)__builtin_ia32_psraw128((__v8hi)__a, (__v8hi)__count);
}
# 2853 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_srai_epi32(__m128i __a,
                                                            int __count) {
  return (__m128i)__builtin_ia32_psradi128((__v4si)__a, __count);
}
# 2872 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_sra_epi32(__m128i __a,
                                                           __m128i __count) {
  return (__m128i)__builtin_ia32_psrad128((__v4si)__a, (__v4si)__count);
}
# 2915 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_srli_epi16(__m128i __a,
                                                            int __count) {
  return (__m128i)__builtin_ia32_psrlwi128((__v8hi)__a, __count);
}
# 2933 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_srl_epi16(__m128i __a,
                                                           __m128i __count) {
  return (__m128i)__builtin_ia32_psrlw128((__v8hi)__a, (__v8hi)__count);
}
# 2951 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_srli_epi32(__m128i __a,
                                                            int __count) {
  return (__m128i)__builtin_ia32_psrldi128((__v4si)__a, __count);
}
# 2969 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_srl_epi32(__m128i __a,
                                                           __m128i __count) {
  return (__m128i)__builtin_ia32_psrld128((__v4si)__a, (__v4si)__count);
}
# 2987 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_srli_epi64(__m128i __a,
                                                            int __count) {
  return __builtin_ia32_psrlqi128((__v2di)__a, __count);
}
# 3005 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_srl_epi64(__m128i __a,
                                                           __m128i __count) {
  return __builtin_ia32_psrlq128((__v2di)__a, (__v2di)__count);
}
# 3023 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cmpeq_epi8(__m128i __a,
                                                            __m128i __b) {
  return (__m128i)((__v16qi)__a == (__v16qi)__b);
}
# 3041 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cmpeq_epi16(__m128i __a,
                                                             __m128i __b) {
  return (__m128i)((__v8hi)__a == (__v8hi)__b);
}
# 3059 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cmpeq_epi32(__m128i __a,
                                                             __m128i __b) {
  return (__m128i)((__v4si)__a == (__v4si)__b);
}
# 3078 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cmpgt_epi8(__m128i __a,
                                                            __m128i __b) {


  return (__m128i)((__v16qs)__a > (__v16qs)__b);
}
# 3100 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cmpgt_epi16(__m128i __a,
                                                             __m128i __b) {
  return (__m128i)((__v8hi)__a > (__v8hi)__b);
}
# 3120 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cmpgt_epi32(__m128i __a,
                                                             __m128i __b) {
  return (__m128i)((__v4si)__a > (__v4si)__b);
}
# 3140 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cmplt_epi8(__m128i __a,
                                                            __m128i __b) {
  return _mm_cmpgt_epi8(__b, __a);
}
# 3160 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cmplt_epi16(__m128i __a,
                                                             __m128i __b) {
  return _mm_cmpgt_epi16(__b, __a);
}
# 3180 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cmplt_epi32(__m128i __a,
                                                             __m128i __b) {
  return _mm_cmpgt_epi32(__b, __a);
}
# 3203 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cvtsi64_sd(__m128d __a,
                                                            long long __b) {
  __a[0] = __b;
  return __a;
}
# 3220 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ long long __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cvtsd_si64(__m128d __a) {
  return __builtin_ia32_cvtsd2si64((__v2df)__a);
}
# 3236 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ long long __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cvttsd_si64(__m128d __a) {
  return __builtin_ia32_cvttsd2si64((__v2df)__a);
}
# 3250 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cvtepi32_ps(__m128i __a) {
  return (__m128) __builtin_convertvector((__v4si)__a, __v4sf);
}
# 3264 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cvtps_epi32(__m128 __a) {
  return (__m128i)__builtin_ia32_cvtps2dq((__v4sf)__a);
}
# 3279 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cvttps_epi32(__m128 __a) {
  return (__m128i)__builtin_ia32_cvttps2dq((__v4sf)__a);
}
# 3293 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cvtsi32_si128(int __a) {
  return __extension__(__m128i)(__v4si){__a, 0, 0, 0};
}
# 3308 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cvtsi64_si128(long long __a) {
  return __extension__(__m128i)(__v2di){__a, 0};
}
# 3323 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ int __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cvtsi128_si32(__m128i __a) {
  __v4si __b = (__v4si)__a;
  return __b[0];
}
# 3339 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ long long __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_cvtsi128_si64(__m128i __a) {
  return __a[0];
}
# 3353 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128)))
_mm_load_si128(__m128i const *__p) {
  return *__p;
}
# 3368 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128)))
_mm_loadu_si128(__m128i_u const *__p) {
  struct __loadu_si128 {
    __m128i_u __v;
  } __attribute__((__packed__, __may_alias__));
  return ((const struct __loadu_si128 *)__p)->__v;
}
# 3388 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128)))
_mm_loadl_epi64(__m128i_u const *__p) {
  struct __mm_loadl_epi64_struct {
    long long __u;
  } __attribute__((__packed__, __may_alias__));
  return __extension__(__m128i){
      ((const struct __mm_loadl_epi64_struct *)__p)->__u, 0};
}
# 3406 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_undefined_si128(void) {
  return (__m128i)__builtin_ia32_undef128();
}
# 3426 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_set_epi64x(long long __q1,
                                                            long long __q0) {
  return __extension__(__m128i)(__v2di){__q0, __q1};
}
# 3447 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_set_epi64(__m64 __q1,
                                                           __m64 __q0) {
  return _mm_set_epi64x((long long)__q1, (long long)__q0);
}
# 3474 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_set_epi32(int __i3, int __i2,
                                                           int __i1, int __i0) {
  return __extension__(__m128i)(__v4si){__i0, __i1, __i2, __i3};
}
# 3513 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128)))
_mm_set_epi16(short __w7, short __w6, short __w5, short __w4, short __w3,
              short __w2, short __w1, short __w0) {
  return __extension__(__m128i)(__v8hi){__w0, __w1, __w2, __w3,
                                        __w4, __w5, __w6, __w7};
}
# 3562 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128)))
_mm_set_epi8(char __b15, char __b14, char __b13, char __b12, char __b11,
             char __b10, char __b9, char __b8, char __b7, char __b6, char __b5,
             char __b4, char __b3, char __b2, char __b1, char __b0) {
  return __extension__(__m128i)(__v16qi){
      __b0, __b1, __b2, __b3, __b4, __b5, __b6, __b7,
      __b8, __b9, __b10, __b11, __b12, __b13, __b14, __b15};
}
# 3584 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_set1_epi64x(long long __q) {
  return _mm_set_epi64x(__q, __q);
}
# 3601 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_set1_epi64(__m64 __q) {
  return _mm_set_epi64(__q, __q);
}
# 3618 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_set1_epi32(int __i) {
  return _mm_set_epi32(__i, __i, __i, __i);
}
# 3635 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_set1_epi16(short __w) {
  return _mm_set_epi16(__w, __w, __w, __w, __w, __w, __w, __w);
}
# 3652 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_set1_epi8(char __b) {
  return _mm_set_epi8(__b, __b, __b, __b, __b, __b, __b, __b, __b, __b, __b,
                      __b, __b, __b, __b, __b);
}
# 3671 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_setr_epi64(__m64 __q0,
                                                            __m64 __q1) {
  return _mm_set_epi64(__q1, __q0);
}
# 3693 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_setr_epi32(int __i0, int __i1,
                                                            int __i2,
                                                            int __i3) {
  return _mm_set_epi32(__i3, __i2, __i1, __i0);
}
# 3724 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128)))
_mm_setr_epi16(short __w0, short __w1, short __w2, short __w3, short __w4,
               short __w5, short __w6, short __w7) {
  return _mm_set_epi16(__w7, __w6, __w5, __w4, __w3, __w2, __w1, __w0);
}
# 3771 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128)))
_mm_setr_epi8(char __b0, char __b1, char __b2, char __b3, char __b4, char __b5,
              char __b6, char __b7, char __b8, char __b9, char __b10,
              char __b11, char __b12, char __b13, char __b14, char __b15) {
  return _mm_set_epi8(__b15, __b14, __b13, __b12, __b11, __b10, __b9, __b8,
                      __b7, __b6, __b5, __b4, __b3, __b2, __b1, __b0);
}
# 3787 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_setzero_si128(void) {
  return __extension__(__m128i)(__v2di){0LL, 0LL};
}
# 3803 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ void __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_store_si128(__m128i *__p,
                                                          __m128i __b) {
  *__p = __b;
}
# 3818 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ void __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_storeu_si128(__m128i_u *__p,
                                                           __m128i __b) {
  struct __storeu_si128 {
    __m128i_u __v;
  } __attribute__((__packed__, __may_alias__));
  ((struct __storeu_si128 *)__p)->__v = __b;
}
# 3838 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ void __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_storeu_si64(void *__p,
                                                          __m128i __b) {
  struct __storeu_si64 {
    long long __v;
  } __attribute__((__packed__, __may_alias__));
  ((struct __storeu_si64 *)__p)->__v = ((__v2di)__b)[0];
}
# 3858 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ void __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_storeu_si32(void *__p,
                                                          __m128i __b) {
  struct __storeu_si32 {
    int __v;
  } __attribute__((__packed__, __may_alias__));
  ((struct __storeu_si32 *)__p)->__v = ((__v4si)__b)[0];
}
# 3878 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ void __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_storeu_si16(void *__p,
                                                          __m128i __b) {
  struct __storeu_si16 {
    short __v;
  } __attribute__((__packed__, __may_alias__));
  ((struct __storeu_si16 *)__p)->__v = ((__v8hi)__b)[0];
}
# 3907 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ void __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_maskmoveu_si128(__m128i __d,
                                                              __m128i __n,
                                                              char *__p) {
  __builtin_ia32_maskmovdqu((__v16qi)__d, (__v16qi)__n, __p);
}
# 3926 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ void __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_storel_epi64(__m128i_u *__p,
                                                           __m128i __a) {
  struct __mm_storel_epi64_struct {
    long long __u;
  } __attribute__((__packed__, __may_alias__));
  ((struct __mm_storel_epi64_struct *)__p)->__u = __a[0];
}
# 3948 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ void __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_stream_pd(void *__p,
                                                        __m128d __a) {
  __builtin_nontemporal_store((__v2df)__a, (__v2df *)__p);
}
# 3966 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ void __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_stream_si128(void *__p,
                                                           __m128i __a) {
  __builtin_nontemporal_store((__v2di)__a, (__v2di *)__p);
}
# 3984 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ void
    __attribute__((__always_inline__, __nodebug__, __target__("sse2")))
    _mm_stream_si32(void *__p, int __a) {
  __builtin_ia32_movnti((int *)__p, __a);
}
# 4004 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ void
    __attribute__((__always_inline__, __nodebug__, __target__("sse2")))
    _mm_stream_si64(void *__p, long long __a) {
  __builtin_ia32_movnti64((long long *)__p, __a);
}



extern "C" {
# 4025 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
void _mm_clflush(void const *__p);
# 4036 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
void _mm_lfence(void);
# 4047 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
void _mm_mfence(void);


}
# 4075 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_packs_epi16(__m128i __a,
                                                             __m128i __b) {
  return (__m128i)__builtin_ia32_packsswb128((__v8hi)__a, (__v8hi)__b);
}
# 4102 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_packs_epi32(__m128i __a,
                                                             __m128i __b) {
  return (__m128i)__builtin_ia32_packssdw128((__v4si)__a, (__v4si)__b);
}
# 4129 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_packus_epi16(__m128i __a,
                                                              __m128i __b) {
  return (__m128i)__builtin_ia32_packuswb128((__v8hi)__a, (__v8hi)__b);
}
# 4204 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ int __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_movemask_epi8(__m128i __a) {
  return __builtin_ia32_pmovmskb128((__v16qi)__a);
}
# 4337 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_unpackhi_epi8(__m128i __a,
                                                               __m128i __b) {
  return (__m128i)__builtin_shufflevector(
      (__v16qi)__a, (__v16qi)__b, 8, 16 + 8, 9, 16 + 9, 10, 16 + 10, 11,
      16 + 11, 12, 16 + 12, 13, 16 + 13, 14, 16 + 14, 15, 16 + 15);
}
# 4365 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_unpackhi_epi16(__m128i __a,
                                                                __m128i __b) {
  return (__m128i)__builtin_shufflevector((__v8hi)__a, (__v8hi)__b, 4, 8 + 4, 5,
                                          8 + 5, 6, 8 + 6, 7, 8 + 7);
}
# 4388 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_unpackhi_epi32(__m128i __a,
                                                                __m128i __b) {
  return (__m128i)__builtin_shufflevector((__v4si)__a, (__v4si)__b, 2, 4 + 2, 3,
                                          4 + 3);
}
# 4409 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_unpackhi_epi64(__m128i __a,
                                                                __m128i __b) {
  return (__m128i)__builtin_shufflevector((__v2di)__a, (__v2di)__b, 1, 2 + 1);
}
# 4443 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_unpacklo_epi8(__m128i __a,
                                                               __m128i __b) {
  return (__m128i)__builtin_shufflevector(
      (__v16qi)__a, (__v16qi)__b, 0, 16 + 0, 1, 16 + 1, 2, 16 + 2, 3, 16 + 3, 4,
      16 + 4, 5, 16 + 5, 6, 16 + 6, 7, 16 + 7);
}
# 4472 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_unpacklo_epi16(__m128i __a,
                                                                __m128i __b) {
  return (__m128i)__builtin_shufflevector((__v8hi)__a, (__v8hi)__b, 0, 8 + 0, 1,
                                          8 + 1, 2, 8 + 2, 3, 8 + 3);
}
# 4495 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_unpacklo_epi32(__m128i __a,
                                                                __m128i __b) {
  return (__m128i)__builtin_shufflevector((__v4si)__a, (__v4si)__b, 0, 4 + 0, 1,
                                          4 + 1);
}
# 4516 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_unpacklo_epi64(__m128i __a,
                                                                __m128i __b) {
  return (__m128i)__builtin_shufflevector((__v2di)__a, (__v2di)__b, 0, 2 + 0);
}
# 4532 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m64 __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_movepi64_pi64(__m128i __a) {
  return (__m64)__a[0];
}
# 4547 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_movpi64_epi64(__m64 __a) {
  return __extension__(__m128i)(__v2di){(long long)__a, 0};
}
# 4563 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_move_epi64(__m128i __a) {
  return __builtin_shufflevector((__v2di)__a, _mm_setzero_si128(), 0, 2);
}
# 4582 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_unpackhi_pd(__m128d __a,
                                                             __m128d __b) {
  return __builtin_shufflevector((__v2df)__a, (__v2df)__b, 1, 2 + 1);
}
# 4602 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_unpacklo_pd(__m128d __a,
                                                             __m128d __b) {
  return __builtin_shufflevector((__v2df)__a, (__v2df)__b, 0, 2 + 0);
}
# 4620 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ int __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_movemask_pd(__m128d __a) {
  return __builtin_ia32_movmskpd((__v2df)__a);
}
# 4666 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_castpd_ps(__m128d __a) {
  return (__m128)__a;
}
# 4681 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_castpd_si128(__m128d __a) {
  return (__m128i)__a;
}
# 4696 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_castps_pd(__m128 __a) {
  return (__m128d)__a;
}
# 4711 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128i __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_castps_si128(__m128 __a) {
  return (__m128i)__a;
}
# 4726 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128 __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_castsi128_ps(__m128i __a) {
  return (__m128)__a;
}
# 4741 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
static __inline__ __m128d __attribute__((__always_inline__, __nodebug__, __target__("sse2,no-evex512"), __min_vector_width__(128))) _mm_castsi128_pd(__m128i __a) {
  return (__m128d)__a;
}


extern "C" {
# 4756 "/usr/bin/../lib/clang/18/include/emmintrin.h" 3
void _mm_pause(void);


}
# 3019 "/usr/bin/../lib/clang/18/include/xmmintrin.h" 2 3
# 32 "/home/avi/scylla-maint/seastar/include/seastar/util/spinlock.hh" 2



namespace seastar {

namespace internal {







[[gnu::always_inline]]
inline void cpu_relax() {
    _mm_pause();
}
# 79 "/home/avi/scylla-maint/seastar/include/seastar/util/spinlock.hh"
}

namespace util {






class spinlock {
    std::atomic<bool> _busy = { false };
public:
    spinlock() = default;
    spinlock(const spinlock&) = delete;
    ~spinlock() { (static_cast <bool> (!_busy.load(std::memory_order_relaxed)) ? void (0) : __assert_fail ("!_busy.load(std::memory_order_relaxed)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); }
    bool try_lock() noexcept {
        return !_busy.exchange(true, std::memory_order_acquire);
    }
    void lock() noexcept {
        while (_busy.exchange(true, std::memory_order_acquire)) {
            while (_busy.load(std::memory_order_relaxed)) {
                internal::cpu_relax();
            }
        }
    }
    void unlock() noexcept {
        _busy.store(false, std::memory_order_release);
    }
};

}

}
# 25 "/home/avi/scylla-maint/seastar/include/seastar/core/resource.hh" 2


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 1 3
# 42 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 3


# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 45 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 2 3
# 28 "/home/avi/scylla-maint/seastar/include/seastar/core/resource.hh" 2
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdlib" 1 3
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdlib" 3
# 29 "/home/avi/scylla-maint/seastar/include/seastar/core/resource.hh" 2
# 38 "/home/avi/scylla-maint/seastar/include/seastar/core/resource.hh"
# 1 "/usr/include/hwloc.h" 1 3 4
# 56 "/usr/include/hwloc.h" 3 4
# 1 "/usr/include/hwloc/autogen/config.h" 1 3 4
# 226 "/usr/include/hwloc/autogen/config.h" 3 4
typedef uint64_t hwloc_uint64_t;
# 57 "/usr/include/hwloc.h" 2 3 4
# 66 "/usr/include/hwloc.h" 3 4
# 1 "/usr/include/hwloc/rename.h" 1 3 4
# 14 "/usr/include/hwloc/rename.h" 3 4
extern "C" {
# 907 "/usr/include/hwloc/rename.h" 3 4
}
# 67 "/usr/include/hwloc.h" 2 3 4





# 1 "/usr/include/hwloc/bitmap.h" 1 3 4
# 18 "/usr/include/hwloc/bitmap.h" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 19 "/usr/include/hwloc/bitmap.h" 2 3 4



extern "C" {
# 69 "/usr/include/hwloc/bitmap.h" 3 4
typedef struct hwloc_bitmap_s * hwloc_bitmap_t;

typedef const struct hwloc_bitmap_s * hwloc_const_bitmap_t;
# 85 "/usr/include/hwloc/bitmap.h" 3 4
               hwloc_bitmap_t hwloc_bitmap_alloc(void) __attribute__((__malloc__));
# 94 "/usr/include/hwloc/bitmap.h" 3 4
               hwloc_bitmap_t hwloc_bitmap_alloc_full(void) __attribute__((__malloc__));





               void hwloc_bitmap_free(hwloc_bitmap_t bitmap);





               hwloc_bitmap_t hwloc_bitmap_dup(hwloc_const_bitmap_t bitmap) __attribute__((__malloc__));


               int hwloc_bitmap_copy(hwloc_bitmap_t dst, hwloc_const_bitmap_t src);
# 125 "/usr/include/hwloc/bitmap.h" 3 4
               int hwloc_bitmap_snprintf(char * __restrict buf, size_t buflen, hwloc_const_bitmap_t bitmap);





               int hwloc_bitmap_asprintf(char ** strp, hwloc_const_bitmap_t bitmap);





               int hwloc_bitmap_sscanf(hwloc_bitmap_t bitmap, const char * __restrict string);
# 152 "/usr/include/hwloc/bitmap.h" 3 4
               int hwloc_bitmap_list_snprintf(char * __restrict buf, size_t buflen, hwloc_const_bitmap_t bitmap);





               int hwloc_bitmap_list_asprintf(char ** strp, hwloc_const_bitmap_t bitmap);





               int hwloc_bitmap_list_sscanf(hwloc_bitmap_t bitmap, const char * __restrict string);
# 178 "/usr/include/hwloc/bitmap.h" 3 4
               int hwloc_bitmap_taskset_snprintf(char * __restrict buf, size_t buflen, hwloc_const_bitmap_t bitmap);





               int hwloc_bitmap_taskset_asprintf(char ** strp, hwloc_const_bitmap_t bitmap);





               int hwloc_bitmap_taskset_sscanf(hwloc_bitmap_t bitmap, const char * __restrict string);







               void hwloc_bitmap_zero(hwloc_bitmap_t bitmap);


               void hwloc_bitmap_fill(hwloc_bitmap_t bitmap);


               int hwloc_bitmap_only(hwloc_bitmap_t bitmap, unsigned id);


               int hwloc_bitmap_allbut(hwloc_bitmap_t bitmap, unsigned id);


               int hwloc_bitmap_from_ulong(hwloc_bitmap_t bitmap, unsigned long mask);


               int hwloc_bitmap_from_ith_ulong(hwloc_bitmap_t bitmap, unsigned i, unsigned long mask);


               int hwloc_bitmap_from_ulongs(hwloc_bitmap_t bitmap, unsigned nr, const unsigned long *masks);







               int hwloc_bitmap_set(hwloc_bitmap_t bitmap, unsigned id);





               int hwloc_bitmap_set_range(hwloc_bitmap_t bitmap, unsigned begin, int end);


               int hwloc_bitmap_set_ith_ulong(hwloc_bitmap_t bitmap, unsigned i, unsigned long mask);


               int hwloc_bitmap_clr(hwloc_bitmap_t bitmap, unsigned id);





               int hwloc_bitmap_clr_range(hwloc_bitmap_t bitmap, unsigned begin, int end);
# 263 "/usr/include/hwloc/bitmap.h" 3 4
               int hwloc_bitmap_singlify(hwloc_bitmap_t bitmap);







               unsigned long hwloc_bitmap_to_ulong(hwloc_const_bitmap_t bitmap) __attribute__((__pure__));


               unsigned long hwloc_bitmap_to_ith_ulong(hwloc_const_bitmap_t bitmap, unsigned i) __attribute__((__pure__));







               int hwloc_bitmap_to_ulongs(hwloc_const_bitmap_t bitmap, unsigned nr, unsigned long *masks);
# 298 "/usr/include/hwloc/bitmap.h" 3 4
               int hwloc_bitmap_nr_ulongs(hwloc_const_bitmap_t bitmap) __attribute__((__pure__));





               int hwloc_bitmap_isset(hwloc_const_bitmap_t bitmap, unsigned id) __attribute__((__pure__));





               int hwloc_bitmap_iszero(hwloc_const_bitmap_t bitmap) __attribute__((__pure__));







               int hwloc_bitmap_isfull(hwloc_const_bitmap_t bitmap) __attribute__((__pure__));






               int hwloc_bitmap_first(hwloc_const_bitmap_t bitmap) __attribute__((__pure__));







               int hwloc_bitmap_next(hwloc_const_bitmap_t bitmap, int prev) __attribute__((__pure__));






               int hwloc_bitmap_last(hwloc_const_bitmap_t bitmap) __attribute__((__pure__));







               int hwloc_bitmap_weight(hwloc_const_bitmap_t bitmap) __attribute__((__pure__));






               int hwloc_bitmap_first_unset(hwloc_const_bitmap_t bitmap) __attribute__((__pure__));







               int hwloc_bitmap_next_unset(hwloc_const_bitmap_t bitmap, int prev) __attribute__((__pure__));






               int hwloc_bitmap_last_unset(hwloc_const_bitmap_t bitmap) __attribute__((__pure__));
# 414 "/usr/include/hwloc/bitmap.h" 3 4
               int hwloc_bitmap_or (hwloc_bitmap_t res, hwloc_const_bitmap_t bitmap1, hwloc_const_bitmap_t bitmap2);





               int hwloc_bitmap_and (hwloc_bitmap_t res, hwloc_const_bitmap_t bitmap1, hwloc_const_bitmap_t bitmap2);





               int hwloc_bitmap_andnot (hwloc_bitmap_t res, hwloc_const_bitmap_t bitmap1, hwloc_const_bitmap_t bitmap2);





               int hwloc_bitmap_xor (hwloc_bitmap_t res, hwloc_const_bitmap_t bitmap1, hwloc_const_bitmap_t bitmap2);





               int hwloc_bitmap_not (hwloc_bitmap_t res, hwloc_const_bitmap_t bitmap);
# 451 "/usr/include/hwloc/bitmap.h" 3 4
               int hwloc_bitmap_intersects (hwloc_const_bitmap_t bitmap1, hwloc_const_bitmap_t bitmap2) __attribute__((__pure__));







               int hwloc_bitmap_isincluded (hwloc_const_bitmap_t sub_bitmap, hwloc_const_bitmap_t super_bitmap) __attribute__((__pure__));





               int hwloc_bitmap_isequal (hwloc_const_bitmap_t bitmap1, hwloc_const_bitmap_t bitmap2) __attribute__((__pure__));
# 484 "/usr/include/hwloc/bitmap.h" 3 4
               int hwloc_bitmap_compare_first(hwloc_const_bitmap_t bitmap1, hwloc_const_bitmap_t bitmap2) __attribute__((__pure__));
# 503 "/usr/include/hwloc/bitmap.h" 3 4
               int hwloc_bitmap_compare(hwloc_const_bitmap_t bitmap1, hwloc_const_bitmap_t bitmap2) __attribute__((__pure__));





}
# 73 "/usr/include/hwloc.h" 2 3 4



extern "C" {
# 123 "/usr/include/hwloc.h" 3 4
               unsigned hwloc_get_api_version(void);
# 161 "/usr/include/hwloc.h" 3 4
typedef hwloc_bitmap_t hwloc_cpuset_t;

typedef hwloc_const_bitmap_t hwloc_const_cpuset_t;
# 178 "/usr/include/hwloc.h" 3 4
typedef hwloc_bitmap_t hwloc_nodeset_t;


typedef hwloc_const_bitmap_t hwloc_const_nodeset_t;
# 197 "/usr/include/hwloc.h" 3 4
typedef enum {





  HWLOC_OBJ_MACHINE,
# 212 "/usr/include/hwloc.h" 3 4
  HWLOC_OBJ_PACKAGE,





  HWLOC_OBJ_CORE,



  HWLOC_OBJ_PU,
# 234 "/usr/include/hwloc.h" 3 4
  HWLOC_OBJ_L1CACHE,
  HWLOC_OBJ_L2CACHE,
  HWLOC_OBJ_L3CACHE,
  HWLOC_OBJ_L4CACHE,
  HWLOC_OBJ_L5CACHE,

  HWLOC_OBJ_L1ICACHE,
  HWLOC_OBJ_L2ICACHE,
  HWLOC_OBJ_L3ICACHE,

  HWLOC_OBJ_GROUP,
# 257 "/usr/include/hwloc.h" 3 4
  HWLOC_OBJ_NUMANODE,
# 283 "/usr/include/hwloc.h" 3 4
  HWLOC_OBJ_BRIDGE,
# 295 "/usr/include/hwloc.h" 3 4
  HWLOC_OBJ_PCI_DEVICE,
# 305 "/usr/include/hwloc.h" 3 4
  HWLOC_OBJ_OS_DEVICE,
# 316 "/usr/include/hwloc.h" 3 4
  HWLOC_OBJ_MISC,
# 331 "/usr/include/hwloc.h" 3 4
  HWLOC_OBJ_MEMCACHE,
# 344 "/usr/include/hwloc.h" 3 4
  HWLOC_OBJ_DIE,
# 354 "/usr/include/hwloc.h" 3 4
  HWLOC_OBJ_TYPE_MAX
} hwloc_obj_type_t;


typedef enum hwloc_obj_cache_type_e {
  HWLOC_OBJ_CACHE_UNIFIED,
  HWLOC_OBJ_CACHE_DATA,
  HWLOC_OBJ_CACHE_INSTRUCTION
} hwloc_obj_cache_type_t;


typedef enum hwloc_obj_bridge_type_e {
  HWLOC_OBJ_BRIDGE_HOST,
  HWLOC_OBJ_BRIDGE_PCI
} hwloc_obj_bridge_type_t;


typedef enum hwloc_obj_osdev_type_e {
  HWLOC_OBJ_OSDEV_BLOCK,

  HWLOC_OBJ_OSDEV_GPU,


  HWLOC_OBJ_OSDEV_NETWORK,

  HWLOC_OBJ_OSDEV_OPENFABRICS,



  HWLOC_OBJ_OSDEV_DMA,

  HWLOC_OBJ_OSDEV_COPROC


} hwloc_obj_osdev_type_t;
# 412 "/usr/include/hwloc.h" 3 4
               int hwloc_compare_types (hwloc_obj_type_t type1, hwloc_obj_type_t type2) __attribute__((__const__));
# 425 "/usr/include/hwloc.h" 3 4
union hwloc_obj_attr_u;





struct hwloc_obj {

  hwloc_obj_type_t type;
  char *subtype;

  unsigned os_index;






  char *name;




  hwloc_uint64_t total_memory;

  union hwloc_obj_attr_u *attr;



  int depth;
# 469 "/usr/include/hwloc.h" 3 4
  unsigned logical_index;







  struct hwloc_obj *next_cousin;
  struct hwloc_obj *prev_cousin;


  struct hwloc_obj *parent;
  unsigned sibling_rank;
  struct hwloc_obj *next_sibling;
  struct hwloc_obj *prev_sibling;


  unsigned arity;



  struct hwloc_obj **children;
  struct hwloc_obj *first_child;
  struct hwloc_obj *last_child;


  int symmetric_subtree;
# 507 "/usr/include/hwloc.h" 3 4
  unsigned memory_arity;


  struct hwloc_obj *memory_first_child;
# 525 "/usr/include/hwloc.h" 3 4
  unsigned io_arity;


  struct hwloc_obj *io_first_child;
# 537 "/usr/include/hwloc.h" 3 4
  unsigned misc_arity;


  struct hwloc_obj *misc_first_child;






  hwloc_cpuset_t cpuset;
# 562 "/usr/include/hwloc.h" 3 4
  hwloc_cpuset_t complete_cpuset;
# 575 "/usr/include/hwloc.h" 3 4
  hwloc_nodeset_t nodeset;
# 597 "/usr/include/hwloc.h" 3 4
  hwloc_nodeset_t complete_nodeset;
# 613 "/usr/include/hwloc.h" 3 4
  struct hwloc_info_s *infos;
  unsigned infos_count;


  void *userdata;




  hwloc_uint64_t gp_index;




};



typedef struct hwloc_obj * hwloc_obj_t;


union hwloc_obj_attr_u {

  struct hwloc_numanode_attr_s {
    hwloc_uint64_t local_memory;
    unsigned page_types_len;





    struct hwloc_memory_page_type_s {
      hwloc_uint64_t size;
      hwloc_uint64_t count;
    } * page_types;
  } numanode;


  struct hwloc_cache_attr_s {
    hwloc_uint64_t size;
    unsigned depth;
    unsigned linesize;
    int associativity;

    hwloc_obj_cache_type_t type;
  } cache;

  struct hwloc_group_attr_s {
    unsigned depth;

    unsigned kind;
    unsigned subkind;
    unsigned char dont_merge;
  } group;

  struct hwloc_pcidev_attr_s {

    unsigned short domain;





    unsigned char bus;
    unsigned char dev;
    unsigned char func;
    unsigned short class_id;
    unsigned short vendor_id;
    unsigned short device_id;
    unsigned short subvendor_id;
    unsigned short subdevice_id;
    unsigned char revision;
    float linkspeed;





  } pcidev;

  struct hwloc_bridge_attr_s {
    union {
      struct hwloc_pcidev_attr_s pci;
    } upstream;
    hwloc_obj_bridge_type_t upstream_type;
    union {
      struct {

        unsigned short domain;





        unsigned char secondary_bus;
        unsigned char subordinate_bus;
      } pci;
    } downstream;
    hwloc_obj_bridge_type_t downstream_type;
    unsigned depth;
  } bridge;

  struct hwloc_osdev_attr_s {
    hwloc_obj_osdev_type_t type;
  } osdev;
};





struct hwloc_info_s {
  char *name;
  char *value;
};
# 737 "/usr/include/hwloc.h" 3 4
struct hwloc_topology;




typedef struct hwloc_topology * hwloc_topology_t;







               int hwloc_topology_init (hwloc_topology_t *topologyp);
# 772 "/usr/include/hwloc.h" 3 4
               int hwloc_topology_load(hwloc_topology_t topology);





               void hwloc_topology_destroy (hwloc_topology_t topology);
# 792 "/usr/include/hwloc.h" 3 4
               int hwloc_topology_dup(hwloc_topology_t *newtopology, hwloc_topology_t oldtopology);
# 811 "/usr/include/hwloc.h" 3 4
               int hwloc_topology_abi_check(hwloc_topology_t topology);
# 824 "/usr/include/hwloc.h" 3 4
               void hwloc_topology_check(hwloc_topology_t topology);
# 848 "/usr/include/hwloc.h" 3 4
               int hwloc_topology_get_depth(hwloc_topology_t __restrict topology) __attribute__((__pure__));
# 876 "/usr/include/hwloc.h" 3 4
               int hwloc_get_type_depth (hwloc_topology_t topology, hwloc_obj_type_t type);

enum hwloc_get_type_depth_e {
    HWLOC_TYPE_DEPTH_UNKNOWN = -1,
    HWLOC_TYPE_DEPTH_MULTIPLE = -2,
    HWLOC_TYPE_DEPTH_NUMANODE = -3,
    HWLOC_TYPE_DEPTH_BRIDGE = -4,
    HWLOC_TYPE_DEPTH_PCI_DEVICE = -5,
    HWLOC_TYPE_DEPTH_OS_DEVICE = -6,
    HWLOC_TYPE_DEPTH_MISC = -7,
    HWLOC_TYPE_DEPTH_MEMCACHE = -8
};
# 908 "/usr/include/hwloc.h" 3 4
               int hwloc_get_memory_parents_depth (hwloc_topology_t topology);
# 923 "/usr/include/hwloc.h" 3 4
static inline int
hwloc_get_type_or_below_depth (hwloc_topology_t topology, hwloc_obj_type_t type) __attribute__((__pure__));
# 939 "/usr/include/hwloc.h" 3 4
static inline int
hwloc_get_type_or_above_depth (hwloc_topology_t topology, hwloc_obj_type_t type) __attribute__((__pure__));
# 950 "/usr/include/hwloc.h" 3 4
               hwloc_obj_type_t hwloc_get_depth_type (hwloc_topology_t topology, int depth) __attribute__((__pure__));






               unsigned hwloc_get_nbobjs_by_depth (hwloc_topology_t topology, int depth) __attribute__((__pure__));







static inline int
hwloc_get_nbobjs_by_type (hwloc_topology_t topology, hwloc_obj_type_t type) __attribute__((__pure__));







static inline hwloc_obj_t
hwloc_get_root_obj (hwloc_topology_t topology) __attribute__((__pure__));






               hwloc_obj_t hwloc_get_obj_by_depth (hwloc_topology_t topology, int depth, unsigned idx) __attribute__((__pure__));
# 991 "/usr/include/hwloc.h" 3 4
static inline hwloc_obj_t
hwloc_get_obj_by_type (hwloc_topology_t topology, hwloc_obj_type_t type, unsigned idx) __attribute__((__pure__));







static inline hwloc_obj_t
hwloc_get_next_obj_by_depth (hwloc_topology_t topology, int depth, hwloc_obj_t prev);
# 1011 "/usr/include/hwloc.h" 3 4
static inline hwloc_obj_t
hwloc_get_next_obj_by_type (hwloc_topology_t topology, hwloc_obj_type_t type,
       hwloc_obj_t prev);
# 1033 "/usr/include/hwloc.h" 3 4
               const char * hwloc_obj_type_string (hwloc_obj_type_t type) __attribute__((__const__));
# 1052 "/usr/include/hwloc.h" 3 4
               int hwloc_obj_type_snprintf(char * __restrict string, size_t size,
        hwloc_obj_t obj,
        int verbose);
# 1067 "/usr/include/hwloc.h" 3 4
               int hwloc_obj_attr_snprintf(char * __restrict string, size_t size,
        hwloc_obj_t obj, const char * __restrict separator,
        int verbose);
# 1094 "/usr/include/hwloc.h" 3 4
               int hwloc_type_sscanf(const char *string,
         hwloc_obj_type_t *typep,
         union hwloc_obj_attr_u *attrp, size_t attrsize);
# 1119 "/usr/include/hwloc.h" 3 4
               int hwloc_type_sscanf_as_depth(const char *string,
           hwloc_obj_type_t *typep,
           hwloc_topology_t topology, int *depthp);
# 1141 "/usr/include/hwloc.h" 3 4
static inline const char *
hwloc_obj_get_info_by_name(hwloc_obj_t obj, const char *name) __attribute__((__pure__));
# 1160 "/usr/include/hwloc.h" 3 4
               int hwloc_obj_add_info(hwloc_obj_t obj, const char *name, const char *value);
# 1233 "/usr/include/hwloc.h" 3 4
typedef enum {


  HWLOC_CPUBIND_PROCESS = (1<<0),



  HWLOC_CPUBIND_THREAD = (1<<1),
# 1265 "/usr/include/hwloc.h" 3 4
  HWLOC_CPUBIND_STRICT = (1<<2),
# 1282 "/usr/include/hwloc.h" 3 4
  HWLOC_CPUBIND_NOMEMBIND = (1<<3)
} hwloc_cpubind_flags_t;







               int hwloc_set_cpubind(hwloc_topology_t topology, hwloc_const_cpuset_t set, int flags);
# 1301 "/usr/include/hwloc.h" 3 4
               int hwloc_get_cpubind(hwloc_topology_t topology, hwloc_cpuset_t set, int flags);
# 1316 "/usr/include/hwloc.h" 3 4
               int hwloc_set_proc_cpubind(hwloc_topology_t topology, pid_t pid, hwloc_const_cpuset_t set, int flags);
# 1335 "/usr/include/hwloc.h" 3 4
               int hwloc_get_proc_cpubind(hwloc_topology_t topology, pid_t pid, hwloc_cpuset_t set, int flags);
# 1347 "/usr/include/hwloc.h" 3 4
               int hwloc_set_thread_cpubind(hwloc_topology_t topology, pthread_t thread, hwloc_const_cpuset_t set, int flags);
# 1364 "/usr/include/hwloc.h" 3 4
               int hwloc_get_thread_cpubind(hwloc_topology_t topology, pthread_t thread, hwloc_cpuset_t set, int flags);
# 1386 "/usr/include/hwloc.h" 3 4
               int hwloc_get_last_cpu_location(hwloc_topology_t topology, hwloc_cpuset_t set, int flags);
# 1410 "/usr/include/hwloc.h" 3 4
               int hwloc_get_proc_last_cpu_location(hwloc_topology_t topology, pid_t pid, hwloc_cpuset_t set, int flags);
# 1491 "/usr/include/hwloc.h" 3 4
typedef enum {







  HWLOC_MEMBIND_DEFAULT = 0,
# 1510 "/usr/include/hwloc.h" 3 4
  HWLOC_MEMBIND_FIRSTTOUCH = 1,
# 1520 "/usr/include/hwloc.h" 3 4
  HWLOC_MEMBIND_BIND = 2,
# 1529 "/usr/include/hwloc.h" 3 4
  HWLOC_MEMBIND_INTERLEAVE = 3,






  HWLOC_MEMBIND_NEXTTOUCH = 4,







  HWLOC_MEMBIND_MIXED = -1
} hwloc_membind_policy_t;
# 1560 "/usr/include/hwloc.h" 3 4
typedef enum {




  HWLOC_MEMBIND_PROCESS = (1<<0),




  HWLOC_MEMBIND_THREAD = (1<<1),







  HWLOC_MEMBIND_STRICT = (1<<2),





  HWLOC_MEMBIND_MIGRATE = (1<<3),
# 1597 "/usr/include/hwloc.h" 3 4
  HWLOC_MEMBIND_NOCPUBIND = (1<<4),
# 1608 "/usr/include/hwloc.h" 3 4
  HWLOC_MEMBIND_BYNODESET = (1<<5)
} hwloc_membind_flags_t;
# 1627 "/usr/include/hwloc.h" 3 4
               int hwloc_set_membind(hwloc_topology_t topology, hwloc_const_bitmap_t set, hwloc_membind_policy_t policy, int flags);
# 1678 "/usr/include/hwloc.h" 3 4
               int hwloc_get_membind(hwloc_topology_t topology, hwloc_bitmap_t set, hwloc_membind_policy_t * policy, int flags);
# 1693 "/usr/include/hwloc.h" 3 4
               int hwloc_set_proc_membind(hwloc_topology_t topology, pid_t pid, hwloc_const_bitmap_t set, hwloc_membind_policy_t policy, int flags);
# 1739 "/usr/include/hwloc.h" 3 4
               int hwloc_get_proc_membind(hwloc_topology_t topology, pid_t pid, hwloc_bitmap_t set, hwloc_membind_policy_t * policy, int flags);
# 1751 "/usr/include/hwloc.h" 3 4
               int hwloc_set_area_membind(hwloc_topology_t topology, const void *addr, size_t len, hwloc_const_bitmap_t set, hwloc_membind_policy_t policy, int flags);
# 1784 "/usr/include/hwloc.h" 3 4
               int hwloc_get_area_membind(hwloc_topology_t topology, const void *addr, size_t len, hwloc_bitmap_t set, hwloc_membind_policy_t * policy, int flags);
# 1808 "/usr/include/hwloc.h" 3 4
               int hwloc_get_area_memlocation(hwloc_topology_t topology, const void *addr, size_t len, hwloc_bitmap_t set, int flags);
# 1819 "/usr/include/hwloc.h" 3 4
               void *hwloc_alloc(hwloc_topology_t topology, size_t len);
# 1836 "/usr/include/hwloc.h" 3 4
               void *hwloc_alloc_membind(hwloc_topology_t topology, size_t len, hwloc_const_bitmap_t set, hwloc_membind_policy_t policy, int flags) __attribute__((__malloc__));
# 1852 "/usr/include/hwloc.h" 3 4
static inline void *
hwloc_alloc_membind_policy(hwloc_topology_t topology, size_t len, hwloc_const_bitmap_t set, hwloc_membind_policy_t policy, int flags) __attribute__((__malloc__));






               int hwloc_free(hwloc_topology_t topology, void *addr, size_t len);
# 1907 "/usr/include/hwloc.h" 3 4
               int hwloc_topology_set_pid(hwloc_topology_t __restrict topology, pid_t pid);
# 1940 "/usr/include/hwloc.h" 3 4
               int hwloc_topology_set_synthetic(hwloc_topology_t __restrict topology, const char * __restrict description);
# 1973 "/usr/include/hwloc.h" 3 4
               int hwloc_topology_set_xml(hwloc_topology_t __restrict topology, const char * __restrict xmlpath);
# 2007 "/usr/include/hwloc.h" 3 4
               int hwloc_topology_set_xmlbuffer(hwloc_topology_t __restrict topology, const char * __restrict buffer, int size);



enum hwloc_topology_components_flag_e {



  HWLOC_TOPOLOGY_COMPONENTS_FLAG_BLACKLIST = (1UL<<0)
};
# 2035 "/usr/include/hwloc.h" 3 4
               int hwloc_topology_set_components(hwloc_topology_t __restrict topology, unsigned long flags, const char * __restrict name);
# 2055 "/usr/include/hwloc.h" 3 4
enum hwloc_topology_flags_e {
# 2077 "/usr/include/hwloc.h" 3 4
  HWLOC_TOPOLOGY_FLAG_INCLUDE_DISALLOWED = (1UL<<0),
# 2097 "/usr/include/hwloc.h" 3 4
  HWLOC_TOPOLOGY_FLAG_IS_THISSYSTEM = (1UL<<1),
# 2118 "/usr/include/hwloc.h" 3 4
  HWLOC_TOPOLOGY_FLAG_THISSYSTEM_ALLOWED_RESOURCES = (1UL<<2),
# 2142 "/usr/include/hwloc.h" 3 4
  HWLOC_TOPOLOGY_FLAG_IMPORT_SUPPORT = (1UL<<3),
# 2167 "/usr/include/hwloc.h" 3 4
  HWLOC_TOPOLOGY_FLAG_RESTRICT_TO_CPUBINDING = (1UL<<4),
# 2189 "/usr/include/hwloc.h" 3 4
  HWLOC_TOPOLOGY_FLAG_RESTRICT_TO_MEMBINDING = (1UL<<5),
# 2204 "/usr/include/hwloc.h" 3 4
  HWLOC_TOPOLOGY_FLAG_DONT_CHANGE_BINDING = (1UL<<6),






  HWLOC_TOPOLOGY_FLAG_NO_DISTANCES = (1UL<<7),






  HWLOC_TOPOLOGY_FLAG_NO_MEMATTRS = (1UL<<8),





  HWLOC_TOPOLOGY_FLAG_NO_CPUKINDS = (1UL<<9)
};
# 2241 "/usr/include/hwloc.h" 3 4
               int hwloc_topology_set_flags (hwloc_topology_t topology, unsigned long flags);
# 2254 "/usr/include/hwloc.h" 3 4
               unsigned long hwloc_topology_get_flags (hwloc_topology_t topology);
# 2265 "/usr/include/hwloc.h" 3 4
               int hwloc_topology_is_thissystem(hwloc_topology_t __restrict topology) __attribute__((__pure__));


struct hwloc_topology_discovery_support {

  unsigned char pu;

  unsigned char numa;

  unsigned char numa_memory;

  unsigned char disallowed_pu;

  unsigned char disallowed_numa;

  unsigned char cpukind_efficiency;
};






struct hwloc_topology_cpubind_support {

  unsigned char set_thisproc_cpubind;

  unsigned char get_thisproc_cpubind;

  unsigned char set_proc_cpubind;

  unsigned char get_proc_cpubind;

  unsigned char set_thisthread_cpubind;

  unsigned char get_thisthread_cpubind;

  unsigned char set_thread_cpubind;

  unsigned char get_thread_cpubind;

  unsigned char get_thisproc_last_cpu_location;

  unsigned char get_proc_last_cpu_location;

  unsigned char get_thisthread_last_cpu_location;
};






struct hwloc_topology_membind_support {

  unsigned char set_thisproc_membind;

  unsigned char get_thisproc_membind;

  unsigned char set_proc_membind;

  unsigned char get_proc_membind;

  unsigned char set_thisthread_membind;

  unsigned char get_thisthread_membind;

  unsigned char set_area_membind;

  unsigned char get_area_membind;

  unsigned char alloc_membind;

  unsigned char firsttouch_membind;

  unsigned char bind_membind;

  unsigned char interleave_membind;

  unsigned char nexttouch_membind;

  unsigned char migrate_membind;

  unsigned char get_area_memlocation;
};



struct hwloc_topology_misc_support {

  unsigned char imported_support;
};







struct hwloc_topology_support {
  struct hwloc_topology_discovery_support *discovery;
  struct hwloc_topology_cpubind_support *cpubind;
  struct hwloc_topology_membind_support *membind;
  struct hwloc_topology_misc_support *misc;
};
# 2400 "/usr/include/hwloc.h" 3 4
               const struct hwloc_topology_support *hwloc_topology_get_support(hwloc_topology_t __restrict topology);
# 2411 "/usr/include/hwloc.h" 3 4
enum hwloc_type_filter_e {





  HWLOC_TYPE_FILTER_KEEP_ALL = 0,







  HWLOC_TYPE_FILTER_KEEP_NONE = 1,
# 2439 "/usr/include/hwloc.h" 3 4
  HWLOC_TYPE_FILTER_KEEP_STRUCTURE = 2,
# 2454 "/usr/include/hwloc.h" 3 4
  HWLOC_TYPE_FILTER_KEEP_IMPORTANT = 3
};





               int hwloc_topology_set_type_filter(hwloc_topology_t topology, hwloc_obj_type_t type, enum hwloc_type_filter_e filter);





               int hwloc_topology_get_type_filter(hwloc_topology_t topology, hwloc_obj_type_t type, enum hwloc_type_filter_e *filter);







               int hwloc_topology_set_all_types_filter(hwloc_topology_t topology, enum hwloc_type_filter_e filter);







               int hwloc_topology_set_cache_types_filter(hwloc_topology_t topology, enum hwloc_type_filter_e filter);







               int hwloc_topology_set_icache_types_filter(hwloc_topology_t topology, enum hwloc_type_filter_e filter);





               int hwloc_topology_set_io_types_filter(hwloc_topology_t topology, enum hwloc_type_filter_e filter);
# 2509 "/usr/include/hwloc.h" 3 4
               void hwloc_topology_set_userdata(hwloc_topology_t topology, const void *userdata);
# 2519 "/usr/include/hwloc.h" 3 4
               void * hwloc_topology_get_userdata(hwloc_topology_t topology);
# 2530 "/usr/include/hwloc.h" 3 4
enum hwloc_restrict_flags_e {





  HWLOC_RESTRICT_FLAG_REMOVE_CPULESS = (1UL<<0),





  HWLOC_RESTRICT_FLAG_BYNODESET = (1UL<<3),






  HWLOC_RESTRICT_FLAG_REMOVE_MEMLESS = (1UL<<4),





  HWLOC_RESTRICT_FLAG_ADAPT_MISC = (1UL<<1),





  HWLOC_RESTRICT_FLAG_ADAPT_IO = (1UL<<2)
};
# 2599 "/usr/include/hwloc.h" 3 4
               int hwloc_topology_restrict(hwloc_topology_t __restrict topology, hwloc_const_bitmap_t set, unsigned long flags);


enum hwloc_allow_flags_e {




  HWLOC_ALLOW_FLAG_ALL = (1UL<<0),
# 2616 "/usr/include/hwloc.h" 3 4
  HWLOC_ALLOW_FLAG_LOCAL_RESTRICTIONS = (1UL<<1),



  HWLOC_ALLOW_FLAG_CUSTOM = (1UL<<2)
};
# 2640 "/usr/include/hwloc.h" 3 4
               int hwloc_topology_allow(hwloc_topology_t __restrict topology, hwloc_const_cpuset_t cpuset, hwloc_const_nodeset_t nodeset, unsigned long flags);
# 2663 "/usr/include/hwloc.h" 3 4
               hwloc_obj_t hwloc_topology_insert_misc_object(hwloc_topology_t topology, hwloc_obj_t parent, const char *name);
# 2682 "/usr/include/hwloc.h" 3 4
               hwloc_obj_t hwloc_topology_alloc_group_object(hwloc_topology_t topology);
# 2695 "/usr/include/hwloc.h" 3 4
               int hwloc_topology_free_group_object(hwloc_topology_t topology, hwloc_obj_t group);
# 2755 "/usr/include/hwloc.h" 3 4
               hwloc_obj_t hwloc_topology_insert_group_object(hwloc_topology_t topology, hwloc_obj_t group);
# 2769 "/usr/include/hwloc.h" 3 4
               int hwloc_obj_add_other_obj_sets(hwloc_obj_t dst, hwloc_obj_t src);
# 2788 "/usr/include/hwloc.h" 3 4
               int hwloc_topology_refresh(hwloc_topology_t topology);






}




# 1 "/usr/include/hwloc/helper.h" 1 3 4
# 20 "/usr/include/hwloc/helper.h" 3 4
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/stdlib.h" 1 3 4
# 21 "/usr/include/hwloc/helper.h" 2 3 4




extern "C" {
# 53 "/usr/include/hwloc/helper.h" 3 4
               int
hwloc_obj_type_is_normal(hwloc_obj_type_t type);
# 64 "/usr/include/hwloc/helper.h" 3 4
               int
hwloc_obj_type_is_io(hwloc_obj_type_t type);
# 75 "/usr/include/hwloc/helper.h" 3 4
               int
hwloc_obj_type_is_memory(hwloc_obj_type_t type);







               int
hwloc_obj_type_is_cache(hwloc_obj_type_t type);







               int
hwloc_obj_type_is_dcache(hwloc_obj_type_t type);







               int
hwloc_obj_type_is_icache(hwloc_obj_type_t type);
# 122 "/usr/include/hwloc/helper.h" 3 4
static inline hwloc_obj_t
hwloc_get_first_largest_obj_inside_cpuset(hwloc_topology_t topology, hwloc_const_cpuset_t set)
{
  hwloc_obj_t obj = hwloc_get_root_obj(topology);
  if (!hwloc_bitmap_intersects(obj->cpuset, set))
    return __null;
  while (!hwloc_bitmap_isincluded(obj->cpuset, set)) {

    hwloc_obj_t child = obj->first_child;
    while (child) {
      if (hwloc_bitmap_intersects(child->cpuset, set))
 break;
      child = child->next_sibling;
    }
    if (!child)

      return obj;

    obj = child;
  }

  return obj;
}






               int hwloc_get_largest_objs_inside_cpuset (hwloc_topology_t topology, hwloc_const_cpuset_t set,
       hwloc_obj_t * __restrict objs, int max);
# 169 "/usr/include/hwloc/helper.h" 3 4
static inline hwloc_obj_t
hwloc_get_next_obj_inside_cpuset_by_depth (hwloc_topology_t topology, hwloc_const_cpuset_t set,
        int depth, hwloc_obj_t prev)
{
  hwloc_obj_t next = hwloc_get_next_obj_by_depth(topology, depth, prev);
  if (!next)
    return __null;
  while (next && (hwloc_bitmap_iszero(next->cpuset) || !hwloc_bitmap_isincluded(next->cpuset, set)))
    next = next->next_cousin;
  return next;
}
# 199 "/usr/include/hwloc/helper.h" 3 4
static inline hwloc_obj_t
hwloc_get_next_obj_inside_cpuset_by_type (hwloc_topology_t topology, hwloc_const_cpuset_t set,
       hwloc_obj_type_t type, hwloc_obj_t prev)
{
  int depth = hwloc_get_type_depth(topology, type);
  if (depth == HWLOC_TYPE_DEPTH_UNKNOWN || depth == HWLOC_TYPE_DEPTH_MULTIPLE)
    return __null;
  return hwloc_get_next_obj_inside_cpuset_by_depth(topology, set, depth, prev);
}
# 219 "/usr/include/hwloc/helper.h" 3 4
static inline hwloc_obj_t
hwloc_get_obj_inside_cpuset_by_depth (hwloc_topology_t topology, hwloc_const_cpuset_t set,
          int depth, unsigned idx) __attribute__((__pure__));
static inline hwloc_obj_t
hwloc_get_obj_inside_cpuset_by_depth (hwloc_topology_t topology, hwloc_const_cpuset_t set,
          int depth, unsigned idx)
{
  hwloc_obj_t obj = hwloc_get_obj_by_depth (topology, depth, 0);
  unsigned count = 0;
  if (!obj)
    return __null;
  while (obj) {
    if (!hwloc_bitmap_iszero(obj->cpuset) && hwloc_bitmap_isincluded(obj->cpuset, set)) {
      if (count == idx)
 return obj;
      count++;
    }
    obj = obj->next_cousin;
  }
  return __null;
}
# 255 "/usr/include/hwloc/helper.h" 3 4
static inline hwloc_obj_t
hwloc_get_obj_inside_cpuset_by_type (hwloc_topology_t topology, hwloc_const_cpuset_t set,
         hwloc_obj_type_t type, unsigned idx) __attribute__((__pure__));
static inline hwloc_obj_t
hwloc_get_obj_inside_cpuset_by_type (hwloc_topology_t topology, hwloc_const_cpuset_t set,
         hwloc_obj_type_t type, unsigned idx)
{
  int depth = hwloc_get_type_depth(topology, type);
  if (depth == HWLOC_TYPE_DEPTH_UNKNOWN || depth == HWLOC_TYPE_DEPTH_MULTIPLE)
    return __null;
  return hwloc_get_obj_inside_cpuset_by_depth(topology, set, depth, idx);
}
# 279 "/usr/include/hwloc/helper.h" 3 4
static inline unsigned
hwloc_get_nbobjs_inside_cpuset_by_depth (hwloc_topology_t topology, hwloc_const_cpuset_t set,
      int depth) __attribute__((__pure__));
static inline unsigned
hwloc_get_nbobjs_inside_cpuset_by_depth (hwloc_topology_t topology, hwloc_const_cpuset_t set,
      int depth)
{
  hwloc_obj_t obj = hwloc_get_obj_by_depth (topology, depth, 0);
  unsigned count = 0;
  if (!obj)
    return 0;
  while (obj) {
    if (!hwloc_bitmap_iszero(obj->cpuset) && hwloc_bitmap_isincluded(obj->cpuset, set))
      count++;
    obj = obj->next_cousin;
  }
  return count;
}
# 311 "/usr/include/hwloc/helper.h" 3 4
static inline int
hwloc_get_nbobjs_inside_cpuset_by_type (hwloc_topology_t topology, hwloc_const_cpuset_t set,
     hwloc_obj_type_t type) __attribute__((__pure__));
static inline int
hwloc_get_nbobjs_inside_cpuset_by_type (hwloc_topology_t topology, hwloc_const_cpuset_t set,
     hwloc_obj_type_t type)
{
  int depth = hwloc_get_type_depth(topology, type);
  if (depth == HWLOC_TYPE_DEPTH_UNKNOWN)
    return 0;
  if (depth == HWLOC_TYPE_DEPTH_MULTIPLE)
    return -1;
  return (int) hwloc_get_nbobjs_inside_cpuset_by_depth(topology, set, depth);
}
# 342 "/usr/include/hwloc/helper.h" 3 4
static inline int
hwloc_get_obj_index_inside_cpuset (hwloc_topology_t topology __attribute__((__unused__)), hwloc_const_cpuset_t set,
       hwloc_obj_t obj) __attribute__((__pure__));
static inline int
hwloc_get_obj_index_inside_cpuset (hwloc_topology_t topology __attribute__((__unused__)), hwloc_const_cpuset_t set,
       hwloc_obj_t obj)
{
  int idx = 0;
  if (!hwloc_bitmap_isincluded(obj->cpuset, set))
    return -1;

  while ((obj = obj->prev_cousin) != __null)
    if (!hwloc_bitmap_iszero(obj->cpuset) && hwloc_bitmap_isincluded(obj->cpuset, set))
      idx++;
  return idx;
}
# 374 "/usr/include/hwloc/helper.h" 3 4
static inline hwloc_obj_t
hwloc_get_child_covering_cpuset (hwloc_topology_t topology __attribute__((__unused__)), hwloc_const_cpuset_t set,
    hwloc_obj_t parent) __attribute__((__pure__));
static inline hwloc_obj_t
hwloc_get_child_covering_cpuset (hwloc_topology_t topology __attribute__((__unused__)), hwloc_const_cpuset_t set,
    hwloc_obj_t parent)
{
  hwloc_obj_t child;
  if (hwloc_bitmap_iszero(set))
    return __null;
  child = parent->first_child;
  while (child) {
    if (child->cpuset && hwloc_bitmap_isincluded(set, child->cpuset))
      return child;
    child = child->next_sibling;
  }
  return __null;
}






static inline hwloc_obj_t
hwloc_get_obj_covering_cpuset (hwloc_topology_t topology, hwloc_const_cpuset_t set) __attribute__((__pure__));
static inline hwloc_obj_t
hwloc_get_obj_covering_cpuset (hwloc_topology_t topology, hwloc_const_cpuset_t set)
{
  struct hwloc_obj *current = hwloc_get_root_obj(topology);
  if (hwloc_bitmap_iszero(set) || !hwloc_bitmap_isincluded(set, current->cpuset))
    return __null;
  while (1) {
    hwloc_obj_t child = hwloc_get_child_covering_cpuset(topology, set, current);
    if (!child)
      return current;
    current = child;
  }
}
# 427 "/usr/include/hwloc/helper.h" 3 4
static inline hwloc_obj_t
hwloc_get_next_obj_covering_cpuset_by_depth(hwloc_topology_t topology, hwloc_const_cpuset_t set,
         int depth, hwloc_obj_t prev)
{
  hwloc_obj_t next = hwloc_get_next_obj_by_depth(topology, depth, prev);
  if (!next)
    return __null;
  while (next && !hwloc_bitmap_intersects(set, next->cpuset))
    next = next->next_cousin;
  return next;
}
# 455 "/usr/include/hwloc/helper.h" 3 4
static inline hwloc_obj_t
hwloc_get_next_obj_covering_cpuset_by_type(hwloc_topology_t topology, hwloc_const_cpuset_t set,
        hwloc_obj_type_t type, hwloc_obj_t prev)
{
  int depth = hwloc_get_type_depth(topology, type);
  if (depth == HWLOC_TYPE_DEPTH_UNKNOWN || depth == HWLOC_TYPE_DEPTH_MULTIPLE)
    return __null;
  return hwloc_get_next_obj_covering_cpuset_by_depth(topology, set, depth, prev);
}
# 488 "/usr/include/hwloc/helper.h" 3 4
static inline hwloc_obj_t
hwloc_get_ancestor_obj_by_depth (hwloc_topology_t topology __attribute__((__unused__)), int depth, hwloc_obj_t obj) __attribute__((__pure__));
static inline hwloc_obj_t
hwloc_get_ancestor_obj_by_depth (hwloc_topology_t topology __attribute__((__unused__)), int depth, hwloc_obj_t obj)
{
  hwloc_obj_t ancestor = obj;
  if (obj->depth < depth)
    return __null;
  while (ancestor && ancestor->depth > depth)
    ancestor = ancestor->parent;
  return ancestor;
}
# 514 "/usr/include/hwloc/helper.h" 3 4
static inline hwloc_obj_t
hwloc_get_ancestor_obj_by_type (hwloc_topology_t topology __attribute__((__unused__)), hwloc_obj_type_t type, hwloc_obj_t obj) __attribute__((__pure__));
static inline hwloc_obj_t
hwloc_get_ancestor_obj_by_type (hwloc_topology_t topology __attribute__((__unused__)), hwloc_obj_type_t type, hwloc_obj_t obj)
{
  hwloc_obj_t ancestor = obj->parent;
  while (ancestor && ancestor->type != type)
    ancestor = ancestor->parent;
  return ancestor;
}







static inline hwloc_obj_t
hwloc_get_common_ancestor_obj (hwloc_topology_t topology __attribute__((__unused__)), hwloc_obj_t obj1, hwloc_obj_t obj2) __attribute__((__pure__));
static inline hwloc_obj_t
hwloc_get_common_ancestor_obj (hwloc_topology_t topology __attribute__((__unused__)), hwloc_obj_t obj1, hwloc_obj_t obj2)
{





  while (obj1 != obj2) {
    while (obj1->depth > obj2->depth)
      obj1 = obj1->parent;
    while (obj2->depth > obj1->depth)
      obj2 = obj2->parent;
    if (obj1 != obj2 && obj1->depth == obj2->depth) {
      obj1 = obj1->parent;
      obj2 = obj2->parent;
    }
  }
  return obj1;
}
# 561 "/usr/include/hwloc/helper.h" 3 4
static inline int
hwloc_obj_is_in_subtree (hwloc_topology_t topology __attribute__((__unused__)), hwloc_obj_t obj, hwloc_obj_t subtree_root) __attribute__((__pure__));
static inline int
hwloc_obj_is_in_subtree (hwloc_topology_t topology __attribute__((__unused__)), hwloc_obj_t obj, hwloc_obj_t subtree_root)
{
  return obj->cpuset && subtree_root->cpuset && hwloc_bitmap_isincluded(obj->cpuset, subtree_root->cpuset);
}
# 579 "/usr/include/hwloc/helper.h" 3 4
static inline hwloc_obj_t
hwloc_get_next_child (hwloc_topology_t topology __attribute__((__unused__)), hwloc_obj_t parent, hwloc_obj_t prev)
{
  hwloc_obj_t obj;
  int state = 0;
  if (prev) {
    if (prev->type == HWLOC_OBJ_MISC)
      state = 3;
    else if (hwloc_obj_type_is_io(prev->type))
      state = 2;
    else if (hwloc_obj_type_is_memory(prev->type))
      state = 1;
    obj = prev->next_sibling;
  } else {
    obj = parent->first_child;
  }
  if (!obj && state == 0) {
    obj = parent->memory_first_child;
    state = 1;
  }
  if (!obj && state == 1) {
    obj = parent->io_first_child;
    state = 2;
  }
  if (!obj && state == 2) {
    obj = parent->misc_first_child;
    state = 3;
  }
  return obj;
}
# 641 "/usr/include/hwloc/helper.h" 3 4
static inline int
hwloc_get_cache_type_depth (hwloc_topology_t topology,
       unsigned cachelevel, hwloc_obj_cache_type_t cachetype)
{
  int depth;
  int found = HWLOC_TYPE_DEPTH_UNKNOWN;
  for (depth=0; ; depth++) {
    hwloc_obj_t obj = hwloc_get_obj_by_depth(topology, depth, 0);
    if (!obj)
      break;
    if (!hwloc_obj_type_is_dcache(obj->type) || obj->attr->cache.depth != cachelevel)

      continue;
    if (cachetype == (hwloc_obj_cache_type_t) -1) {
      if (found != HWLOC_TYPE_DEPTH_UNKNOWN) {

        return HWLOC_TYPE_DEPTH_MULTIPLE;
      }

      found = depth;
      continue;
    }
    if (obj->attr->cache.type == cachetype || obj->attr->cache.type == HWLOC_OBJ_CACHE_UNIFIED)

      return depth;
  }

  return found;
}





static inline hwloc_obj_t
hwloc_get_cache_covering_cpuset (hwloc_topology_t topology, hwloc_const_cpuset_t set) __attribute__((__pure__));
static inline hwloc_obj_t
hwloc_get_cache_covering_cpuset (hwloc_topology_t topology, hwloc_const_cpuset_t set)
{
  hwloc_obj_t current = hwloc_get_obj_covering_cpuset(topology, set);
  while (current) {
    if (hwloc_obj_type_is_dcache(current->type))
      return current;
    current = current->parent;
  }
  return __null;
}






static inline hwloc_obj_t
hwloc_get_shared_cache_covering_obj (hwloc_topology_t topology __attribute__((__unused__)), hwloc_obj_t obj) __attribute__((__pure__));
static inline hwloc_obj_t
hwloc_get_shared_cache_covering_obj (hwloc_topology_t topology __attribute__((__unused__)), hwloc_obj_t obj)
{
  hwloc_obj_t current = obj->parent;
  if (!obj->cpuset)
    return __null;
  while (current) {
    if (!hwloc_bitmap_isequal(current->cpuset, obj->cpuset)
        && hwloc_obj_type_is_dcache(current->type))
      return current;
    current = current->parent;
  }
  return __null;
}
# 742 "/usr/include/hwloc/helper.h" 3 4
               int hwloc_bitmap_singlify_per_core(hwloc_topology_t topology, hwloc_bitmap_t cpuset, unsigned which);
# 755 "/usr/include/hwloc/helper.h" 3 4
static inline hwloc_obj_t
hwloc_get_pu_obj_by_os_index(hwloc_topology_t topology, unsigned os_index) __attribute__((__pure__));
static inline hwloc_obj_t
hwloc_get_pu_obj_by_os_index(hwloc_topology_t topology, unsigned os_index)
{
  hwloc_obj_t obj = __null;
  while ((obj = hwloc_get_next_obj_by_type(topology, HWLOC_OBJ_PU, obj)) != __null)
    if (obj->os_index == os_index)
      return obj;
  return __null;
}
# 778 "/usr/include/hwloc/helper.h" 3 4
static inline hwloc_obj_t
hwloc_get_numanode_obj_by_os_index(hwloc_topology_t topology, unsigned os_index) __attribute__((__pure__));
static inline hwloc_obj_t
hwloc_get_numanode_obj_by_os_index(hwloc_topology_t topology, unsigned os_index)
{
  hwloc_obj_t obj = __null;
  while ((obj = hwloc_get_next_obj_by_type(topology, HWLOC_OBJ_NUMANODE, obj)) != __null)
    if (obj->os_index == os_index)
      return obj;
  return __null;
}
# 802 "/usr/include/hwloc/helper.h" 3 4
               unsigned hwloc_get_closest_objs (hwloc_topology_t topology, hwloc_obj_t src, hwloc_obj_t * __restrict objs, unsigned max);
# 818 "/usr/include/hwloc/helper.h" 3 4
static inline hwloc_obj_t
hwloc_get_obj_below_by_type (hwloc_topology_t topology,
        hwloc_obj_type_t type1, unsigned idx1,
        hwloc_obj_type_t type2, unsigned idx2) __attribute__((__pure__));
static inline hwloc_obj_t
hwloc_get_obj_below_by_type (hwloc_topology_t topology,
        hwloc_obj_type_t type1, unsigned idx1,
        hwloc_obj_type_t type2, unsigned idx2)
{
  hwloc_obj_t obj;
  obj = hwloc_get_obj_by_type (topology, type1, idx1);
  if (!obj)
    return __null;
  return hwloc_get_obj_inside_cpuset_by_type(topology, obj->cpuset, type2, idx2);
}
# 854 "/usr/include/hwloc/helper.h" 3 4
static inline hwloc_obj_t
hwloc_get_obj_below_array_by_type (hwloc_topology_t topology, int nr, hwloc_obj_type_t *typev, unsigned *idxv) __attribute__((__pure__));
static inline hwloc_obj_t
hwloc_get_obj_below_array_by_type (hwloc_topology_t topology, int nr, hwloc_obj_type_t *typev, unsigned *idxv)
{
  hwloc_obj_t obj = hwloc_get_root_obj(topology);
  int i;
  for(i=0; i<nr; i++) {
    if (!obj)
      return __null;
    obj = hwloc_get_obj_inside_cpuset_by_type(topology, obj->cpuset, typev[i], idxv[i]);
  }
  return obj;
}
# 907 "/usr/include/hwloc/helper.h" 3 4
               hwloc_obj_t
hwloc_get_obj_with_same_locality(hwloc_topology_t topology, hwloc_obj_t src,
                                 hwloc_obj_type_t type, const char *subtype, const char *nameprefix,
                                 unsigned long flags);
# 922 "/usr/include/hwloc/helper.h" 3 4
enum hwloc_distrib_flags_e {



  HWLOC_DISTRIB_FLAG_REVERSE = (1UL<<0)
};
# 951 "/usr/include/hwloc/helper.h" 3 4
static inline int
hwloc_distrib(hwloc_topology_t topology,
       hwloc_obj_t *roots, unsigned n_roots,
       hwloc_cpuset_t *set,
       unsigned n,
       int until, unsigned long flags)
{
  unsigned i;
  unsigned tot_weight;
  unsigned given, givenweight;
  hwloc_cpuset_t *cpusetp = set;

  if (flags & ~HWLOC_DISTRIB_FLAG_REVERSE) {
    (*__errno_location ()) = 22;
    return -1;
  }

  tot_weight = 0;
  for (i = 0; i < n_roots; i++)
    tot_weight += (unsigned) hwloc_bitmap_weight(roots[i]->cpuset);

  for (i = 0, given = 0, givenweight = 0; i < n_roots; i++) {
    unsigned chunk, weight;
    hwloc_obj_t root = roots[flags & HWLOC_DISTRIB_FLAG_REVERSE ? n_roots-1-i : i];
    hwloc_cpuset_t cpuset = root->cpuset;
    while (!hwloc_obj_type_is_normal(root->type))

      root = root->parent;
    weight = (unsigned) hwloc_bitmap_weight(cpuset);
    if (!weight)
      continue;


    chunk = (( (givenweight+weight) * n + tot_weight-1) / tot_weight)
          - (( givenweight * n + tot_weight-1) / tot_weight);
    if (!root->arity || chunk <= 1 || root->depth >= until) {

      if (chunk) {

 unsigned j;
 for (j=0; j < chunk; j++)
   cpusetp[j] = hwloc_bitmap_dup(cpuset);
      } else {




 (static_cast <bool> (given) ? void (0) : __assert_fail ("given", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
 hwloc_bitmap_or(cpusetp[-1], cpusetp[-1], cpuset);
      }
    } else {

      hwloc_distrib(topology, root->children, root->arity, cpusetp, chunk, until, flags);
    }
    cpusetp += chunk;
    given += chunk;
    givenweight += weight;
  }

  return 0;
}
# 1032 "/usr/include/hwloc/helper.h" 3 4
               hwloc_const_cpuset_t
hwloc_topology_get_complete_cpuset(hwloc_topology_t topology) __attribute__((__pure__));
# 1048 "/usr/include/hwloc/helper.h" 3 4
               hwloc_const_cpuset_t
hwloc_topology_get_topology_cpuset(hwloc_topology_t topology) __attribute__((__pure__));
# 1069 "/usr/include/hwloc/helper.h" 3 4
               hwloc_const_cpuset_t
hwloc_topology_get_allowed_cpuset(hwloc_topology_t topology) __attribute__((__pure__));
# 1083 "/usr/include/hwloc/helper.h" 3 4
               hwloc_const_nodeset_t
hwloc_topology_get_complete_nodeset(hwloc_topology_t topology) __attribute__((__pure__));
# 1099 "/usr/include/hwloc/helper.h" 3 4
               hwloc_const_nodeset_t
hwloc_topology_get_topology_nodeset(hwloc_topology_t topology) __attribute__((__pure__));
# 1120 "/usr/include/hwloc/helper.h" 3 4
               hwloc_const_nodeset_t
hwloc_topology_get_allowed_nodeset(hwloc_topology_t topology) __attribute__((__pure__));
# 1146 "/usr/include/hwloc/helper.h" 3 4
static inline int
hwloc_cpuset_to_nodeset(hwloc_topology_t topology, hwloc_const_cpuset_t _cpuset, hwloc_nodeset_t nodeset)
{
 int depth = hwloc_get_type_depth(topology, HWLOC_OBJ_NUMANODE);
 hwloc_obj_t obj = __null;
 (static_cast <bool> (depth != HWLOC_TYPE_DEPTH_UNKNOWN) ? void (0) : __assert_fail ("depth != HWLOC_TYPE_DEPTH_UNKNOWN", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
 hwloc_bitmap_zero(nodeset);
 while ((obj = hwloc_get_next_obj_covering_cpuset_by_depth(topology, _cpuset, depth, obj)) != __null)
  if (hwloc_bitmap_set(nodeset, obj->os_index) < 0)
   return -1;
 return 0;
}
# 1173 "/usr/include/hwloc/helper.h" 3 4
static inline int
hwloc_cpuset_from_nodeset(hwloc_topology_t topology, hwloc_cpuset_t _cpuset, hwloc_const_nodeset_t nodeset)
{
 int depth = hwloc_get_type_depth(topology, HWLOC_OBJ_NUMANODE);
 hwloc_obj_t obj = __null;
 (static_cast <bool> (depth != HWLOC_TYPE_DEPTH_UNKNOWN) ? void (0) : __assert_fail ("depth != HWLOC_TYPE_DEPTH_UNKNOWN", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
 hwloc_bitmap_zero(_cpuset);
 while ((obj = hwloc_get_next_obj_by_depth(topology, depth, obj)) != __null) {
  if (hwloc_bitmap_isset(nodeset, obj->os_index))

   if (hwloc_bitmap_or(_cpuset, _cpuset, obj->cpuset) < 0)
    return -1;
 }
 return 0;
}
# 1212 "/usr/include/hwloc/helper.h" 3 4
static inline hwloc_obj_t
hwloc_get_non_io_ancestor_obj(hwloc_topology_t topology __attribute__((__unused__)),
         hwloc_obj_t ioobj)
{
  hwloc_obj_t obj = ioobj;
  while (obj && !obj->cpuset) {
    obj = obj->parent;
  }
  return obj;
}







static inline hwloc_obj_t
hwloc_get_next_pcidev(hwloc_topology_t topology, hwloc_obj_t prev)
{
  return hwloc_get_next_obj_by_type(topology, HWLOC_OBJ_PCI_DEVICE, prev);
}






static inline hwloc_obj_t
hwloc_get_pcidev_by_busid(hwloc_topology_t topology,
     unsigned domain, unsigned bus, unsigned dev, unsigned func)
{
  hwloc_obj_t obj = __null;
  while ((obj = hwloc_get_next_pcidev(topology, obj)) != __null) {
    if (obj->attr->pcidev.domain == domain
 && obj->attr->pcidev.bus == bus
 && obj->attr->pcidev.dev == dev
 && obj->attr->pcidev.func == func)
      return obj;
  }
  return __null;
}






static inline hwloc_obj_t
hwloc_get_pcidev_by_busidstring(hwloc_topology_t topology, const char *busid)
{
  unsigned domain = 0;
  unsigned bus, dev, func;

  if (sscanf(busid, "%x:%x.%x", &bus, &dev, &func) != 3
      && sscanf(busid, "%x:%x:%x.%x", &domain, &bus, &dev, &func) != 4) {
    (*__errno_location ()) = 22;
    return __null;
  }

  return hwloc_get_pcidev_by_busid(topology, domain, bus, dev, func);
}







static inline hwloc_obj_t
hwloc_get_next_osdev(hwloc_topology_t topology, hwloc_obj_t prev)
{
  return hwloc_get_next_obj_by_type(topology, HWLOC_OBJ_OS_DEVICE, prev);
}







static inline hwloc_obj_t
hwloc_get_next_bridge(hwloc_topology_t topology, hwloc_obj_t prev)
{
  return hwloc_get_next_obj_by_type(topology, HWLOC_OBJ_BRIDGE, prev);
}





static inline int
hwloc_bridge_covers_pcibus(hwloc_obj_t bridge,
      unsigned domain, unsigned bus)
{
  return bridge->type == HWLOC_OBJ_BRIDGE
    && bridge->attr->bridge.downstream_type == HWLOC_OBJ_BRIDGE_PCI
    && bridge->attr->bridge.downstream.pci.domain == domain
    && bridge->attr->bridge.downstream.pci.secondary_bus <= bus
    && bridge->attr->bridge.downstream.pci.subordinate_bus >= bus;
}






}
# 2801 "/usr/include/hwloc.h" 2 3 4


# 1 "/usr/include/hwloc/inlines.h" 1 3 4
# 20 "/usr/include/hwloc/inlines.h" 3 4
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/stdlib.h" 1 3 4
# 21 "/usr/include/hwloc/inlines.h" 2 3 4




extern "C" {


static inline int
hwloc_get_type_or_below_depth (hwloc_topology_t topology, hwloc_obj_type_t type)
{
  int depth = hwloc_get_type_depth(topology, type);

  if (depth != HWLOC_TYPE_DEPTH_UNKNOWN)
    return depth;


  for(depth = hwloc_get_type_depth(topology, HWLOC_OBJ_PU); ; depth--)
    if (hwloc_compare_types(hwloc_get_depth_type(topology, depth), type) < 0)
      return depth+1;



}

static inline int
hwloc_get_type_or_above_depth (hwloc_topology_t topology, hwloc_obj_type_t type)
{
  int depth = hwloc_get_type_depth(topology, type);

  if (depth != HWLOC_TYPE_DEPTH_UNKNOWN)
    return depth;


  for(depth = 0; ; depth++)
    if (hwloc_compare_types(hwloc_get_depth_type(topology, depth), type) > 0)
      return depth-1;



}

static inline int
hwloc_get_nbobjs_by_type (hwloc_topology_t topology, hwloc_obj_type_t type)
{
  int depth = hwloc_get_type_depth(topology, type);
  if (depth == HWLOC_TYPE_DEPTH_UNKNOWN)
    return 0;
  if (depth == HWLOC_TYPE_DEPTH_MULTIPLE)
    return -1;
  return (int) hwloc_get_nbobjs_by_depth(topology, depth);
}

static inline hwloc_obj_t
hwloc_get_obj_by_type (hwloc_topology_t topology, hwloc_obj_type_t type, unsigned idx)
{
  int depth = hwloc_get_type_depth(topology, type);
  if (depth == HWLOC_TYPE_DEPTH_UNKNOWN)
    return __null;
  if (depth == HWLOC_TYPE_DEPTH_MULTIPLE)
    return __null;
  return hwloc_get_obj_by_depth(topology, depth, idx);
}

static inline hwloc_obj_t
hwloc_get_next_obj_by_depth (hwloc_topology_t topology, int depth, hwloc_obj_t prev)
{
  if (!prev)
    return hwloc_get_obj_by_depth (topology, depth, 0);
  if (prev->depth != depth)
    return __null;
  return prev->next_cousin;
}

static inline hwloc_obj_t
hwloc_get_next_obj_by_type (hwloc_topology_t topology, hwloc_obj_type_t type,
       hwloc_obj_t prev)
{
  int depth = hwloc_get_type_depth(topology, type);
  if (depth == HWLOC_TYPE_DEPTH_UNKNOWN || depth == HWLOC_TYPE_DEPTH_MULTIPLE)
    return __null;
  return hwloc_get_next_obj_by_depth (topology, depth, prev);
}

static inline hwloc_obj_t
hwloc_get_root_obj (hwloc_topology_t topology)
{
  return hwloc_get_obj_by_depth (topology, 0, 0);
}

static inline const char *
hwloc_obj_get_info_by_name(hwloc_obj_t obj, const char *name)
{
  unsigned i;
  for(i=0; i<obj->infos_count; i++) {
    struct hwloc_info_s *info = &obj->infos[i];
    if (!strcmp(info->name, name))
      return info->value;
  }
  return __null;
}

static inline void *
hwloc_alloc_membind_policy(hwloc_topology_t topology, size_t len, hwloc_const_cpuset_t set, hwloc_membind_policy_t policy, int flags)
{
  void *p = hwloc_alloc_membind(topology, len, set, policy, flags);
  if (p)
    return p;

  if (hwloc_set_membind(topology, set, policy, flags) < 0)

    return __null;

  p = hwloc_alloc(topology, len);
  if (p && policy != HWLOC_MEMBIND_FIRSTTOUCH)

    memset(p, 0, len);
  return p;
}



}
# 2804 "/usr/include/hwloc.h" 2 3 4


# 1 "/usr/include/hwloc/memattrs.h" 1 3 4
# 13 "/usr/include/hwloc/memattrs.h" 3 4
# 1 "/usr/include/hwloc.h" 1 3 4
# 14 "/usr/include/hwloc/memattrs.h" 2 3 4


extern "C" {
# 73 "/usr/include/hwloc/memattrs.h" 3 4
enum hwloc_memattr_id_e {
# 83 "/usr/include/hwloc/memattrs.h" 3 4
  HWLOC_MEMATTR_ID_CAPACITY = 0,
# 98 "/usr/include/hwloc/memattrs.h" 3 4
  HWLOC_MEMATTR_ID_LOCALITY = 1,
# 113 "/usr/include/hwloc/memattrs.h" 3 4
  HWLOC_MEMATTR_ID_BANDWIDTH = 2,
# 124 "/usr/include/hwloc/memattrs.h" 3 4
  HWLOC_MEMATTR_ID_READ_BANDWIDTH = 4,
# 135 "/usr/include/hwloc/memattrs.h" 3 4
  HWLOC_MEMATTR_ID_WRITE_BANDWIDTH = 5,
# 150 "/usr/include/hwloc/memattrs.h" 3 4
  HWLOC_MEMATTR_ID_LATENCY = 3,
# 161 "/usr/include/hwloc/memattrs.h" 3 4
  HWLOC_MEMATTR_ID_READ_LATENCY = 6,
# 172 "/usr/include/hwloc/memattrs.h" 3 4
  HWLOC_MEMATTR_ID_WRITE_LATENCY = 7,



  HWLOC_MEMATTR_ID_MAX
};




typedef unsigned hwloc_memattr_id_t;






               int
hwloc_memattr_get_by_name(hwloc_topology_t topology,
                          const char *name,
                          hwloc_memattr_id_t *id);



enum hwloc_location_type_e {

  HWLOC_LOCATION_TYPE_CPUSET = 1,

  HWLOC_LOCATION_TYPE_OBJECT = 0
};


struct hwloc_location {

  enum hwloc_location_type_e type;

  union hwloc_location_u {

    hwloc_cpuset_t cpuset;

    hwloc_obj_t object;
  } location;
};



enum hwloc_local_numanode_flag_e {





  HWLOC_LOCAL_NUMANODE_FLAG_LARGER_LOCALITY = (1UL<<0),






  HWLOC_LOCAL_NUMANODE_FLAG_SMALLER_LOCALITY = (1UL<<1),





  HWLOC_LOCAL_NUMANODE_FLAG_ALL = (1UL<<2)
};
# 271 "/usr/include/hwloc/memattrs.h" 3 4
               int
hwloc_get_local_numanode_objs(hwloc_topology_t topology,
                              struct hwloc_location *location,
                              unsigned *nr,
                              hwloc_obj_t *nodes,
                              unsigned long flags);
# 298 "/usr/include/hwloc/memattrs.h" 3 4
               int
hwloc_memattr_get_value(hwloc_topology_t topology,
                        hwloc_memattr_id_t attribute,
                        hwloc_obj_t target_node,
                        struct hwloc_location *initiator,
                        unsigned long flags,
                        hwloc_uint64_t *value);
# 334 "/usr/include/hwloc/memattrs.h" 3 4
               int
hwloc_memattr_get_best_target(hwloc_topology_t topology,
                              hwloc_memattr_id_t attribute,
                              struct hwloc_location *initiator,
                              unsigned long flags,
                              hwloc_obj_t *best_target, hwloc_uint64_t *value);
# 362 "/usr/include/hwloc/memattrs.h" 3 4
               int
hwloc_memattr_get_best_initiator(hwloc_topology_t topology,
                                 hwloc_memattr_id_t attribute,
                                 hwloc_obj_t target,
                                 unsigned long flags,
                                 struct hwloc_location *best_initiator, hwloc_uint64_t *value);
# 381 "/usr/include/hwloc/memattrs.h" 3 4
               int
hwloc_memattr_get_name(hwloc_topology_t topology,
                       hwloc_memattr_id_t attribute,
                       const char **name);
# 393 "/usr/include/hwloc/memattrs.h" 3 4
               int
hwloc_memattr_get_flags(hwloc_topology_t topology,
                        hwloc_memattr_id_t attribute,
                        unsigned long *flags);




enum hwloc_memattr_flag_e {



  HWLOC_MEMATTR_FLAG_HIGHER_FIRST = (1UL<<0),



  HWLOC_MEMATTR_FLAG_LOWER_FIRST = (1UL<<1),



  HWLOC_MEMATTR_FLAG_NEED_INITIATOR = (1UL<<2)
};
# 425 "/usr/include/hwloc/memattrs.h" 3 4
               int
hwloc_memattr_register(hwloc_topology_t topology,
                       const char *name,
                       unsigned long flags,
                       hwloc_memattr_id_t *id);
# 451 "/usr/include/hwloc/memattrs.h" 3 4
               int
hwloc_memattr_set_value(hwloc_topology_t topology,
                        hwloc_memattr_id_t attribute,
                        hwloc_obj_t target_node,
                        struct hwloc_location *initiator,
                        unsigned long flags,
                        hwloc_uint64_t value);
# 497 "/usr/include/hwloc/memattrs.h" 3 4
               int
hwloc_memattr_get_targets(hwloc_topology_t topology,
                          hwloc_memattr_id_t attribute,
                          struct hwloc_location *initiator,
                          unsigned long flags,
                          unsigned *nr, hwloc_obj_t *targets, hwloc_uint64_t *values);
# 535 "/usr/include/hwloc/memattrs.h" 3 4
               int
hwloc_memattr_get_initiators(hwloc_topology_t topology,
                             hwloc_memattr_id_t attribute,
                             hwloc_obj_t target_node,
                             unsigned long flags,
                             unsigned *nr, struct hwloc_location *initiators, hwloc_uint64_t *values);



}
# 2807 "/usr/include/hwloc.h" 2 3 4


# 1 "/usr/include/hwloc/cpukinds.h" 1 3 4
# 13 "/usr/include/hwloc/cpukinds.h" 3 4
# 1 "/usr/include/hwloc.h" 1 3 4
# 14 "/usr/include/hwloc/cpukinds.h" 2 3 4


extern "C" {
# 81 "/usr/include/hwloc/cpukinds.h" 3 4
               int
hwloc_cpukinds_get_nr(hwloc_topology_t topology,
                      unsigned long flags);
# 96 "/usr/include/hwloc/cpukinds.h" 3 4
               int
hwloc_cpukinds_get_by_cpuset(hwloc_topology_t topology,
                             hwloc_const_bitmap_t cpuset,
                             unsigned long flags);
# 134 "/usr/include/hwloc/cpukinds.h" 3 4
               int
hwloc_cpukinds_get_info(hwloc_topology_t topology,
                        unsigned kind_index,
                        hwloc_bitmap_t cpuset,
                        int *efficiency,
                        unsigned *nr_infos, struct hwloc_info_s **infos,
                        unsigned long flags);
# 179 "/usr/include/hwloc/cpukinds.h" 3 4
               int
hwloc_cpukinds_register(hwloc_topology_t topology,
                        hwloc_bitmap_t cpuset,
                        int forced_efficiency,
                        unsigned nr_infos, struct hwloc_info_s *infos,
                        unsigned long flags);




}
# 2810 "/usr/include/hwloc.h" 2 3 4


# 1 "/usr/include/hwloc/export.h" 1 3 4
# 21 "/usr/include/hwloc/export.h" 3 4
extern "C" {
# 35 "/usr/include/hwloc/export.h" 3 4
enum hwloc_topology_export_xml_flags_e {




 HWLOC_TOPOLOGY_EXPORT_XML_FLAG_V1 = (1UL<<0)
};
# 71 "/usr/include/hwloc/export.h" 3 4
               int hwloc_topology_export_xml(hwloc_topology_t topology, const char *xmlpath, unsigned long flags);
# 105 "/usr/include/hwloc/export.h" 3 4
               int hwloc_topology_export_xmlbuffer(hwloc_topology_t topology, char **xmlbuffer, int *buflen, unsigned long flags);


               void hwloc_free_xmlbuffer(hwloc_topology_t topology, char *xmlbuffer);
# 128 "/usr/include/hwloc/export.h" 3 4
               void hwloc_topology_set_userdata_export_callback(hwloc_topology_t topology,
        void (*export_cb)(void *reserved, hwloc_topology_t topology, hwloc_obj_t obj));
# 158 "/usr/include/hwloc/export.h" 3 4
               int hwloc_export_obj_userdata(void *reserved, hwloc_topology_t topology, hwloc_obj_t obj, const char *name, const void *buffer, size_t length);
# 179 "/usr/include/hwloc/export.h" 3 4
               int hwloc_export_obj_userdata_base64(void *reserved, hwloc_topology_t topology, hwloc_obj_t obj, const char *name, const void *buffer, size_t length);
# 203 "/usr/include/hwloc/export.h" 3 4
               void hwloc_topology_set_userdata_import_callback(hwloc_topology_t topology,
        void (*import_cb)(hwloc_topology_t topology, hwloc_obj_t obj, const char *name, const void *buffer, size_t length));
# 217 "/usr/include/hwloc/export.h" 3 4
enum hwloc_topology_export_synthetic_flags_e {





 HWLOC_TOPOLOGY_EXPORT_SYNTHETIC_FLAG_NO_EXTENDED_TYPES = (1UL<<0),







 HWLOC_TOPOLOGY_EXPORT_SYNTHETIC_FLAG_NO_ATTRS = (1UL<<1),
# 241 "/usr/include/hwloc/export.h" 3 4
 HWLOC_TOPOLOGY_EXPORT_SYNTHETIC_FLAG_V1 = (1UL<<2),
# 251 "/usr/include/hwloc/export.h" 3 4
 HWLOC_TOPOLOGY_EXPORT_SYNTHETIC_FLAG_IGNORE_MEMORY = (1UL<<3)
};
# 275 "/usr/include/hwloc/export.h" 3 4
                 int hwloc_topology_export_synthetic(hwloc_topology_t topology, char *buffer, size_t buflen, unsigned long flags);






}
# 2813 "/usr/include/hwloc.h" 2 3 4


# 1 "/usr/include/hwloc/distances.h" 1 3 4
# 19 "/usr/include/hwloc/distances.h" 3 4
extern "C" {
# 53 "/usr/include/hwloc/distances.h" 3 4
struct hwloc_distances_s {
  unsigned nbobjs;
  hwloc_obj_t *objs;




  unsigned long kind;
  hwloc_uint64_t *values;




};
# 79 "/usr/include/hwloc/distances.h" 3 4
enum hwloc_distances_kind_e {



  HWLOC_DISTANCES_KIND_FROM_OS = (1UL<<0),



  HWLOC_DISTANCES_KIND_FROM_USER = (1UL<<1),







  HWLOC_DISTANCES_KIND_MEANS_LATENCY = (1UL<<2),






  HWLOC_DISTANCES_KIND_MEANS_BANDWIDTH = (1UL<<3),






  HWLOC_DISTANCES_KIND_HETEROGENEOUS_TYPES = (1UL<<4)
};
# 137 "/usr/include/hwloc/distances.h" 3 4
               int
hwloc_distances_get(hwloc_topology_t topology,
      unsigned *nr, struct hwloc_distances_s **distances,
      unsigned long kind, unsigned long flags);







               int
hwloc_distances_get_by_depth(hwloc_topology_t topology, int depth,
        unsigned *nr, struct hwloc_distances_s **distances,
        unsigned long kind, unsigned long flags);







               int
hwloc_distances_get_by_type(hwloc_topology_t topology, hwloc_obj_type_t type,
       unsigned *nr, struct hwloc_distances_s **distances,
       unsigned long kind, unsigned long flags);
# 174 "/usr/include/hwloc/distances.h" 3 4
               int
hwloc_distances_get_by_name(hwloc_topology_t topology, const char *name,
       unsigned *nr, struct hwloc_distances_s **distances,
       unsigned long flags);
# 189 "/usr/include/hwloc/distances.h" 3 4
               const char *
hwloc_distances_get_name(hwloc_topology_t topology, struct hwloc_distances_s *distances);





               void
hwloc_distances_release(hwloc_topology_t topology, struct hwloc_distances_s *distances);


enum hwloc_distances_transform_e {
# 214 "/usr/include/hwloc/distances.h" 3 4
  HWLOC_DISTANCES_TRANSFORM_REMOVE_NULL = 0,
# 228 "/usr/include/hwloc/distances.h" 3 4
  HWLOC_DISTANCES_TRANSFORM_LINKS = 1,
# 237 "/usr/include/hwloc/distances.h" 3 4
  HWLOC_DISTANCES_TRANSFORM_MERGE_SWITCH_PORTS = 2,






  HWLOC_DISTANCES_TRANSFORM_TRANSITIVE_CLOSURE = 3
};
# 275 "/usr/include/hwloc/distances.h" 3 4
               int hwloc_distances_transform(hwloc_topology_t topology, struct hwloc_distances_s *distances,
                                             enum hwloc_distances_transform_e transform,
                                             void *transform_attr,
                                             unsigned long flags);
# 293 "/usr/include/hwloc/distances.h" 3 4
static inline int
hwloc_distances_obj_index(struct hwloc_distances_s *distances, hwloc_obj_t obj)
{
  unsigned i;
  for(i=0; i<distances->nbobjs; i++)
    if (distances->objs[i] == obj)
      return (int)i;
  return -1;
}
# 311 "/usr/include/hwloc/distances.h" 3 4
static inline int
hwloc_distances_obj_pair_values(struct hwloc_distances_s *distances,
    hwloc_obj_t obj1, hwloc_obj_t obj2,
    hwloc_uint64_t *value1to2, hwloc_uint64_t *value2to1)
{
  int i1 = hwloc_distances_obj_index(distances, obj1);
  int i2 = hwloc_distances_obj_index(distances, obj2);
  if (i1 < 0 || i2 < 0)
    return -1;
  *value1to2 = distances->values[i1 * distances->nbobjs + i2];
  *value2to1 = distances->values[i2 * distances->nbobjs + i1];
  return 0;
}
# 348 "/usr/include/hwloc/distances.h" 3 4
typedef void * hwloc_distances_add_handle_t;
# 370 "/usr/include/hwloc/distances.h" 3 4
               hwloc_distances_add_handle_t
hwloc_distances_add_create(hwloc_topology_t topology,
                           const char *name, unsigned long kind,
                           unsigned long flags);
# 397 "/usr/include/hwloc/distances.h" 3 4
               int hwloc_distances_add_values(hwloc_topology_t topology,
                                              hwloc_distances_add_handle_t handle,
                                              unsigned nbobjs, hwloc_obj_t *objs,
                                              hwloc_uint64_t *values,
                                              unsigned long flags);


enum hwloc_distances_add_flag_e {




  HWLOC_DISTANCES_ADD_FLAG_GROUP = (1UL<<0),





  HWLOC_DISTANCES_ADD_FLAG_GROUP_INACCURATE = (1UL<<1)
};
# 434 "/usr/include/hwloc/distances.h" 3 4
               int hwloc_distances_add_commit(hwloc_topology_t topology,
                                              hwloc_distances_add_handle_t handle,
                                              unsigned long flags);
# 456 "/usr/include/hwloc/distances.h" 3 4
               int hwloc_distances_remove(hwloc_topology_t topology);







               int hwloc_distances_remove_by_depth(hwloc_topology_t topology, int depth);







static inline int
hwloc_distances_remove_by_type(hwloc_topology_t topology, hwloc_obj_type_t type)
{
  int depth = hwloc_get_type_depth(topology, type);
  if (depth == HWLOC_TYPE_DEPTH_UNKNOWN || depth == HWLOC_TYPE_DEPTH_MULTIPLE)
    return 0;
  return hwloc_distances_remove_by_depth(topology, depth);
}







               int hwloc_distances_release_remove(hwloc_topology_t topology, struct hwloc_distances_s *distances);





}
# 2816 "/usr/include/hwloc.h" 2 3 4


# 1 "/usr/include/hwloc/diff.h" 1 3 4
# 19 "/usr/include/hwloc/diff.h" 3 4
extern "C" {
# 62 "/usr/include/hwloc/diff.h" 3 4
typedef enum hwloc_topology_diff_obj_attr_type_e {




  HWLOC_TOPOLOGY_DIFF_OBJ_ATTR_SIZE,






  HWLOC_TOPOLOGY_DIFF_OBJ_ATTR_NAME,



  HWLOC_TOPOLOGY_DIFF_OBJ_ATTR_INFO
} hwloc_topology_diff_obj_attr_type_t;



union hwloc_topology_diff_obj_attr_u {
  struct hwloc_topology_diff_obj_attr_generic_s {

    hwloc_topology_diff_obj_attr_type_t type;
  } generic;


  struct hwloc_topology_diff_obj_attr_uint64_s {

    hwloc_topology_diff_obj_attr_type_t type;
    hwloc_uint64_t index;
    hwloc_uint64_t oldvalue;
    hwloc_uint64_t newvalue;
  } uint64;


  struct hwloc_topology_diff_obj_attr_string_s {

    hwloc_topology_diff_obj_attr_type_t type;
    char *name;
    char *oldvalue;
    char *newvalue;
  } string;
};




typedef enum hwloc_topology_diff_type_e {



  HWLOC_TOPOLOGY_DIFF_OBJ_ATTR,
# 124 "/usr/include/hwloc/diff.h" 3 4
  HWLOC_TOPOLOGY_DIFF_TOO_COMPLEX
} hwloc_topology_diff_type_t;



typedef union hwloc_topology_diff_u {
  struct hwloc_topology_diff_generic_s {

    hwloc_topology_diff_type_t type;
    union hwloc_topology_diff_u * next;
  } generic;


  struct hwloc_topology_diff_obj_attr_s {
    hwloc_topology_diff_type_t type;
    union hwloc_topology_diff_u * next;

    int obj_depth;
    unsigned obj_index;
    union hwloc_topology_diff_obj_attr_u diff;
  } obj_attr;


  struct hwloc_topology_diff_too_complex_s {
    hwloc_topology_diff_type_t type;
    union hwloc_topology_diff_u * next;

    int obj_depth;
    unsigned obj_index;
  } too_complex;
} * hwloc_topology_diff_t;
# 194 "/usr/include/hwloc/diff.h" 3 4
               int hwloc_topology_diff_build(hwloc_topology_t topology, hwloc_topology_t newtopology, unsigned long flags, hwloc_topology_diff_t *diff);



enum hwloc_topology_diff_apply_flags_e {



  HWLOC_TOPOLOGY_DIFF_APPLY_REVERSE = (1UL<<0)
};
# 222 "/usr/include/hwloc/diff.h" 3 4
               int hwloc_topology_diff_apply(hwloc_topology_t topology, hwloc_topology_diff_t diff, unsigned long flags);





               int hwloc_topology_diff_destroy(hwloc_topology_diff_t diff);
# 243 "/usr/include/hwloc/diff.h" 3 4
               int hwloc_topology_diff_load_xml(const char *xmlpath, hwloc_topology_diff_t *diff, char **refname);
# 256 "/usr/include/hwloc/diff.h" 3 4
               int hwloc_topology_diff_export_xml(hwloc_topology_diff_t diff, const char *refname, const char *xmlpath);
# 276 "/usr/include/hwloc/diff.h" 3 4
               int hwloc_topology_diff_load_xmlbuffer(const char *xmlbuffer, int buflen, hwloc_topology_diff_t *diff, char **refname);
# 294 "/usr/include/hwloc/diff.h" 3 4
               int hwloc_topology_diff_export_xmlbuffer(hwloc_topology_diff_t diff, const char *refname, char **xmlbuffer, int *buflen);





}
# 2819 "/usr/include/hwloc.h" 2 3 4


# 1 "/usr/include/hwloc/deprecated.h" 1 3 4
# 21 "/usr/include/hwloc/deprecated.h" 3 4
extern "C" {
# 38 "/usr/include/hwloc/deprecated.h" 3 4
               int hwloc_distances_add(hwloc_topology_t topology,
           unsigned nbobjs, hwloc_obj_t *objs, hwloc_uint64_t *values,
           unsigned long kind, unsigned long flags) __attribute__((__deprecated__));





static inline hwloc_obj_t
hwloc_topology_insert_misc_object_by_parent(hwloc_topology_t topology, hwloc_obj_t parent, const char *name) __attribute__((__deprecated__));
static inline hwloc_obj_t
hwloc_topology_insert_misc_object_by_parent(hwloc_topology_t topology, hwloc_obj_t parent, const char *name)
{
  return hwloc_topology_insert_misc_object(topology, parent, name);
}
# 61 "/usr/include/hwloc/deprecated.h" 3 4
static inline int
hwloc_obj_cpuset_snprintf(char *str, size_t size, size_t nobj, struct hwloc_obj * const *objs) __attribute__((__deprecated__));
static inline int
hwloc_obj_cpuset_snprintf(char *str, size_t size, size_t nobj, struct hwloc_obj * const *objs)
{
  hwloc_bitmap_t set = hwloc_bitmap_alloc();
  int res;
  unsigned i;

  hwloc_bitmap_zero(set);
  for(i=0; i<nobj; i++)
    if (objs[i]->cpuset)
      hwloc_bitmap_or(set, set, objs[i]->cpuset);

  res = hwloc_bitmap_snprintf(str, size, set);
  hwloc_bitmap_free(set);
  return res;
}





static inline int
hwloc_obj_type_sscanf(const char *string, hwloc_obj_type_t *typep, int *depthattrp, void *typeattrp, size_t typeattrsize) __attribute__((__deprecated__));
static inline int
hwloc_obj_type_sscanf(const char *string, hwloc_obj_type_t *typep, int *depthattrp, void *typeattrp, size_t typeattrsize)
{
  union hwloc_obj_attr_u attr;
  int err = hwloc_type_sscanf(string, typep, &attr, sizeof(attr));
  if (err < 0)
    return err;
  if (hwloc_obj_type_is_cache(*typep)) {
    if (depthattrp)
      *depthattrp = (int) attr.cache.depth;
    if (typeattrp && typeattrsize >= sizeof(hwloc_obj_cache_type_t))
      memcpy(typeattrp, &attr.cache.type, sizeof(hwloc_obj_cache_type_t));
  } else if (*typep == HWLOC_OBJ_GROUP) {
    if (depthattrp)
      *depthattrp = (int) attr.group.depth;
  }
  return 0;
}




static inline int
hwloc_set_membind_nodeset(hwloc_topology_t topology, hwloc_const_nodeset_t nodeset, hwloc_membind_policy_t policy, int flags) __attribute__((__deprecated__));
static inline int
hwloc_set_membind_nodeset(hwloc_topology_t topology, hwloc_const_nodeset_t nodeset, hwloc_membind_policy_t policy, int flags)
{
  return hwloc_set_membind(topology, nodeset, policy, flags | HWLOC_MEMBIND_BYNODESET);
}




static inline int
hwloc_get_membind_nodeset(hwloc_topology_t topology, hwloc_nodeset_t nodeset, hwloc_membind_policy_t * policy, int flags) __attribute__((__deprecated__));
static inline int
hwloc_get_membind_nodeset(hwloc_topology_t topology, hwloc_nodeset_t nodeset, hwloc_membind_policy_t * policy, int flags)
{
  return hwloc_get_membind(topology, nodeset, policy, flags | HWLOC_MEMBIND_BYNODESET);
}




static inline int
hwloc_set_proc_membind_nodeset(hwloc_topology_t topology, pid_t pid, hwloc_const_nodeset_t nodeset, hwloc_membind_policy_t policy, int flags) __attribute__((__deprecated__));
static inline int
hwloc_set_proc_membind_nodeset(hwloc_topology_t topology, pid_t pid, hwloc_const_nodeset_t nodeset, hwloc_membind_policy_t policy, int flags)
{
  return hwloc_set_proc_membind(topology, pid, nodeset, policy, flags | HWLOC_MEMBIND_BYNODESET);
}




static inline int
hwloc_get_proc_membind_nodeset(hwloc_topology_t topology, pid_t pid, hwloc_nodeset_t nodeset, hwloc_membind_policy_t * policy, int flags) __attribute__((__deprecated__));
static inline int
hwloc_get_proc_membind_nodeset(hwloc_topology_t topology, pid_t pid, hwloc_nodeset_t nodeset, hwloc_membind_policy_t * policy, int flags)
{
  return hwloc_get_proc_membind(topology, pid, nodeset, policy, flags | HWLOC_MEMBIND_BYNODESET);
}




static inline int
hwloc_set_area_membind_nodeset(hwloc_topology_t topology, const void *addr, size_t len, hwloc_const_nodeset_t nodeset, hwloc_membind_policy_t policy, int flags) __attribute__((__deprecated__));
static inline int
hwloc_set_area_membind_nodeset(hwloc_topology_t topology, const void *addr, size_t len, hwloc_const_nodeset_t nodeset, hwloc_membind_policy_t policy, int flags)
{
  return hwloc_set_area_membind(topology, addr, len, nodeset, policy, flags | HWLOC_MEMBIND_BYNODESET);
}




static inline int
hwloc_get_area_membind_nodeset(hwloc_topology_t topology, const void *addr, size_t len, hwloc_nodeset_t nodeset, hwloc_membind_policy_t * policy, int flags) __attribute__((__deprecated__));
static inline int
hwloc_get_area_membind_nodeset(hwloc_topology_t topology, const void *addr, size_t len, hwloc_nodeset_t nodeset, hwloc_membind_policy_t * policy, int flags)
{
  return hwloc_get_area_membind(topology, addr, len, nodeset, policy, flags | HWLOC_MEMBIND_BYNODESET);
}



static inline void *
hwloc_alloc_membind_nodeset(hwloc_topology_t topology, size_t len, hwloc_const_nodeset_t nodeset, hwloc_membind_policy_t policy, int flags) __attribute__((__malloc__)) __attribute__((__deprecated__));
static inline void *
hwloc_alloc_membind_nodeset(hwloc_topology_t topology, size_t len, hwloc_const_nodeset_t nodeset, hwloc_membind_policy_t policy, int flags)
{
  return hwloc_alloc_membind(topology, len, nodeset, policy, flags | HWLOC_MEMBIND_BYNODESET);
}



static inline void *
hwloc_alloc_membind_policy_nodeset(hwloc_topology_t topology, size_t len, hwloc_const_nodeset_t nodeset, hwloc_membind_policy_t policy, int flags) __attribute__((__malloc__)) __attribute__((__deprecated__));
static inline void *
hwloc_alloc_membind_policy_nodeset(hwloc_topology_t topology, size_t len, hwloc_const_nodeset_t nodeset, hwloc_membind_policy_t policy, int flags)
{
  return hwloc_alloc_membind_policy(topology, len, nodeset, policy, flags | HWLOC_MEMBIND_BYNODESET);
}



static inline void
hwloc_cpuset_to_nodeset_strict(hwloc_topology_t topology, hwloc_const_cpuset_t _cpuset, hwloc_nodeset_t nodeset) __attribute__((__deprecated__));
static inline void
hwloc_cpuset_to_nodeset_strict(hwloc_topology_t topology, hwloc_const_cpuset_t _cpuset, hwloc_nodeset_t nodeset)
{
  hwloc_cpuset_to_nodeset(topology, _cpuset, nodeset);
}



static inline void
hwloc_cpuset_from_nodeset_strict(hwloc_topology_t topology, hwloc_cpuset_t _cpuset, hwloc_const_nodeset_t nodeset) __attribute__((__deprecated__));
static inline void
hwloc_cpuset_from_nodeset_strict(hwloc_topology_t topology, hwloc_cpuset_t _cpuset, hwloc_const_nodeset_t nodeset)
{
  hwloc_cpuset_from_nodeset(topology, _cpuset, nodeset);
}



}
# 2822 "/usr/include/hwloc.h" 2 3 4
# 39 "/home/avi/scylla-maint/seastar/include/seastar/core/resource.hh" 2



namespace seastar {

cpu_set_t cpuid_to_cpuset(unsigned cpuid);
class io_queue;
class io_group;

namespace resource {

using std::optional;

using cpuset = std::set<unsigned>;


std::optional<cpuset> parse_cpuset(std::string value);


namespace hwloc::internal {


class topology_holder {
    hwloc_topology_t _topology;

public:
    topology_holder() noexcept
        : _topology(nullptr)
    { }

    topology_holder(topology_holder&& o) noexcept;

    ~topology_holder();

    topology_holder& operator=(topology_holder&& o) noexcept;

    operator bool() const noexcept {
        return _topology != nullptr;
    }

    void init_and_load();
    hwloc_topology_t get();
};







}



struct configuration {
    optional<size_t> total_memory;
    optional<size_t> reserve_memory;
    size_t reserve_additional_memory_per_shard;
    size_t cpus;
    cpuset cpu_set;
    bool assign_orphan_cpus = false;
    std::vector<dev_t> devices;
    unsigned num_io_groups;
    hwloc::internal::topology_holder topology;
};

struct memory {
    size_t bytes;
    unsigned nodeid;

};

struct io_queue_topology {
    std::vector<std::unique_ptr<io_queue>> queues;
    std::vector<unsigned> shard_to_group;
    std::vector<unsigned> shards_in_group;
    std::vector<std::shared_ptr<io_group>> groups;

    util::spinlock lock;

    io_queue_topology();
    io_queue_topology(const io_queue_topology&) = delete;
    io_queue_topology(io_queue_topology&&);
    ~io_queue_topology();
};

struct cpu {
    unsigned cpu_id;
    std::vector<memory> mem;
};

struct resources {
    std::vector<cpu> cpus;
    std::unordered_map<dev_t, io_queue_topology> ioq_topology;
    std::unordered_map<unsigned , cpuset> numa_node_id_to_cpuset;
};

resources allocate(configuration& c);
unsigned nr_processing_units(configuration& c);



std::optional<resource::cpuset> parse_cpuset(std::string value);


}
}
# 31 "/home/avi/scylla-maint/seastar/include/seastar/core/smp.hh" 2




# 1 "/usr/include/boost/lockfree/spsc_queue.hpp" 1 3 4
# 16 "/usr/include/boost/lockfree/spsc_queue.hpp" 3 4
# 1 "/usr/include/boost/aligned_storage.hpp" 1 3 4
# 16 "/usr/include/boost/aligned_storage.hpp" 3 4
# 1 "/usr/include/boost/type_traits/aligned_storage.hpp" 1 3 4
# 21 "/usr/include/boost/type_traits/aligned_storage.hpp" 3 4
# 1 "/usr/include/boost/type_traits/type_with_alignment.hpp" 1 3 4
# 12 "/usr/include/boost/type_traits/type_with_alignment.hpp" 3 4
# 1 "/usr/include/boost/type_traits/is_pod.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/is_pod.hpp" 3 4
# 1 "/usr/include/boost/type_traits/is_scalar.hpp" 1 3 4
# 12 "/usr/include/boost/type_traits/is_scalar.hpp" 3 4
# 1 "/usr/include/boost/type_traits/is_arithmetic.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/is_arithmetic.hpp" 3 4
namespace boost {

template <class T>
struct is_arithmetic : public integral_constant<bool, is_integral<T>::value || is_floating_point<T>::value> {};

}
# 13 "/usr/include/boost/type_traits/is_scalar.hpp" 2 3 4

# 1 "/usr/include/boost/type_traits/is_pointer.hpp" 1 3 4
# 26 "/usr/include/boost/type_traits/is_pointer.hpp" 3 4
namespace boost {




template <class T> struct is_pointer : public false_type{};
template <class T> struct is_pointer<T*> : public true_type{};
template <class T> struct is_pointer<T*const> : public true_type{};
template <class T> struct is_pointer<T*const volatile> : public true_type{};
template <class T> struct is_pointer<T*volatile> : public true_type{};
# 45 "/usr/include/boost/type_traits/is_pointer.hpp" 3 4
}
# 15 "/usr/include/boost/type_traits/is_scalar.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/is_member_pointer.hpp" 1 3 4
# 25 "/usr/include/boost/type_traits/is_member_pointer.hpp" 3 4
# 1 "/usr/include/boost/type_traits/is_member_function_pointer.hpp" 1 3 4
# 18 "/usr/include/boost/type_traits/is_member_function_pointer.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/is_member_function_pointer_cxx_11.hpp" 1 3 4
# 16 "/usr/include/boost/type_traits/detail/is_member_function_pointer_cxx_11.hpp" 3 4
namespace boost {
# 25 "/usr/include/boost/type_traits/detail/is_member_function_pointer_cxx_11.hpp" 3 4
   template <class T>
   struct is_member_function_pointer : public false_type {};
   template <class T>
   struct is_member_function_pointer<T const> : public is_member_function_pointer<T> {};
   template <class T>
   struct is_member_function_pointer<T volatile> : public is_member_function_pointer<T> {};
   template <class T>
   struct is_member_function_pointer<T const volatile> : public is_member_function_pointer<T> {};
# 47 "/usr/include/boost/type_traits/detail/is_member_function_pointer_cxx_11.hpp" 3 4
   template <class Ret, class C, class...Args , bool NE>
   struct is_member_function_pointer<Ret ( C::*)(Args...)noexcept(NE)> : public true_type {};
   template <class Ret, class C, class ...Args , bool NE>
   struct is_member_function_pointer<Ret (C::*)(Args..., ...)noexcept(NE)> : public true_type {};

   template <class Ret, class C, class...Args , bool NE>
   struct is_member_function_pointer<Ret ( C::*)(Args...)const noexcept(NE)> : public true_type {};
   template <class Ret, class C, class ...Args , bool NE>
   struct is_member_function_pointer<Ret(C::*)(Args..., ...)const noexcept(NE)> : public true_type {};

   template <class Ret, class C, class...Args , bool NE>
   struct is_member_function_pointer<Ret ( C::*)(Args...)volatile noexcept(NE)> : public true_type {};
   template <class Ret, class C, class ...Args , bool NE>
   struct is_member_function_pointer<Ret(C::*)(Args..., ...)volatile noexcept(NE)> : public true_type {};

   template <class Ret, class C, class...Args , bool NE>
   struct is_member_function_pointer<Ret ( C::*)(Args...)const volatile noexcept(NE)> : public true_type {};
   template <class Ret, class C, class ...Args , bool NE>
   struct is_member_function_pointer<Ret(C::*)(Args..., ...)const volatile noexcept(NE)> : public true_type {};



   template <class Ret, class C, class...Args , bool NE>
   struct is_member_function_pointer<Ret ( C::*)(Args...)& noexcept(NE)> : public true_type {};
   template <class Ret, class C, class ...Args , bool NE>
   struct is_member_function_pointer<Ret(C::*)(Args..., ...)& noexcept(NE)> : public true_type {};

   template <class Ret, class C, class...Args , bool NE>
   struct is_member_function_pointer<Ret ( C::*)(Args...)const & noexcept(NE)> : public true_type {};
   template <class Ret, class C, class ...Args , bool NE>
   struct is_member_function_pointer<Ret(C::*)(Args..., ...)const & noexcept(NE)> : public true_type {};

   template <class Ret, class C, class...Args , bool NE>
   struct is_member_function_pointer<Ret ( C::*)(Args...)volatile & noexcept(NE)> : public true_type {};
   template <class Ret, class C, class ...Args , bool NE>
   struct is_member_function_pointer<Ret(C::*)(Args..., ...)volatile & noexcept(NE)> : public true_type {};

   template <class Ret, class C, class...Args , bool NE>
   struct is_member_function_pointer<Ret ( C::*)(Args...)const volatile & noexcept(NE)> : public true_type {};
   template <class Ret, class C, class ...Args , bool NE>
   struct is_member_function_pointer<Ret(C::*)(Args..., ...)const volatile & noexcept(NE)> : public true_type {};



   template <class Ret, class C, class...Args , bool NE>
   struct is_member_function_pointer<Ret ( C::*)(Args...) && noexcept(NE)> : public true_type {};
   template <class Ret, class C, class ...Args , bool NE>
   struct is_member_function_pointer<Ret(C::*)(Args..., ...) && noexcept(NE)> : public true_type {};

   template <class Ret, class C, class...Args , bool NE>
   struct is_member_function_pointer<Ret ( C::*)(Args...)const && noexcept(NE)> : public true_type {};
   template <class Ret, class C, class ...Args , bool NE>
   struct is_member_function_pointer<Ret(C::*)(Args..., ...)const && noexcept(NE)> : public true_type {};

   template <class Ret, class C, class...Args , bool NE>
   struct is_member_function_pointer<Ret ( C::*)(Args...)volatile && noexcept(NE)> : public true_type {};
   template <class Ret, class C, class ...Args , bool NE>
   struct is_member_function_pointer<Ret(C::*)(Args..., ...)volatile && noexcept(NE)> : public true_type {};

   template <class Ret, class C, class...Args , bool NE>
   struct is_member_function_pointer<Ret ( C::*)(Args...)const volatile && noexcept(NE)> : public true_type {};
   template <class Ret, class C, class ...Args , bool NE>
   struct is_member_function_pointer<Ret(C::*)(Args..., ...)const volatile && noexcept(NE)> : public true_type {};
# 695 "/usr/include/boost/type_traits/detail/is_member_function_pointer_cxx_11.hpp" 3 4
}
# 19 "/usr/include/boost/type_traits/is_member_function_pointer.hpp" 2 3 4
# 26 "/usr/include/boost/type_traits/is_member_pointer.hpp" 2 3 4

namespace boost {




template <class T> struct is_member_pointer : public integral_constant<bool, ::boost::is_member_function_pointer<T>::value>{};
template <class T, class U> struct is_member_pointer<U T::* > : public true_type{};


template <class T, class U> struct is_member_pointer<U T::*const> : public true_type{};
template <class T, class U> struct is_member_pointer<U T::*const volatile> : public true_type{};
template <class T, class U> struct is_member_pointer<U T::*volatile> : public true_type{};




}
# 16 "/usr/include/boost/type_traits/is_scalar.hpp" 2 3 4


namespace boost {

template <typename T>
struct is_scalar
   : public integral_constant<bool, ::boost::is_arithmetic<T>::value || ::boost::is_enum<T>::value || ::boost::is_pointer<T>::value || ::boost::is_member_pointer<T>::value>
{};

}
# 16 "/usr/include/boost/type_traits/is_pod.hpp" 2 3 4
# 30 "/usr/include/boost/type_traits/is_pod.hpp" 3 4
namespace boost {


template< typename T > struct is_POD;

template <typename T> struct is_pod
: public integral_constant<bool, ::boost::is_scalar<T>::value || ::boost::is_void<T>::value || __is_pod(T)>
{};


template <typename T, std::size_t sz> struct is_pod<T[sz]> : public is_pod<T>{};




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


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


template<class T> struct is_POD : public is_pod<T>{};

}
# 13 "/usr/include/boost/type_traits/type_with_alignment.hpp" 2 3 4
# 27 "/usr/include/boost/type_traits/type_with_alignment.hpp" 3 4
namespace boost {

   namespace detail{

      union max_align
      {
         char c;
         short s;
         int i;
         long l;

         boost::long_long_type ll;


         boost::int128_type i128;

         float f;
         double d;
         long double ld;



      };

template <std::size_t Target, bool check> struct long_double_alignment{ typedef long double type; };
template <std::size_t Target> struct long_double_alignment<Target, false>{ typedef boost::detail::max_align type; };

template <std::size_t Target, bool check> struct double_alignment{ typedef double type; };
template <std::size_t Target> struct double_alignment<Target, false>{ typedef typename long_double_alignment<Target, boost::alignment_of<long double>::value >= Target>::type type; };


template <std::size_t Target, bool check> struct long_long_alignment{ typedef boost::long_long_type type; };
template <std::size_t Target> struct long_long_alignment<Target, false>{ typedef typename double_alignment<Target, boost::alignment_of<double>::value >= Target>::type type; };


template <std::size_t Target, bool check> struct long_alignment{ typedef long type; };

template <std::size_t Target> struct long_alignment<Target, false>{ typedef typename long_long_alignment<Target, boost::alignment_of<boost::long_long_type>::value >= Target>::type type; };




template <std::size_t Target, bool check> struct int_alignment{ typedef int type; };
template <std::size_t Target> struct int_alignment<Target, false>{ typedef typename long_alignment<Target, boost::alignment_of<long>::value >= Target>::type type; };

template <std::size_t Target, bool check> struct short_alignment{ typedef short type; };
template <std::size_t Target> struct short_alignment<Target, false>{ typedef typename int_alignment<Target, boost::alignment_of<int>::value >= Target>::type type; };

template <std::size_t Target, bool check> struct char_alignment{ typedef char type; };
template <std::size_t Target> struct char_alignment<Target, false>{ typedef typename short_alignment<Target, boost::alignment_of<short>::value >= Target>::type type; };

}

template <std::size_t Align>
struct type_with_alignment
{
   typedef typename boost::detail::char_alignment<Align, boost::alignment_of<char>::value >= Align>::type type;
};


namespace tt_align_ns {
struct __attribute__((__aligned__(2))) a2 {};
struct __attribute__((__aligned__(4))) a4 {};
struct __attribute__((__aligned__(8))) a8 {};
struct __attribute__((__aligned__(16))) a16 {};
struct __attribute__((__aligned__(32))) a32 {};
struct __attribute__((__aligned__(64))) a64 {};
struct __attribute__((__aligned__(128))) a128 {};
}

template<> struct type_with_alignment<1> { public: typedef char type; };
template<> struct type_with_alignment<2> { public: typedef tt_align_ns::a2 type; };
template<> struct type_with_alignment<4> { public: typedef tt_align_ns::a4 type; };
template<> struct type_with_alignment<8> { public: typedef tt_align_ns::a8 type; };
template<> struct type_with_alignment<16> { public: typedef tt_align_ns::a16 type; };
template<> struct type_with_alignment<32> { public: typedef tt_align_ns::a32 type; };
template<> struct type_with_alignment<64> { public: typedef tt_align_ns::a64 type; };
template<> struct type_with_alignment<128> { public: typedef tt_align_ns::a128 type; };

template<> struct is_pod< ::boost::tt_align_ns::a2> : public true_type{};
template<> struct is_pod< ::boost::tt_align_ns::a4> : public true_type{};
template<> struct is_pod< ::boost::tt_align_ns::a8> : public true_type{};
template<> struct is_pod< ::boost::tt_align_ns::a16> : public true_type{};
template<> struct is_pod< ::boost::tt_align_ns::a32> : public true_type{};
template<> struct is_pod< ::boost::tt_align_ns::a64> : public true_type{};
template<> struct is_pod< ::boost::tt_align_ns::a128> : public true_type{};
# 252 "/usr/include/boost/type_traits/type_with_alignment.hpp" 3 4
}
# 22 "/usr/include/boost/type_traits/aligned_storage.hpp" 2 3 4



namespace boost {

namespace detail { namespace aligned_storage {

static const std::size_t alignment_of_max_align = ::boost::alignment_of<boost::detail::max_align>::value;







template <
      std::size_t size_
    , std::size_t alignment_
>
struct aligned_storage_imp
{
    union data_t
    {
        char buf[size_];

        typename ::boost::type_with_alignment<alignment_>::type align_;
    } data_;
    void* address() const { return const_cast<aligned_storage_imp*>(this); }
};
template <std::size_t size>
struct aligned_storage_imp<size, std::size_t(-1)>
{
   union data_t
   {
      char buf[size];
      ::boost::detail::max_align align_;
   } data_;
   void* address() const { return const_cast<aligned_storage_imp*>(this); }
};

template< std::size_t alignment_ >
struct aligned_storage_imp<0u,alignment_>
{

    void* address() const { return 0; }
};

}}

template <
      std::size_t size_
    , std::size_t alignment_ = std::size_t(-1)
>
class aligned_storage :

   private



   ::boost::detail::aligned_storage::aligned_storage_imp<size_, alignment_>
{

public:

    typedef ::boost::detail::aligned_storage::aligned_storage_imp<size_, alignment_> type;

    static const std::size_t size = size_;



    static const std::size_t alignment = ( alignment_ == std::size_t(-1) ? ::boost::detail::aligned_storage::alignment_of_max_align : alignment_ );
# 101 "/usr/include/boost/type_traits/aligned_storage.hpp" 3 4
private:

    aligned_storage(const aligned_storage&);
    aligned_storage& operator=(const aligned_storage&);

public:

    aligned_storage()
    {
    }

    ~aligned_storage()
    {
    }

public:

    void* address()
    {
        return static_cast<type*>(this)->address();
    }

    const void* address() const
    {
        return static_cast<const type*>(this)->address();
    }
};





template <std::size_t size_, std::size_t alignment_>
struct is_pod< ::boost::detail::aligned_storage::aligned_storage_imp<size_, alignment_> > : public true_type{};

}
# 17 "/usr/include/boost/aligned_storage.hpp" 2 3 4
# 17 "/usr/include/boost/lockfree/spsc_queue.hpp" 2 3 4
# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 58 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 59 "/usr/include/boost/assert.hpp" 2 3 4
# 18 "/usr/include/boost/lockfree/spsc_queue.hpp" 2 3 4

# 1 "/usr/include/boost/core/allocator_access.hpp" 1 3 4
# 12 "/usr/include/boost/core/allocator_access.hpp" 3 4
# 1 "/usr/include/boost/core/pointer_traits.hpp" 1 3 4
# 15 "/usr/include/boost/core/pointer_traits.hpp" 3 4
namespace boost {
namespace detail {

struct ptr_none { };

template<class>
struct ptr_valid {
    typedef void type;
};

template<class>
struct ptr_first {
    typedef ptr_none type;
};


template<template<class, class...> class T, class U, class... Args>
struct ptr_first<T<U, Args...> > {
    typedef U type;
};
# 52 "/usr/include/boost/core/pointer_traits.hpp" 3 4
template<class T, class = void>
struct ptr_element {
    typedef typename ptr_first<T>::type type;
};

template<class T>
struct ptr_element<T, typename ptr_valid<typename T::element_type>::type> {
    typedef typename T::element_type type;
};

template<class, class = void>
struct ptr_difference {
    typedef std::ptrdiff_t type;
};

template<class T>
struct ptr_difference<T,
    typename ptr_valid<typename T::difference_type>::type> {
    typedef typename T::difference_type type;
};

template<class, class>
struct ptr_transform { };


template<template<class, class...> class T, class U, class... Args, class V>
struct ptr_transform<T<U, Args...>, V> {
    typedef T<V, Args...> type;
};
# 99 "/usr/include/boost/core/pointer_traits.hpp" 3 4
template<class T, class U, class = void>
struct ptr_rebind
    : ptr_transform<T, U> { };


template<class T, class U>
struct ptr_rebind<T, U,
    typename ptr_valid<typename T::template rebind<U> >::type> {
    typedef typename T::template rebind<U> type;
};
# 118 "/usr/include/boost/core/pointer_traits.hpp" 3 4
template<class T, class E>
class ptr_to_expr {
    template<class>
    struct result {
        char x, y;
    };

    static E& source();

    template<class O>
    static auto check(int) -> result<decltype(O::pointer_to(source()))>;

    template<class>
    static char check(long);

public:
    static constexpr bool value = sizeof(check<T>(0)) > 1;
};

template<class T, class E>
struct ptr_to_expr<T*, E> {
    static constexpr bool value = true;
};

template<class T, class E>
struct ptr_has_to {
    static constexpr bool value = ptr_to_expr<T, E>::value;
};







template<class T>
struct ptr_has_to<T, void> {
    static constexpr bool value = false;
};

template<class T>
struct ptr_has_to<T, const void> {
    static constexpr bool value = false;
};

template<class T>
struct ptr_has_to<T, volatile void> {
    static constexpr bool value = false;
};

template<class T>
struct ptr_has_to<T, const volatile void> {
    static constexpr bool value = false;
};

template<class T, class E, bool = ptr_has_to<T, E>::value>
struct ptr_to { };

template<class T, class E>
struct ptr_to<T, E, true> {
    static T pointer_to(E& v) {
        return T::pointer_to(v);
    }
};

template<class T>
struct ptr_to<T*, T, true> {
    static T* pointer_to(T& v) noexcept {
        return boost::addressof(v);
    }
};

template<class T, class E>
struct ptr_traits
    : ptr_to<T, E> {
    typedef T pointer;
    typedef E element_type;
    typedef typename ptr_difference<T>::type difference_type;

    template<class U>
    struct rebind_to
        : ptr_rebind<T, U> { };


    template<class U>
    using rebind = typename rebind_to<U>::type;

};

template<class T>
struct ptr_traits<T, ptr_none> { };

}

template<class T>
struct pointer_traits
    : detail::ptr_traits<T, typename detail::ptr_element<T>::type> { };

template<class T>
struct pointer_traits<T*>
    : detail::ptr_to<T*, T> {
    typedef T* pointer;
    typedef T element_type;
    typedef std::ptrdiff_t difference_type;

    template<class U>
    struct rebind_to {
        typedef U* type;
    };


    template<class U>
    using rebind = typename rebind_to<U>::type;

};

template<class T>
constexpr inline T*
to_address(T* v) noexcept
{
    return v;
}


namespace detail {

template<class T>
inline T*
ptr_address(T* v, int) noexcept
{
    return v;
}

template<class T>
inline auto
ptr_address(const T& v, int) noexcept
-> decltype(boost::pointer_traits<T>::to_address(v))
{
    return boost::pointer_traits<T>::to_address(v);
}

template<class T>
inline auto
ptr_address(const T& v, long) noexcept
{
    return boost::detail::ptr_address(v.operator->(), 0);
}

}

template<class T>
inline auto
to_address(const T& v) noexcept
{
    return boost::detail::ptr_address(v, 0);
}
# 283 "/usr/include/boost/core/pointer_traits.hpp" 3 4
}
# 13 "/usr/include/boost/core/allocator_access.hpp" 2 3 4
# 51 "/usr/include/boost/core/allocator_access.hpp" 3 4
namespace boost {

template<class A>
struct allocator_value_type {
    typedef typename A::value_type type;
};

namespace detail {

template<class A, class = void>
struct alloc_ptr {
    typedef typename boost::allocator_value_type<A>::type* type;
};

template<class>
struct alloc_void {
    typedef void type;
};

template<class A>
struct alloc_ptr<A,
    typename alloc_void<typename A::pointer>::type> {
    typedef typename A::pointer type;
};

}

template<class A>
struct allocator_pointer {
    typedef typename detail::alloc_ptr<A>::type type;
};

namespace detail {

template<class A, class = void>
struct alloc_const_ptr {
    typedef typename boost::pointer_traits<typename
        boost::allocator_pointer<A>::type>::template rebind_to<const typename
            boost::allocator_value_type<A>::type>::type type;
};

template<class A>
struct alloc_const_ptr<A,
    typename alloc_void<typename A::const_pointer>::type> {
    typedef typename A::const_pointer type;
};

}

template<class A>
struct allocator_const_pointer {
    typedef typename detail::alloc_const_ptr<A>::type type;
};

namespace detail {

template<class, class>
struct alloc_to { };
# 127 "/usr/include/boost/core/allocator_access.hpp" 3 4
template<template<class, class...> class A, class T, class U, class... V>
struct alloc_to<A<U, V...>, T> {
    typedef A<T, V...> type;
};


template<class A, class T, class = void>
struct alloc_rebind {
    typedef typename alloc_to<A, T>::type type;
};

template<class A, class T>
struct alloc_rebind<A, T,
    typename alloc_void<typename A::template rebind<T>::other>::type> {
    typedef typename A::template rebind<T>::other type;
};

}

template<class A, class T>
struct allocator_rebind {
    typedef typename detail::alloc_rebind<A, T>::type type;
};

namespace detail {

template<class A, class = void>
struct alloc_void_ptr {
     typedef typename boost::pointer_traits<typename
        boost::allocator_pointer<A>::type>::template
            rebind_to<void>::type type;
};

template<class A>
struct alloc_void_ptr<A,
    typename alloc_void<typename A::void_pointer>::type> {
    typedef typename A::void_pointer type;
};

}

template<class A>
struct allocator_void_pointer {
    typedef typename detail::alloc_void_ptr<A>::type type;
};

namespace detail {

template<class A, class = void>
struct alloc_const_void_ptr {
     typedef typename boost::pointer_traits<typename
        boost::allocator_pointer<A>::type>::template
            rebind_to<const void>::type type;
};

template<class A>
struct alloc_const_void_ptr<A,
    typename alloc_void<typename A::const_void_pointer>::type> {
    typedef typename A::const_void_pointer type;
};

}

template<class A>
struct allocator_const_void_pointer {
    typedef typename detail::alloc_const_void_ptr<A>::type type;
};

namespace detail {

template<class A, class = void>
struct alloc_diff_type {
    typedef typename boost::pointer_traits<typename
        boost::allocator_pointer<A>::type>::difference_type type;
};

template<class A>
struct alloc_diff_type<A,
    typename alloc_void<typename A::difference_type>::type> {
    typedef typename A::difference_type type;
};

}

template<class A>
struct allocator_difference_type {
    typedef typename detail::alloc_diff_type<A>::type type;
};

namespace detail {







template<class A, class = void>
struct alloc_size_type {
    typedef typename std::make_unsigned<typename
        boost::allocator_difference_type<A>::type>::type type;
};


template<class A>
struct alloc_size_type<A,
    typename alloc_void<typename A::size_type>::type> {
    typedef typename A::size_type type;
};

}

template<class A>
struct allocator_size_type {
    typedef typename detail::alloc_size_type<A>::type type;
};

namespace detail {
# 268 "/usr/include/boost/core/allocator_access.hpp" 3 4
typedef std::false_type alloc_false;


template<class A, class = void>
struct alloc_pocca {
    typedef alloc_false type;
};

template<class A>
struct alloc_pocca<A,
    typename alloc_void<typename
        A::propagate_on_container_copy_assignment>::type> {
    typedef typename A::propagate_on_container_copy_assignment type;
};

}

template<class A, class = void>
struct allocator_propagate_on_container_copy_assignment {
    typedef typename detail::alloc_pocca<A>::type type;
};

namespace detail {

template<class A, class = void>
struct alloc_pocma {
    typedef alloc_false type;
};

template<class A>
struct alloc_pocma<A,
    typename alloc_void<typename
        A::propagate_on_container_move_assignment>::type> {
    typedef typename A::propagate_on_container_move_assignment type;
};

}

template<class A>
struct allocator_propagate_on_container_move_assignment {
    typedef typename detail::alloc_pocma<A>::type type;
};

namespace detail {

template<class A, class = void>
struct alloc_pocs {
    typedef alloc_false type;
};

template<class A>
struct alloc_pocs<A,
    typename alloc_void<typename A::propagate_on_container_swap>::type> {
    typedef typename A::propagate_on_container_swap type;
};

}

template<class A>
struct allocator_propagate_on_container_swap {
    typedef typename detail::alloc_pocs<A>::type type;
};

namespace detail {


template<class A, class = void>
struct alloc_equal {
    typedef typename std::is_empty<A>::type type;
};
# 350 "/usr/include/boost/core/allocator_access.hpp" 3 4
template<class A>
struct alloc_equal<A,
    typename alloc_void<typename A::is_always_equal>::type> {
    typedef typename A::is_always_equal type;
};

}

template<class A>
struct allocator_is_always_equal {
    typedef typename detail::alloc_equal<A>::type type;
};

template<class A>
inline typename allocator_pointer<A>::type
allocator_allocate(A& a, typename allocator_size_type<A>::type n)
{
    return a.allocate(n);
}

template<class A>
inline void
allocator_deallocate(A& a, typename allocator_pointer<A>::type p,
    typename allocator_size_type<A>::type n)
{
    a.deallocate(p, n);
}
# 387 "/usr/include/boost/core/allocator_access.hpp" 3 4
namespace detail {

template<class>
struct alloc_no {
    char x, y;
};

template<class A>
class alloc_has_allocate {
    template<class O>
    static auto check(int)
    -> alloc_no<decltype(std::declval<O&>().allocate(std::declval<typename
        boost::allocator_size_type<A>::type>(), std::declval<typename
            boost::allocator_const_void_pointer<A>::type>()))>;

    template<class>
    static char check(long);

public:
    static constexpr bool value = sizeof(check<A>(0)) > 1;
};

}

template<class A>
inline typename std::enable_if<detail::alloc_has_allocate<A>::value,
    typename allocator_pointer<A>::type>::type
allocator_allocate(A& a, typename allocator_size_type<A>::type n,
    typename allocator_const_void_pointer<A>::type h)
{
    return a.allocate(n, h);
}

template<class A>
inline typename std::enable_if<!detail::alloc_has_allocate<A>::value,
    typename allocator_pointer<A>::type>::type
allocator_allocate(A& a, typename allocator_size_type<A>::type n,
    typename allocator_const_void_pointer<A>::type)
{
    return a.allocate(n);
}


namespace detail {
# 444 "/usr/include/boost/core/allocator_access.hpp" 3 4
template<class A, class T, class... Args>
class alloc_has_construct {
    template<class O>
    static auto check(int)
    -> alloc_no<decltype(std::declval<O&>().construct(std::declval<T*>(),
        std::declval<Args&&>()...))>;

    template<class>
    static char check(long);

public:
    static constexpr bool value = sizeof(check<A>(0)) > 1;
};


template<bool, class = void>
struct alloc_if { };

template<class T>
struct alloc_if<true, T> {
    typedef T type;
};

}
# 516 "/usr/include/boost/core/allocator_access.hpp" 3 4
template<class A, class T, class... Args>
inline typename std::enable_if<detail::alloc_has_construct<A, T,
    Args...>::value>::type
allocator_construct(A& a, T* p, Args&&... args)
{
    a.construct(p, std::forward<Args>(args)...);
}

template<class A, class T, class... Args>
inline typename std::enable_if<!detail::alloc_has_construct<A, T,
    Args...>::value>::type
allocator_construct(A&, T* p, Args&&... args)
{
    ::new((void*)p) T(std::forward<Args>(args)...);
}


namespace detail {
# 547 "/usr/include/boost/core/allocator_access.hpp" 3 4
template<class A, class T>
class alloc_has_destroy {
    template<class O>
    static auto check(int)
    -> alloc_no<decltype(std::declval<O&>().destroy(std::declval<T*>()))>;

    template<class>
    static char check(long);

public:
    static constexpr bool value = sizeof(check<A>(0)) > 1;
};


}

template<class A, class T>
inline typename detail::alloc_if<detail::alloc_has_destroy<A, T>::value>::type
allocator_destroy(A& a, T* p)
{
    a.destroy(p);
}

template<class A, class T>
inline typename detail::alloc_if<!detail::alloc_has_destroy<A, T>::value>::type
allocator_destroy(A&, T* p)
{
    p->~T();
    (void)p;
}

namespace detail {
# 607 "/usr/include/boost/core/allocator_access.hpp" 3 4
template<class A>
class alloc_has_max_size {
    template<class O>
    static auto check(int)
    -> alloc_no<decltype(std::declval<const O&>().max_size())>;

    template<class>
    static char check(long);

public:
    static constexpr bool value = sizeof(check<A>(0)) > 1;
};


}

template<class A>
inline typename detail::alloc_if<detail::alloc_has_max_size<A>::value,
    typename allocator_size_type<A>::type>::type
allocator_max_size(const A& a) noexcept
{
    return a.max_size();
}

template<class A>
inline typename detail::alloc_if<!detail::alloc_has_max_size<A>::value,
    typename allocator_size_type<A>::type>::type
allocator_max_size(const A&) noexcept
{
    return (std::numeric_limits<typename
        allocator_size_type<A>::type>::max)() /
            sizeof(typename allocator_value_type<A>::type);
}

namespace detail {
# 665 "/usr/include/boost/core/allocator_access.hpp" 3 4
template<class A>
class alloc_has_soccc {
    template<class O>
    static auto check(int) -> alloc_no<decltype(std::declval<const
        O&>().select_on_container_copy_construction())>;

    template<class>
    static char check(long);

public:
    static constexpr bool value = sizeof(check<A>(0)) > 1;
};


}

template<class A>
inline typename detail::alloc_if<detail::alloc_has_soccc<A>::value, A>::type
allocator_select_on_container_copy_construction(const A& a)
{
    return a.select_on_container_copy_construction();
}

template<class A>
inline typename detail::alloc_if<!detail::alloc_has_soccc<A>::value, A>::type
allocator_select_on_container_copy_construction(const A& a)
{
    return a;
}

template<class A, class T>
inline void
allocator_destroy_n(A& a, T* p, std::size_t n)
{
    while (n > 0) {
        boost::allocator_destroy(a, p + --n);
    }
}

namespace detail {

template<class A, class T>
class alloc_destroyer {
public:
    alloc_destroyer(A& a, T* p) noexcept
        : a_(a), p_(p), n_(0) { }

    ~alloc_destroyer() {
        boost::allocator_destroy_n(a_, p_, n_);
    }

    std::size_t& size() noexcept {
        return n_;
    }

private:
    alloc_destroyer(const alloc_destroyer&);
    alloc_destroyer& operator=(const alloc_destroyer&);

    A& a_;
    T* p_;
    std::size_t n_;
};

}

template<class A, class T>
inline void
allocator_construct_n(A& a, T* p, std::size_t n)
{
    detail::alloc_destroyer<A, T> d(a, p);
    for (std::size_t& i = d.size(); i < n; ++i) {
        boost::allocator_construct(a, p + i);
    }
    d.size() = 0;
}

template<class A, class T>
inline void
allocator_construct_n(A& a, T* p, std::size_t n, const T* l, std::size_t m)
{
    detail::alloc_destroyer<A, T> d(a, p);
    for (std::size_t& i = d.size(); i < n; ++i) {
        boost::allocator_construct(a, p + i, l[i % m]);
    }
    d.size() = 0;
}

template<class A, class T, class I>
inline void
allocator_construct_n(A& a, T* p, std::size_t n, I b)
{
    detail::alloc_destroyer<A, T> d(a, p);
    for (std::size_t& i = d.size(); i < n; void(++i), void(++b)) {
        boost::allocator_construct(a, p + i, *b);
    }
    d.size() = 0;
}


template<class A>
using allocator_value_type_t = typename allocator_value_type<A>::type;

template<class A>
using allocator_pointer_t = typename allocator_pointer<A>::type;

template<class A>
using allocator_const_pointer_t = typename allocator_const_pointer<A>::type;

template<class A>
using allocator_void_pointer_t = typename allocator_void_pointer<A>::type;

template<class A>
using allocator_const_void_pointer_t =
    typename allocator_const_void_pointer<A>::type;

template<class A>
using allocator_difference_type_t =
    typename allocator_difference_type<A>::type;

template<class A>
using allocator_size_type_t = typename allocator_size_type<A>::type;

template<class A>
using allocator_propagate_on_container_copy_assignment_t =
    typename allocator_propagate_on_container_copy_assignment<A>::type;

template<class A>
using allocator_propagate_on_container_move_assignment_t =
    typename allocator_propagate_on_container_move_assignment<A>::type;

template<class A>
using allocator_propagate_on_container_swap_t =
    typename allocator_propagate_on_container_swap<A>::type;

template<class A>
using allocator_is_always_equal_t =
    typename allocator_is_always_equal<A>::type;

template<class A, class T>
using allocator_rebind_t = typename allocator_rebind<A, T>::type;


}
# 20 "/usr/include/boost/lockfree/spsc_queue.hpp" 2 3 4
# 1 "/usr/include/boost/utility.hpp" 1 3 4
# 15 "/usr/include/boost/utility.hpp" 3 4
# 1 "/usr/include/boost/utility/base_from_member.hpp" 1 3 4
# 14 "/usr/include/boost/utility/base_from_member.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/arithmetic/inc.hpp" 1 3 4
# 18 "/usr/include/boost/preprocessor/arithmetic/inc.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/config/config.hpp" 1 3 4
# 19 "/usr/include/boost/preprocessor/arithmetic/inc.hpp" 2 3 4
# 304 "/usr/include/boost/preprocessor/arithmetic/inc.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/config/limits.hpp" 1 3 4
# 305 "/usr/include/boost/preprocessor/arithmetic/inc.hpp" 2 3 4


# 1 "/usr/include/boost/preprocessor/arithmetic/limits/inc_256.hpp" 1 3 4
# 308 "/usr/include/boost/preprocessor/arithmetic/inc.hpp" 2 3 4
# 15 "/usr/include/boost/utility/base_from_member.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/repetition/enum_binary_params.hpp" 1 3 4
# 15 "/usr/include/boost/preprocessor/repetition/enum_binary_params.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/cat.hpp" 1 3 4
# 16 "/usr/include/boost/preprocessor/repetition/enum_binary_params.hpp" 2 3 4

# 1 "/usr/include/boost/preprocessor/punctuation/comma_if.hpp" 1 3 4
# 18 "/usr/include/boost/preprocessor/punctuation/comma_if.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/control/if.hpp" 1 3 4
# 18 "/usr/include/boost/preprocessor/control/if.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/control/iif.hpp" 1 3 4
# 19 "/usr/include/boost/preprocessor/control/if.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/logical/bool.hpp" 1 3 4
# 296 "/usr/include/boost/preprocessor/logical/bool.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/logical/limits/bool_256.hpp" 1 3 4
# 297 "/usr/include/boost/preprocessor/logical/bool.hpp" 2 3 4
# 20 "/usr/include/boost/preprocessor/control/if.hpp" 2 3 4
# 19 "/usr/include/boost/preprocessor/punctuation/comma_if.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/facilities/empty.hpp" 1 3 4
# 20 "/usr/include/boost/preprocessor/punctuation/comma_if.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/punctuation/comma.hpp" 1 3 4
# 21 "/usr/include/boost/preprocessor/punctuation/comma_if.hpp" 2 3 4
# 18 "/usr/include/boost/preprocessor/repetition/enum_binary_params.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/repetition/repeat.hpp" 1 3 4
# 20 "/usr/include/boost/preprocessor/repetition/repeat.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/debug/error.hpp" 1 3 4
# 21 "/usr/include/boost/preprocessor/repetition/repeat.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
# 318 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/detail/limits/auto_rec_256.hpp" 1 3 4
# 319 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 2 3 4
# 22 "/usr/include/boost/preprocessor/repetition/repeat.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/tuple/eat.hpp" 1 3 4
# 23 "/usr/include/boost/preprocessor/repetition/repeat.hpp" 2 3 4
# 833 "/usr/include/boost/preprocessor/repetition/repeat.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/repetition/limits/repeat_256.hpp" 1 3 4
# 834 "/usr/include/boost/preprocessor/repetition/repeat.hpp" 2 3 4
# 19 "/usr/include/boost/preprocessor/repetition/enum_binary_params.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/tuple/elem.hpp" 1 3 4
# 20 "/usr/include/boost/preprocessor/tuple/elem.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/facilities/expand.hpp" 1 3 4
# 21 "/usr/include/boost/preprocessor/tuple/elem.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/facilities/overload.hpp" 1 3 4
# 17 "/usr/include/boost/preprocessor/facilities/overload.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/variadic/size.hpp" 1 3 4
# 21 "/usr/include/boost/preprocessor/variadic/size.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/facilities/check_empty.hpp" 1 3 4
# 14 "/usr/include/boost/preprocessor/facilities/check_empty.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/variadic/has_opt.hpp" 1 3 4
# 23 "/usr/include/boost/preprocessor/variadic/has_opt.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/variadic/detail/has_opt.hpp" 1 3 4
# 24 "/usr/include/boost/preprocessor/variadic/has_opt.hpp" 2 3 4
# 15 "/usr/include/boost/preprocessor/facilities/check_empty.hpp" 2 3 4

# 1 "/usr/include/boost/preprocessor/facilities/is_empty_variadic.hpp" 1 3 4
# 16 "/usr/include/boost/preprocessor/facilities/is_empty_variadic.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/punctuation/is_begin_parens.hpp" 1 3 4
# 16 "/usr/include/boost/preprocessor/punctuation/is_begin_parens.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/punctuation/detail/is_begin_parens.hpp" 1 3 4
# 17 "/usr/include/boost/preprocessor/punctuation/is_begin_parens.hpp" 2 3 4
# 17 "/usr/include/boost/preprocessor/facilities/is_empty_variadic.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/facilities/detail/is_empty.hpp" 1 3 4
# 18 "/usr/include/boost/preprocessor/facilities/is_empty_variadic.hpp" 2 3 4
# 17 "/usr/include/boost/preprocessor/facilities/check_empty.hpp" 2 3 4
# 22 "/usr/include/boost/preprocessor/variadic/size.hpp" 2 3 4
# 54 "/usr/include/boost/preprocessor/variadic/size.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/variadic/limits/size_64.hpp" 1 3 4
# 55 "/usr/include/boost/preprocessor/variadic/size.hpp" 2 3 4
# 18 "/usr/include/boost/preprocessor/facilities/overload.hpp" 2 3 4
# 22 "/usr/include/boost/preprocessor/tuple/elem.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/tuple/rem.hpp" 1 3 4
# 22 "/usr/include/boost/preprocessor/tuple/rem.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/tuple/detail/is_single_return.hpp" 1 3 4
# 23 "/usr/include/boost/preprocessor/tuple/rem.hpp" 2 3 4
# 23 "/usr/include/boost/preprocessor/tuple/elem.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/variadic/elem.hpp" 1 3 4
# 102 "/usr/include/boost/preprocessor/variadic/elem.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/variadic/limits/elem_64.hpp" 1 3 4
# 103 "/usr/include/boost/preprocessor/variadic/elem.hpp" 2 3 4
# 24 "/usr/include/boost/preprocessor/tuple/elem.hpp" 2 3 4
# 20 "/usr/include/boost/preprocessor/repetition/enum_binary_params.hpp" 2 3 4
# 16 "/usr/include/boost/utility/base_from_member.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/repetition/enum_params.hpp" 1 3 4
# 17 "/usr/include/boost/utility/base_from_member.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/repetition/repeat_from_to.hpp" 1 3 4
# 18 "/usr/include/boost/preprocessor/repetition/repeat_from_to.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/arithmetic/add.hpp" 1 3 4
# 57 "/usr/include/boost/preprocessor/arithmetic/add.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/arithmetic/dec.hpp" 1 3 4
# 308 "/usr/include/boost/preprocessor/arithmetic/dec.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/arithmetic/limits/dec_256.hpp" 1 3 4
# 309 "/usr/include/boost/preprocessor/arithmetic/dec.hpp" 2 3 4
# 58 "/usr/include/boost/preprocessor/arithmetic/add.hpp" 2 3 4


# 1 "/usr/include/boost/preprocessor/control/while.hpp" 1 3 4
# 322 "/usr/include/boost/preprocessor/control/while.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
# 323 "/usr/include/boost/preprocessor/control/while.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/list/fold_left.hpp" 1 3 4
# 312 "/usr/include/boost/preprocessor/list/fold_left.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/control/while.hpp" 1 3 4
# 313 "/usr/include/boost/preprocessor/list/fold_left.hpp" 2 3 4

# 1 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
# 315 "/usr/include/boost/preprocessor/list/fold_left.hpp" 2 3 4
# 345 "/usr/include/boost/preprocessor/list/fold_left.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/list/detail/fold_left.hpp" 1 3 4
# 286 "/usr/include/boost/preprocessor/list/detail/fold_left.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/control/expr_iif.hpp" 1 3 4
# 287 "/usr/include/boost/preprocessor/list/detail/fold_left.hpp" 2 3 4

# 1 "/usr/include/boost/preprocessor/list/adt.hpp" 1 3 4
# 18 "/usr/include/boost/preprocessor/list/adt.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/detail/is_binary.hpp" 1 3 4
# 16 "/usr/include/boost/preprocessor/detail/is_binary.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/detail/check.hpp" 1 3 4
# 17 "/usr/include/boost/preprocessor/detail/is_binary.hpp" 2 3 4
# 19 "/usr/include/boost/preprocessor/list/adt.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/logical/compl.hpp" 1 3 4
# 20 "/usr/include/boost/preprocessor/list/adt.hpp" 2 3 4
# 289 "/usr/include/boost/preprocessor/list/detail/fold_left.hpp" 2 3 4




# 1 "/usr/include/boost/preprocessor/list/detail/limits/fold_left_256.hpp" 1 3 4
# 294 "/usr/include/boost/preprocessor/list/detail/fold_left.hpp" 2 3 4
# 346 "/usr/include/boost/preprocessor/list/fold_left.hpp" 2 3 4





# 1 "/usr/include/boost/preprocessor/list/limits/fold_left_256.hpp" 1 3 4
# 352 "/usr/include/boost/preprocessor/list/fold_left.hpp" 2 3 4
# 324 "/usr/include/boost/preprocessor/control/while.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/list/fold_right.hpp" 1 3 4
# 49 "/usr/include/boost/preprocessor/list/fold_right.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/control/while.hpp" 1 3 4
# 50 "/usr/include/boost/preprocessor/list/fold_right.hpp" 2 3 4

# 1 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
# 52 "/usr/include/boost/preprocessor/list/fold_right.hpp" 2 3 4
# 79 "/usr/include/boost/preprocessor/list/fold_right.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/list/detail/fold_right.hpp" 1 3 4
# 285 "/usr/include/boost/preprocessor/list/detail/fold_right.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/list/reverse.hpp" 1 3 4
# 46 "/usr/include/boost/preprocessor/list/reverse.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/facilities/identity.hpp" 1 3 4
# 47 "/usr/include/boost/preprocessor/list/reverse.hpp" 2 3 4
# 286 "/usr/include/boost/preprocessor/list/detail/fold_right.hpp" 2 3 4



# 1 "/usr/include/boost/preprocessor/list/detail/limits/fold_right_256.hpp" 1 3 4
# 290 "/usr/include/boost/preprocessor/list/detail/fold_right.hpp" 2 3 4
# 80 "/usr/include/boost/preprocessor/list/fold_right.hpp" 2 3 4
# 325 "/usr/include/boost/preprocessor/control/while.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/logical/bitand.hpp" 1 3 4
# 326 "/usr/include/boost/preprocessor/control/while.hpp" 2 3 4
# 361 "/usr/include/boost/preprocessor/control/while.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/control/detail/while.hpp" 1 3 4
# 549 "/usr/include/boost/preprocessor/control/detail/while.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/control/detail/limits/while_256.hpp" 1 3 4
# 550 "/usr/include/boost/preprocessor/control/detail/while.hpp" 2 3 4
# 362 "/usr/include/boost/preprocessor/control/while.hpp" 2 3 4
# 375 "/usr/include/boost/preprocessor/control/while.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/control/limits/while_256.hpp" 1 3 4
# 376 "/usr/include/boost/preprocessor/control/while.hpp" 2 3 4
# 61 "/usr/include/boost/preprocessor/arithmetic/add.hpp" 2 3 4


# 1 "/usr/include/boost/preprocessor/logical/bitor.hpp" 1 3 4
# 64 "/usr/include/boost/preprocessor/arithmetic/add.hpp" 2 3 4



# 1 "/usr/include/boost/preprocessor/arithmetic/detail/is_maximum_number.hpp" 1 3 4
# 17 "/usr/include/boost/preprocessor/arithmetic/detail/is_maximum_number.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/comparison/equal.hpp" 1 3 4
# 17 "/usr/include/boost/preprocessor/comparison/equal.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/comparison/not_equal.hpp" 1 3 4
# 843 "/usr/include/boost/preprocessor/comparison/not_equal.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/comparison/limits/not_equal_256.hpp" 1 3 4
# 844 "/usr/include/boost/preprocessor/comparison/not_equal.hpp" 2 3 4
# 18 "/usr/include/boost/preprocessor/comparison/equal.hpp" 2 3 4
# 18 "/usr/include/boost/preprocessor/arithmetic/detail/is_maximum_number.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/arithmetic/detail/maximum_number.hpp" 1 3 4
# 19 "/usr/include/boost/preprocessor/arithmetic/detail/is_maximum_number.hpp" 2 3 4
# 68 "/usr/include/boost/preprocessor/arithmetic/add.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/arithmetic/detail/is_minimum_number.hpp" 1 3 4
# 17 "/usr/include/boost/preprocessor/arithmetic/detail/is_minimum_number.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/logical/not.hpp" 1 3 4
# 18 "/usr/include/boost/preprocessor/arithmetic/detail/is_minimum_number.hpp" 2 3 4
# 69 "/usr/include/boost/preprocessor/arithmetic/add.hpp" 2 3 4
# 19 "/usr/include/boost/preprocessor/repetition/repeat_from_to.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/arithmetic/sub.hpp" 1 3 4
# 60 "/usr/include/boost/preprocessor/arithmetic/sub.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/logical/and.hpp" 1 3 4
# 61 "/usr/include/boost/preprocessor/arithmetic/sub.hpp" 2 3 4
# 20 "/usr/include/boost/preprocessor/repetition/repeat_from_to.hpp" 2 3 4




# 1 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
# 25 "/usr/include/boost/preprocessor/repetition/repeat_from_to.hpp" 2 3 4
# 18 "/usr/include/boost/utility/base_from_member.hpp" 2 3 4



# 1 "/usr/include/boost/utility/enable_if.hpp" 1 3 4
# 22 "/usr/include/boost/utility/base_from_member.hpp" 2 3 4
# 59 "/usr/include/boost/utility/base_from_member.hpp" 3 4
namespace boost
{

namespace detail
{
# 73 "/usr/include/boost/utility/base_from_member.hpp" 3 4
template < typename T >
struct remove_cv_ref
{
    typedef typename ::boost::remove_cv<typename
     ::boost::remove_reference<T>::type>::type type;

};







template < typename T, typename U >
struct is_related
    : public ::boost::is_same<
     typename ::boost::detail::remove_cv_ref<T>::type,
     typename ::boost::detail::remove_cv_ref<U>::type >
{};
# 101 "/usr/include/boost/utility/base_from_member.hpp" 3 4
template<typename ...T>
struct enable_if_unrelated
    : public ::boost::enable_if_c<true>
{};

template<typename T, typename U, typename ...U2>
struct enable_if_unrelated<T, U, U2...>
    : public ::boost::disable_if< ::boost::detail::is_related<T, U> >
{};


}
# 124 "/usr/include/boost/utility/base_from_member.hpp" 3 4
template < typename MemberType, int UniqueID = 0 >
class base_from_member
{
protected:
    MemberType member;
# 142 "/usr/include/boost/utility/base_from_member.hpp" 3 4
    base_from_member()
        : member()
        {}

    template < typename T0 > explicit base_from_member( T0 x0 ) : member( x0 ) {}
    template < typename T0 , typename T1 > base_from_member( T0 x0 , T1 x1 ) : member( x0 , x1 ) {} template < typename T0 , typename T1 , typename T2 > base_from_member( T0 x0 , T1 x1 , T2 x2 ) : member( x0 , x1 , x2 ) {} template < typename T0 , typename T1 , typename T2 , typename T3 > base_from_member( T0 x0 , T1 x1 , T2 x2 , T3 x3 ) : member( x0 , x1 , x2 , x3 ) {} template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 > base_from_member( T0 x0 , T1 x1 , T2 x2 , T3 x3 , T4 x4 ) : member( x0 , x1 , x2 , x3 , x4 ) {} template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > base_from_member( T0 x0 , T1 x1 , T2 x2 , T3 x3 , T4 x4 , T5 x5 ) : member( x0 , x1 , x2 , x3 , x4 , x5 ) {} template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 > base_from_member( T0 x0 , T1 x1 , T2 x2 , T3 x3 , T4 x4 , T5 x5 , T6 x6 ) : member( x0 , x1 , x2 , x3 , x4 , x5 , x6 ) {} template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 > base_from_member( T0 x0 , T1 x1 , T2 x2 , T3 x3 , T4 x4 , T5 x5 , T6 x6 , T7 x7 ) : member( x0 , x1 , x2 , x3 , x4 , x5 , x6 , x7 ) {} template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 > base_from_member( T0 x0 , T1 x1 , T2 x2 , T3 x3 , T4 x4 , T5 x5 , T6 x6 , T7 x7 , T8 x8 ) : member( x0 , x1 , x2 , x3 , x4 , x5 , x6 , x7 , x8 ) {} template < typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 > base_from_member( T0 x0 , T1 x1 , T2 x2 , T3 x3 , T4 x4 , T5 x5 , T6 x6 , T7 x7 , T8 x8 , T9 x9 ) : member( x0 , x1 , x2 , x3 , x4 , x5 , x6 , x7 , x8 , x9 ) {}



};

template < typename MemberType, int UniqueID >
class base_from_member<MemberType&, UniqueID>
{
protected:
    MemberType& member;

    explicit constexpr base_from_member( MemberType& x )
        noexcept
        : member( x )
        {}

};

}
# 16 "/usr/include/boost/utility.hpp" 2 3 4
# 1 "/usr/include/boost/utility/binary.hpp" 1 3 4
# 26 "/usr/include/boost/utility/binary.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/control/deduce_d.hpp" 1 3 4
# 32 "/usr/include/boost/preprocessor/control/deduce_d.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
# 33 "/usr/include/boost/preprocessor/control/deduce_d.hpp" 2 3 4
# 27 "/usr/include/boost/utility/binary.hpp" 2 3 4


# 1 "/usr/include/boost/preprocessor/seq/cat.hpp" 1 3 4
# 18 "/usr/include/boost/preprocessor/seq/cat.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/seq/fold_left.hpp" 1 3 4
# 21 "/usr/include/boost/preprocessor/seq/fold_left.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
# 22 "/usr/include/boost/preprocessor/seq/fold_left.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/seq/seq.hpp" 1 3 4
# 16 "/usr/include/boost/preprocessor/seq/seq.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/seq/elem.hpp" 1 3 4
# 313 "/usr/include/boost/preprocessor/seq/elem.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/seq/limits/elem_256.hpp" 1 3 4
# 314 "/usr/include/boost/preprocessor/seq/elem.hpp" 2 3 4
# 17 "/usr/include/boost/preprocessor/seq/seq.hpp" 2 3 4
# 23 "/usr/include/boost/preprocessor/seq/fold_left.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/seq/size.hpp" 1 3 4
# 557 "/usr/include/boost/preprocessor/seq/size.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/seq/limits/size_256.hpp" 1 3 4
# 558 "/usr/include/boost/preprocessor/seq/size.hpp" 2 3 4
# 24 "/usr/include/boost/preprocessor/seq/fold_left.hpp" 2 3 4
# 1110 "/usr/include/boost/preprocessor/seq/fold_left.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/seq/limits/fold_left_256.hpp" 1 3 4
# 1111 "/usr/include/boost/preprocessor/seq/fold_left.hpp" 2 3 4
# 19 "/usr/include/boost/preprocessor/seq/cat.hpp" 2 3 4
# 30 "/usr/include/boost/utility/binary.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/seq/transform.hpp" 1 3 4
# 31 "/usr/include/boost/utility/binary.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/arithmetic/mod.hpp" 1 3 4
# 45 "/usr/include/boost/preprocessor/arithmetic/mod.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/arithmetic/detail/div_base.hpp" 1 3 4
# 19 "/usr/include/boost/preprocessor/arithmetic/detail/div_base.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/comparison/less_equal.hpp" 1 3 4
# 20 "/usr/include/boost/preprocessor/arithmetic/detail/div_base.hpp" 2 3 4
# 46 "/usr/include/boost/preprocessor/arithmetic/mod.hpp" 2 3 4



# 1 "/usr/include/boost/preprocessor/arithmetic/detail/is_1_number.hpp" 1 3 4
# 50 "/usr/include/boost/preprocessor/arithmetic/mod.hpp" 2 3 4
# 32 "/usr/include/boost/utility/binary.hpp" 2 3 4
# 17 "/usr/include/boost/utility.hpp" 2 3 4
# 1 "/usr/include/boost/utility/identity_type.hpp" 1 3 4
# 16 "/usr/include/boost/utility/identity_type.hpp" 3 4
# 1 "/usr/include/boost/type_traits/function_traits.hpp" 1 3 4
# 16 "/usr/include/boost/type_traits/function_traits.hpp" 3 4
namespace boost {

namespace detail {

template<typename Function> struct function_traits_helper;

template<typename R>
struct function_traits_helper<R (*)(void)>
{
  static const unsigned arity = 0;
  typedef R result_type;
};

template<typename R, typename T1>
struct function_traits_helper<R (*)(T1)>
{
  static const unsigned arity = 1;
  typedef R result_type;
  typedef T1 arg1_type;
  typedef T1 argument_type;
};

template<typename R, typename T1, typename T2>
struct function_traits_helper<R (*)(T1, T2)>
{
  static const unsigned arity = 2;
  typedef R result_type;
  typedef T1 arg1_type;
  typedef T2 arg2_type;
  typedef T1 first_argument_type;
  typedef T2 second_argument_type;
};

template<typename R, typename T1, typename T2, typename T3>
struct function_traits_helper<R (*)(T1, T2, T3)>
{
  static const unsigned arity = 3;
  typedef R result_type;
  typedef T1 arg1_type;
  typedef T2 arg2_type;
  typedef T3 arg3_type;
};

template<typename R, typename T1, typename T2, typename T3, typename T4>
struct function_traits_helper<R (*)(T1, T2, T3, T4)>
{
  static const unsigned arity = 4;
  typedef R result_type;
  typedef T1 arg1_type;
  typedef T2 arg2_type;
  typedef T3 arg3_type;
  typedef T4 arg4_type;
};

template<typename R, typename T1, typename T2, typename T3, typename T4,
         typename T5>
struct function_traits_helper<R (*)(T1, T2, T3, T4, T5)>
{
  static const unsigned arity = 5;
  typedef R result_type;
  typedef T1 arg1_type;
  typedef T2 arg2_type;
  typedef T3 arg3_type;
  typedef T4 arg4_type;
  typedef T5 arg5_type;
};

template<typename R, typename T1, typename T2, typename T3, typename T4,
         typename T5, typename T6>
struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6)>
{
  static const unsigned arity = 6;
  typedef R result_type;
  typedef T1 arg1_type;
  typedef T2 arg2_type;
  typedef T3 arg3_type;
  typedef T4 arg4_type;
  typedef T5 arg5_type;
  typedef T6 arg6_type;
};

template<typename R, typename T1, typename T2, typename T3, typename T4,
         typename T5, typename T6, typename T7>
struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6, T7)>
{
  static const unsigned arity = 7;
  typedef R result_type;
  typedef T1 arg1_type;
  typedef T2 arg2_type;
  typedef T3 arg3_type;
  typedef T4 arg4_type;
  typedef T5 arg5_type;
  typedef T6 arg6_type;
  typedef T7 arg7_type;
};

template<typename R, typename T1, typename T2, typename T3, typename T4,
         typename T5, typename T6, typename T7, typename T8>
struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6, T7, T8)>
{
  static const unsigned arity = 8;
  typedef R result_type;
  typedef T1 arg1_type;
  typedef T2 arg2_type;
  typedef T3 arg3_type;
  typedef T4 arg4_type;
  typedef T5 arg5_type;
  typedef T6 arg6_type;
  typedef T7 arg7_type;
  typedef T8 arg8_type;
};

template<typename R, typename T1, typename T2, typename T3, typename T4,
         typename T5, typename T6, typename T7, typename T8, typename T9>
struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6, T7, T8, T9)>
{
  static const unsigned arity = 9;
  typedef R result_type;
  typedef T1 arg1_type;
  typedef T2 arg2_type;
  typedef T3 arg3_type;
  typedef T4 arg4_type;
  typedef T5 arg5_type;
  typedef T6 arg6_type;
  typedef T7 arg7_type;
  typedef T8 arg8_type;
  typedef T9 arg9_type;
};

template<typename R, typename T1, typename T2, typename T3, typename T4,
         typename T5, typename T6, typename T7, typename T8, typename T9,
         typename T10>
struct function_traits_helper<R (*)(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)>
{
  static const unsigned arity = 10;
  typedef R result_type;
  typedef T1 arg1_type;
  typedef T2 arg2_type;
  typedef T3 arg3_type;
  typedef T4 arg4_type;
  typedef T5 arg5_type;
  typedef T6 arg6_type;
  typedef T7 arg7_type;
  typedef T8 arg8_type;
  typedef T9 arg9_type;
  typedef T10 arg10_type;
};

}

template<typename Function>
struct function_traits :
  public boost::detail::function_traits_helper<typename boost::add_pointer<Function>::type>
{
};

}
# 17 "/usr/include/boost/utility/identity_type.hpp" 2 3 4
# 18 "/usr/include/boost/utility.hpp" 2 3 4



# 1 "/usr/include/boost/core/checked_delete.hpp" 1 3 4
# 26 "/usr/include/boost/core/checked_delete.hpp" 3 4
namespace boost
{



template<class T> inline void checked_delete(T * x) noexcept
{


    static_assert( sizeof(T) != 0, "Type must be complete" );
# 44 "/usr/include/boost/core/checked_delete.hpp" 3 4
    delete x;
}

template<class T> inline void checked_array_delete(T * x) noexcept
{


    static_assert( sizeof(T) != 0, "Type must be complete" );
# 60 "/usr/include/boost/core/checked_delete.hpp" 3 4
    delete [] x;
}

template<class T> struct checked_deleter
{
    typedef void result_type;
    typedef T * argument_type;

    void operator()(T * x) const noexcept
    {

        boost::checked_delete(x);
    }
};

template<class T> struct checked_array_deleter
{
    typedef void result_type;
    typedef T * argument_type;

    void operator()(T * x) const noexcept
    {
        boost::checked_array_delete(x);
    }
};

}
# 22 "/usr/include/boost/utility.hpp" 2 3 4
# 1 "/usr/include/boost/core/noncopyable.hpp" 1 3 4
# 14 "/usr/include/boost/core/noncopyable.hpp" 3 4
namespace boost {






namespace noncopyable_
{
# 34 "/usr/include/boost/core/noncopyable.hpp" 3 4
  struct base_token {};



  class noncopyable: base_token
  {
  protected:

      constexpr noncopyable() = default;
      ~noncopyable() = default;





      noncopyable( const noncopyable& ) = delete;
      noncopyable& operator=( const noncopyable& ) = delete;





  };
}

typedef noncopyable_::noncopyable noncopyable;

}
# 23 "/usr/include/boost/utility.hpp" 2 3 4
# 21 "/usr/include/boost/lockfree/spsc_queue.hpp" 2 3 4
# 1 "/usr/include/boost/next_prior.hpp" 1 3 4
# 19 "/usr/include/boost/next_prior.hpp" 3 4
# 1 "/usr/include/boost/type_traits/has_plus.hpp" 1 3 4
# 48 "/usr/include/boost/type_traits/has_plus.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 1 3 4
# 26 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
# 37 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
# 1 "/usr/include/boost/type_traits/make_void.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/make_void.hpp" 3 4
namespace boost {


template<class...>
struct make_void {
    typedef void type;
};


template<class... Ts>
using void_t = typename make_void<Ts...>::type;
# 50 "/usr/include/boost/type_traits/make_void.hpp" 3 4
}
# 38 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3
# 1 "/usr/include/boost/type_traits/is_convertible.hpp" 1 3 4
# 17 "/usr/include/boost/type_traits/is_convertible.hpp" 3 4
# 1 "/usr/include/boost/type_traits/is_complete.hpp" 1 3 4
# 16 "/usr/include/boost/type_traits/is_complete.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/yes_no_type.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/detail/yes_no_type.hpp" 3 4
namespace boost {
namespace type_traits {

typedef char yes_type;
struct no_type
{
   char padding[8];
};

}
}
# 17 "/usr/include/boost/type_traits/is_complete.hpp" 2 3 4
# 32 "/usr/include/boost/type_traits/is_complete.hpp" 3 4
namespace boost {
# 42 "/usr/include/boost/type_traits/is_complete.hpp" 3 4
   namespace detail{

      template <std::size_t N>
      struct ok_tag { double d; char c[N]; };

      template <class T>
      ok_tag<sizeof(T)> check_is_complete(int);
      template <class T>
      char check_is_complete(...);
   }

   template <class T> struct is_complete
      : public integral_constant<bool, ::boost::is_function<typename boost::remove_reference<T>::type>::value || (sizeof(boost::detail::check_is_complete<T>(0)) != sizeof(char))> {};
# 91 "/usr/include/boost/type_traits/is_complete.hpp" 3 4
}
# 18 "/usr/include/boost/type_traits/is_convertible.hpp" 2 3 4
# 45 "/usr/include/boost/type_traits/is_convertible.hpp" 3 4
namespace boost {
# 489 "/usr/include/boost/type_traits/is_convertible.hpp" 3 4
template <class From, class To>
struct is_convertible : public integral_constant<bool, __is_convertible_to(From,To)>
{





   static_assert(boost::is_complete<To>::value || boost::is_void<To>::value || boost::is_array<To>::value, "Destination argument type to is_convertible must be a complete type");
   static_assert(boost::is_complete<From>::value || boost::is_void<From>::value || boost::is_array<From>::value, "From argument type to is_convertible must be a complete type");

};



}
# 39 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 2 3




namespace boost
{

   namespace binary_op_detail {

      struct dont_care;

      template <class T, class U, class Ret, class = void>
      struct has_plus_ret_imp : public boost::false_type {};

      template <class T, class U, class Ret>
      struct has_plus_ret_imp<T, U, Ret, typename boost::make_void<decltype(std::declval<typename add_reference<T>::type>() + std::declval<typename add_reference<U>::type>())>::type>
         : public boost::integral_constant<bool, ::boost::is_convertible<decltype(std::declval<typename add_reference<T>::type>() + std::declval<typename add_reference<U>::type>()), Ret>::value> {};

      template <class T, class U, class = void >
      struct has_plus_void_imp : public boost::false_type {};

      template <class T, class U>
      struct has_plus_void_imp<T, U, typename boost::make_void<decltype(std::declval<typename add_reference<T>::type>() + std::declval<typename add_reference<U>::type>())>::type>
         : public boost::integral_constant<bool, ::boost::is_void<decltype(std::declval<typename add_reference<T>::type>() + std::declval<typename add_reference<U>::type>())>::value> {};

      template <class T, class U, class = void>
      struct has_plus_dc_imp : public boost::false_type {};

      template <class T, class U>
      struct has_plus_dc_imp<T, U, typename boost::make_void<decltype(std::declval<typename add_reference<T>::type>() + std::declval<typename add_reference<U>::type>())>::type>
         : public boost::true_type {};

   }

   template <class T, class U = T, class Ret = boost::binary_op_detail::dont_care>
   struct has_plus : public boost::binary_op_detail:: has_plus_ret_imp <T, U, Ret> {};
   template <class T, class U>
   struct has_plus<T, U, void> : public boost::binary_op_detail:: has_plus_void_imp <T, U> {};
   template <class T, class U>
   struct has_plus<T, U, boost::binary_op_detail::dont_care> : public boost::binary_op_detail:: has_plus_dc_imp <T, U> {};


}
# 49 "/usr/include/boost/type_traits/has_plus.hpp" 2 3 4
# 20 "/usr/include/boost/next_prior.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/has_plus_assign.hpp" 1 3 4
# 29 "/usr/include/boost/type_traits/has_plus_assign.hpp" 3
# 47 "/usr/include/boost/type_traits/has_plus_assign.hpp" 3
# 1 "/usr/include/boost/type_traits/remove_pointer.hpp" 1 3 4
# 20 "/usr/include/boost/type_traits/remove_pointer.hpp" 3 4
namespace boost {
# 68 "/usr/include/boost/type_traits/remove_pointer.hpp" 3 4
template <class T> struct remove_pointer{ typedef T type; };
template <class T> struct remove_pointer<T*>{ typedef T type; };
template <class T> struct remove_pointer<T*const>{ typedef T type; };
template <class T> struct remove_pointer<T*volatile>{ typedef T type; };
template <class T> struct remove_pointer<T*const volatile>{ typedef T type; };





   template <class T> using remove_pointer_t = typename remove_pointer<T>::type;



}
# 48 "/usr/include/boost/type_traits/has_plus_assign.hpp" 2 3




namespace boost
{

   namespace binary_op_detail {

      struct dont_care;

      template <class T, class U, class Ret, class = void>
      struct has_plus_assign_ret_imp : public boost::false_type {};

      template <class T, class U, class Ret>
      struct has_plus_assign_ret_imp<T, U, Ret, typename boost::make_void<decltype(std::declval<typename add_reference<T>::type>() += std::declval<typename add_reference<U>::type>())>::type>
         : public boost::integral_constant<bool, ::boost::is_convertible<decltype(std::declval<typename add_reference<T>::type>() += std::declval<typename add_reference<U>::type>()), Ret>::value> {};

      template <class T, class U, class = void >
      struct has_plus_assign_void_imp : public boost::false_type {};

      template <class T, class U>
      struct has_plus_assign_void_imp<T, U, typename boost::make_void<decltype(std::declval<typename add_reference<T>::type>() += std::declval<typename add_reference<U>::type>())>::type>
         : public boost::integral_constant<bool, ::boost::is_void<decltype(std::declval<typename add_reference<T>::type>() += std::declval<typename add_reference<U>::type>())>::value> {};

      template <class T, class U, class = void>
      struct has_plus_assign_dc_imp : public boost::false_type {};

      template <class T, class U>
      struct has_plus_assign_dc_imp<T, U, typename boost::make_void<decltype(std::declval<typename add_reference<T>::type>() += std::declval<typename add_reference<U>::type>())>::type>
         : public boost::true_type {};

      template <class T, class U, class Ret>
      struct has_plus_assign_filter_ret : public boost::binary_op_detail:: has_plus_assign_ret_imp <T, U, Ret> {};
      template <class T, class U>
      struct has_plus_assign_filter_ret<T, U, void> : public boost::binary_op_detail:: has_plus_assign_void_imp <T, U> {};
      template <class T, class U>
      struct has_plus_assign_filter_ret<T, U, boost::binary_op_detail::dont_care> : public boost::binary_op_detail:: has_plus_assign_dc_imp <T, U> {};

      template <class T, class U, class Ret, bool f>
      struct has_plus_assign_filter_impossible : public boost::binary_op_detail:: has_plus_assign_filter_ret <T, U, Ret> {};
      template <class T, class U, class Ret>
      struct has_plus_assign_filter_impossible<T, U, Ret, true> : public boost::false_type {};

   }

   template <class T, class U = T, class Ret = boost::binary_op_detail::dont_care>
   struct has_plus_assign : public boost::binary_op_detail:: has_plus_assign_filter_impossible <T, U, Ret, boost::is_arithmetic<typename boost::remove_reference<T>::type>::value && boost::is_pointer<typename remove_reference<U>::type>::value && !boost::is_same<bool, typename boost::remove_cv<typename remove_reference<T>::type>::type>::value> {};

}
# 21 "/usr/include/boost/next_prior.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/has_minus.hpp" 1 3 4
# 29 "/usr/include/boost/type_traits/has_minus.hpp" 3
# 48 "/usr/include/boost/type_traits/has_minus.hpp" 3
namespace boost
{

   namespace binary_op_detail {

      struct dont_care;

      template <class T, class U, class Ret, class = void>
      struct has_minus_ret_imp : public boost::false_type {};

      template <class T, class U, class Ret>
      struct has_minus_ret_imp<T, U, Ret, typename boost::make_void<decltype(std::declval<typename add_reference<T>::type>() - std::declval<typename add_reference<U>::type>())>::type>
         : public boost::integral_constant<bool, ::boost::is_convertible<decltype(std::declval<typename add_reference<T>::type>() - std::declval<typename add_reference<U>::type>()), Ret>::value> {};

      template <class T, class U, class = void >
      struct has_minus_void_imp : public boost::false_type {};

      template <class T, class U>
      struct has_minus_void_imp<T, U, typename boost::make_void<decltype(std::declval<typename add_reference<T>::type>() - std::declval<typename add_reference<U>::type>())>::type>
         : public boost::integral_constant<bool, ::boost::is_void<decltype(std::declval<typename add_reference<T>::type>() - std::declval<typename add_reference<U>::type>())>::value> {};

      template <class T, class U, class = void>
      struct has_minus_dc_imp : public boost::false_type {};

      template <class T, class U>
      struct has_minus_dc_imp<T, U, typename boost::make_void<decltype(std::declval<typename add_reference<T>::type>() - std::declval<typename add_reference<U>::type>())>::type>
         : public boost::true_type {};

      template <class T, class U, class Ret>
      struct has_minus_ret_filter : public boost::binary_op_detail::has_minus_ret_imp <T, U, Ret> {};
      template <class T, class U>
      struct has_minus_ret_filter<T, U, void> : public boost::binary_op_detail::has_minus_void_imp <T, U> {};
      template <class T, class U>
      struct has_minus_ret_filter<T, U, boost::binary_op_detail::dont_care> : public boost::binary_op_detail::has_minus_dc_imp <T, U> {};

      template <class T, class U, class Ret, bool b>
      struct has_minus_void_ptr_filter : public boost::binary_op_detail::has_minus_ret_filter <T, U, Ret> {};
      template <class T, class U, class Ret>
      struct has_minus_void_ptr_filter<T, U, Ret, true> : public boost::false_type {};

   }

   template <class T, class U = T, class Ret = boost::binary_op_detail::dont_care>
   struct has_minus :
      public boost::binary_op_detail::has_minus_void_ptr_filter<
         T, U, Ret,
         boost::is_void<typename remove_pointer<typename remove_reference<T>::type>::type>::value
         || boost::is_void<typename remove_pointer<typename remove_reference<U>::type>::type>::value> {};


}
# 22 "/usr/include/boost/next_prior.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/has_minus_assign.hpp" 1 3 4
# 29 "/usr/include/boost/type_traits/has_minus_assign.hpp" 3
# 49 "/usr/include/boost/type_traits/has_minus_assign.hpp" 3
namespace boost
{

   namespace binary_op_detail {

      struct dont_care;

      template <class T, class U, class Ret, class = void>
      struct has_minus_assign_ret_imp : public boost::false_type {};

      template <class T, class U, class Ret>
      struct has_minus_assign_ret_imp<T, U, Ret, typename boost::make_void<decltype(std::declval<typename add_reference<T>::type>() -= std::declval<typename add_reference<U>::type>())>::type>
         : public boost::integral_constant<bool, ::boost::is_convertible<decltype(std::declval<typename add_reference<T>::type>() -= std::declval<typename add_reference<U>::type>()), Ret>::value> {};

      template <class T, class U, class = void >
      struct has_minus_assign_void_imp : public boost::false_type {};

      template <class T, class U>
      struct has_minus_assign_void_imp<T, U, typename boost::make_void<decltype(std::declval<typename add_reference<T>::type>() -= std::declval<typename add_reference<U>::type>())>::type>
         : public boost::integral_constant<bool, ::boost::is_void<decltype(std::declval<typename add_reference<T>::type>() -= std::declval<typename add_reference<U>::type>())>::value> {};

      template <class T, class U, class = void>
      struct has_minus_assign_dc_imp : public boost::false_type {};

      template <class T, class U>
      struct has_minus_assign_dc_imp<T, U, typename boost::make_void<decltype(std::declval<typename add_reference<T>::type>() -= std::declval<typename add_reference<U>::type>())>::type>
         : public boost::true_type {};

      template <class T, class U, class Ret>
      struct has_minus_assign_ret_filter : public boost::binary_op_detail::has_minus_assign_ret_imp <T, U, Ret> {};
      template <class T, class U>
      struct has_minus_assign_ret_filter<T, U, void> : public boost::binary_op_detail::has_minus_assign_void_imp <T, U> {};
      template <class T, class U>
      struct has_minus_assign_ret_filter<T, U, boost::binary_op_detail::dont_care> : public boost::binary_op_detail::has_minus_assign_dc_imp <T, U> {};

      template <class T, class U, class Ret, bool b>
      struct has_minus_assign_void_ptr_filter : public boost::binary_op_detail::has_minus_assign_ret_filter <T, U, Ret> {};
      template <class T, class U, class Ret>
      struct has_minus_assign_void_ptr_filter<T, U, Ret, true> : public boost::false_type {};

   }

   template <class T, class U = T, class Ret = boost::binary_op_detail::dont_care>
   struct has_minus_assign :
      public boost::binary_op_detail::has_minus_assign_void_ptr_filter<
      T, U, Ret,
      boost::is_void<typename remove_pointer<typename remove_reference<T>::type>::type>::value
      || boost::is_void<typename remove_pointer<typename remove_reference<U>::type>::type>::value
      || (boost::is_pointer<typename remove_reference<T>::type>::value && boost::is_pointer<typename remove_reference<U>::type>::value)> {};


}
# 23 "/usr/include/boost/next_prior.hpp" 2 3 4
# 1 "/usr/include/boost/iterator/is_iterator.hpp" 1 3 4
# 20 "/usr/include/boost/iterator/is_iterator.hpp" 3 4
# 1 "/usr/include/boost/type_traits/negation.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/negation.hpp" 3 4
namespace boost {

template<class T>
struct negation
    : integral_constant<bool, !bool(T::value)> { };

}
# 21 "/usr/include/boost/iterator/is_iterator.hpp" 2 3 4
# 32 "/usr/include/boost/iterator/is_iterator.hpp" 3 4
namespace boost {
namespace iterators {
namespace detail {







namespace has_iterator_category_detail {

typedef char yes_type;
struct no_type { char padding[2]; };

template< typename T >
yes_type check(

    typename std::iterator_traits< T >::iterator_category*



);
template< typename >
no_type check(...);

}

template< typename T >
struct is_iterator_impl :
    public boost::integral_constant<
        bool,
        sizeof(has_iterator_category_detail::check< T >(0)) == sizeof(has_iterator_category_detail::yes_type)
    >
{
};

template< typename T >
struct is_iterator_impl< T* > :
    public boost::conjunction<
        boost::is_complete< T >,
        boost::negation< boost::is_function< T > >
    >::type
{
};

template< typename T, typename U >
struct is_iterator_impl< T U::* > :
    public boost::false_type
{
};

template< typename T >
struct is_iterator_impl< T& > :
    public boost::false_type
{
};

template< typename T, std::size_t N >
struct is_iterator_impl< T[N] > :
    public boost::false_type
{
};
# 116 "/usr/include/boost/iterator/is_iterator.hpp" 3 4
}
# 133 "/usr/include/boost/iterator/is_iterator.hpp" 3 4
template< typename T >
struct is_iterator : public detail::is_iterator_impl< T >::type {};
template< typename T >
struct is_iterator< const T > : public detail::is_iterator_impl< T >::type {};
template< typename T >
struct is_iterator< volatile T > : public detail::is_iterator_impl< T >::type {};
template< typename T >
struct is_iterator< const volatile T > : public detail::is_iterator_impl< T >::type {};

}

using iterators::is_iterator;

}
# 24 "/usr/include/boost/next_prior.hpp" 2 3 4
# 1 "/usr/include/boost/iterator/advance.hpp" 1 3 4
# 12 "/usr/include/boost/iterator/advance.hpp" 3 4
# 1 "/usr/include/boost/iterator/iterator_categories.hpp" 1 3 4
# 10 "/usr/include/boost/iterator/iterator_categories.hpp" 3 4
# 1 "/usr/include/boost/iterator/detail/config_def.hpp" 1 3 4
# 11 "/usr/include/boost/iterator/iterator_categories.hpp" 2 3 4



# 1 "/usr/include/boost/mpl/eval_if.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/eval_if.hpp" 3 4
# 1 "/usr/include/boost/mpl/if.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/if.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/value_wknd.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/aux_/value_wknd.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/static_cast.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/aux_/static_cast.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/config/workaround.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/aux_/static_cast.hpp" 2 3 4
# 18 "/usr/include/boost/mpl/aux_/value_wknd.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/config/integral.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/aux_/config/integral.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/config/msvc.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/aux_/config/integral.hpp" 2 3 4
# 19 "/usr/include/boost/mpl/aux_/value_wknd.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/config/eti.hpp" 1 3 4
# 20 "/usr/include/boost/mpl/aux_/value_wknd.hpp" 2 3 4
# 73 "/usr/include/boost/mpl/aux_/value_wknd.hpp" 3 4
namespace boost { namespace mpl { namespace aux {

template< typename T > struct value_type_wknd
{
    typedef typename T::value_type type;
};
# 87 "/usr/include/boost/mpl/aux_/value_wknd.hpp" 3 4
}}}
# 18 "/usr/include/boost/mpl/if.hpp" 2 3 4

# 1 "/usr/include/boost/mpl/aux_/na_spec.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/aux_/na_spec.hpp" 3 4
# 1 "/usr/include/boost/mpl/lambda_fwd.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/lambda_fwd.hpp" 3 4
# 1 "/usr/include/boost/mpl/void_fwd.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/void_fwd.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/adl_barrier.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/aux_/adl_barrier.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/config/adl.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/aux_/config/adl.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/config/intel.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/aux_/config/adl.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/config/gcc.hpp" 1 3 4
# 20 "/usr/include/boost/mpl/aux_/config/adl.hpp" 2 3 4
# 18 "/usr/include/boost/mpl/aux_/adl_barrier.hpp" 2 3 4
# 33 "/usr/include/boost/mpl/aux_/adl_barrier.hpp" 3 4
namespace mpl_ { namespace aux {} }
namespace boost { namespace mpl { using namespace mpl_;
namespace aux { using namespace mpl_::aux; }
}}
# 18 "/usr/include/boost/mpl/void_fwd.hpp" 2 3 4

namespace mpl_ {

struct void_;

}
namespace boost { namespace mpl { using ::mpl_::void_; } }
# 18 "/usr/include/boost/mpl/lambda_fwd.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/na.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/aux_/na.hpp" 3 4
# 1 "/usr/include/boost/mpl/bool.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/bool.hpp" 3 4
# 1 "/usr/include/boost/mpl/bool_fwd.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/bool_fwd.hpp" 3 4
namespace mpl_ {

template< bool C_ > struct bool_;


typedef bool_<true> true_;
typedef bool_<false> false_;

}

namespace boost { namespace mpl { using ::mpl_::bool_; } }
namespace boost { namespace mpl { using ::mpl_::true_; } }
namespace boost { namespace mpl { using ::mpl_::false_; } }
# 18 "/usr/include/boost/mpl/bool.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/integral_c_tag.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/integral_c_tag.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/config/static_constant.hpp" 1 3 4
# 20 "/usr/include/boost/mpl/integral_c_tag.hpp" 2 3 4

namespace mpl_ {
struct integral_c_tag { static const int value = 0; };
}
namespace boost { namespace mpl { using ::mpl_::integral_c_tag; } }
# 19 "/usr/include/boost/mpl/bool.hpp" 2 3 4


namespace mpl_ {

template< bool C_ > struct bool_
{
    static const bool value = C_;
    typedef integral_c_tag tag;
    typedef bool_ type;
    typedef bool value_type;
    constexpr operator bool() const { return this->value; }
};


template< bool C_ >
bool const bool_<C_>::value;


}
# 18 "/usr/include/boost/mpl/aux_/na.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/na_fwd.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/aux_/na_fwd.hpp" 3 4
namespace mpl_ {


struct na
{
    typedef na type;
    enum { value = 0 };
};

}
namespace boost { namespace mpl { using ::mpl_::na; } }
# 19 "/usr/include/boost/mpl/aux_/na.hpp" 2 3 4

# 1 "/usr/include/boost/mpl/aux_/config/ctps.hpp" 1 3 4
# 21 "/usr/include/boost/mpl/aux_/na.hpp" 2 3 4

namespace boost { namespace mpl {

template< typename T >
struct is_na
    : false_
{



};

template<>
struct is_na<na>
    : true_
{



};

template< typename T >
struct is_not_na
    : true_
{



};

template<>
struct is_not_na<na>
    : false_
{



};


template< typename T, typename U > struct if_na
{
    typedef T type;
};

template< typename U > struct if_na<na,U>
{
    typedef U type;
};
# 93 "/usr/include/boost/mpl/aux_/na.hpp" 3 4
}}
# 19 "/usr/include/boost/mpl/lambda_fwd.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/config/lambda.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/aux_/config/lambda.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/config/ttp.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/aux_/config/lambda.hpp" 2 3 4
# 20 "/usr/include/boost/mpl/lambda_fwd.hpp" 2 3 4



# 1 "/usr/include/boost/mpl/int.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/int.hpp" 3 4
# 1 "/usr/include/boost/mpl/int_fwd.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/int_fwd.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/nttp_decl.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/aux_/nttp_decl.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/config/nttp.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/aux_/nttp_decl.hpp" 2 3 4
# 19 "/usr/include/boost/mpl/int_fwd.hpp" 2 3 4

namespace mpl_ {

template< int N > struct int_;

}
namespace boost { namespace mpl { using ::mpl_::int_; } }
# 18 "/usr/include/boost/mpl/int.hpp" 2 3 4


# 1 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 1 3 4
# 40 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 3 4
namespace mpl_ {

template< int N >
struct int_
{
    static const int value = N;





    typedef int_ type;

    typedef int value_type;
    typedef integral_c_tag tag;
# 72 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 3 4
    typedef mpl_::int_< static_cast<int>((value + 1)) > next;
    typedef mpl_::int_< static_cast<int>((value - 1)) > prior;






    constexpr operator int() const { return static_cast<int>(this->value); }
};


template< int N >
int const mpl_::int_< N >::value;


}
# 21 "/usr/include/boost/mpl/int.hpp" 2 3 4
# 24 "/usr/include/boost/mpl/lambda_fwd.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/lambda_arity_param.hpp" 1 3 4
# 25 "/usr/include/boost/mpl/lambda_fwd.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/template_arity_fwd.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/aux_/template_arity_fwd.hpp" 3 4
namespace boost { namespace mpl { namespace aux {

template< typename F > struct template_arity;

}}}
# 26 "/usr/include/boost/mpl/lambda_fwd.hpp" 2 3 4

namespace boost { namespace mpl {

template<
      typename T = na
    , typename Tag = void_
    , typename Arity = int_< aux::template_arity<T>::value >


    >
struct lambda;

}}
# 19 "/usr/include/boost/mpl/aux_/na_spec.hpp" 2 3 4



# 1 "/usr/include/boost/mpl/aux_/arity.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/aux_/arity.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/config/dtp.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/aux_/arity.hpp" 2 3 4
# 23 "/usr/include/boost/mpl/aux_/na_spec.hpp" 2 3 4



# 1 "/usr/include/boost/mpl/aux_/preprocessor/params.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/aux_/preprocessor/params.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/config/preprocessor.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/aux_/preprocessor/params.hpp" 2 3 4
# 49 "/usr/include/boost/mpl/aux_/preprocessor/params.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/comma_if.hpp" 1 3 4
# 50 "/usr/include/boost/mpl/aux_/preprocessor/params.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/repeat.hpp" 1 3 4
# 51 "/usr/include/boost/mpl/aux_/preprocessor/params.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/inc.hpp" 1 3 4
# 52 "/usr/include/boost/mpl/aux_/preprocessor/params.hpp" 2 3 4
# 27 "/usr/include/boost/mpl/aux_/na_spec.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessor/enum.hpp" 1 3 4
# 28 "/usr/include/boost/mpl/aux_/na_spec.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 3 4
# 1 "/usr/include/boost/mpl/limits/arity.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2 3 4





# 1 "/usr/include/boost/preprocessor/identity.hpp" 1 3 4
# 24 "/usr/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/empty.hpp" 1 3 4
# 25 "/usr/include/boost/mpl/aux_/preprocessor/def_params_tail.hpp" 2 3 4
# 29 "/usr/include/boost/mpl/aux_/na_spec.hpp" 2 3 4






# 1 "/usr/include/boost/mpl/aux_/config/overload_resolution.hpp" 1 3 4
# 36 "/usr/include/boost/mpl/aux_/na_spec.hpp" 2 3 4
# 20 "/usr/include/boost/mpl/if.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/lambda_support.hpp" 1 3 4
# 21 "/usr/include/boost/mpl/if.hpp" 2 3 4




namespace boost { namespace mpl {



template<
      bool C
    , typename T1
    , typename T2
    >
struct if_c
{
    typedef T1 type;
};

template<
      typename T1
    , typename T2
    >
struct if_c<false,T1,T2>
{
    typedef T2 type;
};



template<
      typename T1 = na
    , typename T2 = na
    , typename T3 = na
    >
struct if_
{
 private:

    typedef if_c<



          static_cast<bool>(T1::value)

        , T2
        , T3
        > almost_type_;

 public:
    typedef typename almost_type_::type type;


};
# 131 "/usr/include/boost/mpl/if.hpp" 3 4
template<> struct if_< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : if_< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< if_< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef if_< na , na , na > result_; typedef if_< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< if_< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< if_< na , na , na > > : int_<-1> { }; }

}}
# 18 "/usr/include/boost/mpl/eval_if.hpp" 2 3 4






namespace boost { namespace mpl {

template<
      typename C = na
    , typename F1 = na
    , typename F2 = na
    >
struct eval_if




{
    typedef typename if_<C,F1,F2>::type f_;
    typedef typename f_::type type;





};



template<
      bool C
    , typename F1
    , typename F2
    >
struct eval_if_c




{
    typedef typename if_c<C,F1,F2>::type f_;
    typedef typename f_::type type;




};

template<> struct eval_if< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : eval_if< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< eval_if< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef eval_if< na , na , na > result_; typedef eval_if< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< eval_if< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< eval_if< na , na , na > > : int_<-1> { }; }

}}
# 15 "/usr/include/boost/iterator/iterator_categories.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/identity.hpp" 1 3 4
# 20 "/usr/include/boost/mpl/identity.hpp" 3 4
namespace boost { namespace mpl {

template<
      typename T = na
    >
struct identity
{
    typedef T type;

};

template<
      typename T = na
    >
struct make_identity
{
    typedef identity<T> type;

};

template<> struct identity< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : identity< T1 > { }; }; template< typename Tag > struct lambda< identity< na > , Tag , int_<-1> > { typedef false_ is_le; typedef identity< na > result_; typedef identity< na > type; }; namespace aux { template< typename T1 > struct template_arity< identity< T1 > > : int_<1> { }; template<> struct template_arity< identity< na > > : int_<-1> { }; }
template<> struct make_identity< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : make_identity< T1 > { }; }; template< typename Tag > struct lambda< make_identity< na > , Tag , int_<-1> > { typedef false_ is_le; typedef make_identity< na > result_; typedef make_identity< na > type; }; namespace aux { template< typename T1 > struct template_arity< make_identity< T1 > > : int_<1> { }; template<> struct template_arity< make_identity< na > > : int_<-1> { }; }

}}
# 16 "/usr/include/boost/iterator/iterator_categories.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/placeholders.hpp" 1 3 4
# 24 "/usr/include/boost/mpl/placeholders.hpp" 3 4
# 1 "/usr/include/boost/mpl/arg.hpp" 1 3 4
# 23 "/usr/include/boost/mpl/arg.hpp" 3 4
# 1 "/usr/include/boost/mpl/arg_fwd.hpp" 1 3 4
# 21 "/usr/include/boost/mpl/arg_fwd.hpp" 3 4
namespace mpl_ {

template< int N > struct arg;

}
namespace boost { namespace mpl { using ::mpl_::arg; } }
# 24 "/usr/include/boost/mpl/arg.hpp" 2 3 4

# 1 "/usr/include/boost/mpl/aux_/na_assert.hpp" 1 3 4
# 23 "/usr/include/boost/mpl/aux_/na_assert.hpp" 3 4
# 1 "/usr/include/boost/mpl/assert.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/assert.hpp" 3 4
# 1 "/usr/include/boost/mpl/not.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/not.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/nested_type_wknd.hpp" 1 3 4
# 25 "/usr/include/boost/mpl/aux_/nested_type_wknd.hpp" 3 4
namespace boost { namespace mpl { namespace aux {
template< typename T > struct nested_type_wknd
    : T::type
{
};
}}}
# 20 "/usr/include/boost/mpl/not.hpp" 2 3 4



namespace boost { namespace mpl {

namespace aux {

template< long C_ >
struct not_impl
    : bool_<!C_>
{
};

}


template<
      typename T = na
    >
struct not_
    : aux::not_impl<
          ::boost::mpl::aux::nested_type_wknd<T>::value
        >
{

};

template<> struct not_< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : not_< T1 > { }; }; template< typename Tag > struct lambda< not_< na > , Tag , int_<-1> > { typedef false_ is_le; typedef not_< na > result_; typedef not_< na > type; }; namespace aux { template< typename T1 > struct template_arity< not_< T1 > > : int_<1> { }; template<> struct template_arity< not_< na > > : int_<-1> { }; }

}}
# 18 "/usr/include/boost/mpl/assert.hpp" 2 3 4


# 1 "/usr/include/boost/mpl/aux_/yes_no.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/aux_/yes_no.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/config/arrays.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/aux_/yes_no.hpp" 2 3 4





namespace boost { namespace mpl { namespace aux {

typedef char (&no_tag)[1];
typedef char (&yes_tag)[2];

template< bool C_ > struct yes_no_tag
{
    typedef no_tag type;
};

template<> struct yes_no_tag<true>
{
    typedef yes_tag type;
};


template< std::size_t n > struct weighted_tag
{

    typedef char (&type)[n];




};
# 57 "/usr/include/boost/mpl/aux_/yes_no.hpp" 3 4
}}}
# 21 "/usr/include/boost/mpl/assert.hpp" 2 3 4







# 1 "/usr/include/boost/mpl/aux_/config/gpu.hpp" 1 3 4
# 29 "/usr/include/boost/mpl/assert.hpp" 2 3 4

# 1 "/usr/include/boost/mpl/aux_/config/pp_counter.hpp" 1 3 4
# 31 "/usr/include/boost/mpl/assert.hpp" 2 3 4
# 66 "/usr/include/boost/mpl/assert.hpp" 3 4
namespace mpl_ {

struct failed {};
# 79 "/usr/include/boost/mpl/assert.hpp" 3 4
template< bool C > struct assert { typedef void* type; };
template<> struct assert<false> { typedef assert type; };

template< bool C >
int assertion_failed( typename assert<C>::type );

template< bool C >
struct assertion
{
    static int failed( assert<false> );
};

template<>
struct assertion<true>
{
    static int failed( void* );
};

struct assert_
{

    template< typename T1, typename T2 = na, typename T3 = na, typename T4 = na > struct types {};

    static assert_ const arg;
    enum relations { equal = 1, not_equal, greater, greater_equal, less, less_equal };
};
# 127 "/usr/include/boost/mpl/assert.hpp" 3 4
boost::mpl::aux::weighted_tag<1>::type operator==( assert_, assert_ );
boost::mpl::aux::weighted_tag<2>::type operator!=( assert_, assert_ );
boost::mpl::aux::weighted_tag<3>::type operator>( assert_, assert_ );
boost::mpl::aux::weighted_tag<4>::type operator>=( assert_, assert_ );
boost::mpl::aux::weighted_tag<5>::type operator<( assert_, assert_ );
boost::mpl::aux::weighted_tag<6>::type operator<=( assert_, assert_ );

template< assert_::relations r, long x, long y > struct assert_relation {};
# 171 "/usr/include/boost/mpl/assert.hpp" 3 4
template< bool > struct assert_arg_pred_impl { typedef int type; };
template<> struct assert_arg_pred_impl<true> { typedef void* type; };

template< typename P > struct assert_arg_pred
{
    typedef typename P::type p_type;
    typedef typename assert_arg_pred_impl< p_type::value >::type type;
};

template< typename P > struct assert_arg_pred_not
{
    typedef typename P::type p_type;
    enum { p = !p_type::value };
    typedef typename assert_arg_pred_impl<p>::type type;
};







template< typename Pred >
failed ************ (Pred::************
      assert_arg( void (*)(Pred), typename assert_arg_pred<Pred>::type )
    );

template< typename Pred >
failed ************ (boost::mpl::not_<Pred>::************
      assert_not_arg( void (*)(Pred), typename assert_arg_pred_not<Pred>::type )
    );






template< typename Pred >
assert<false>
assert_arg( void (*)(Pred), typename assert_arg_pred_not<Pred>::type );

template< typename Pred >
assert<false>
assert_not_arg( void (*)(Pred), typename assert_arg_pred<Pred>::type );
# 257 "/usr/include/boost/mpl/assert.hpp" 3 4
}
# 24 "/usr/include/boost/mpl/aux_/na_assert.hpp" 2 3 4
# 26 "/usr/include/boost/mpl/arg.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/arity_spec.hpp" 1 3 4
# 27 "/usr/include/boost/mpl/arg.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/arg_typedef.hpp" 1 3 4
# 28 "/usr/include/boost/mpl/arg.hpp" 2 3 4



# 1 "/usr/include/boost/mpl/aux_/config/use_preprocessed.hpp" 1 3 4
# 32 "/usr/include/boost/mpl/arg.hpp" 2 3 4





# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 16 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/config/compiler.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4



# 1 "/usr/include/boost/preprocessor/stringize.hpp" 1 3 4
# 21 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/arg.hpp" 1 3 4
# 13 "/usr/include/boost/mpl/aux_/preprocessed/gcc/arg.hpp" 3 4
namespace mpl_ {
template<> struct arg< -1 >
{
    static const int value = -1;



    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
        typedef U1 type;
        enum { mpl_assertion_in_line_27 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))nullptr, 1 ) ) ) };
    };
};

template<> struct arg<1>
{
    static const int value = 1;
    typedef arg<2> next;



    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
        typedef U1 type;
        enum { mpl_assertion_in_line_45 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))nullptr, 1 ) ) ) };
    };
};

template<> struct arg<2>
{
    static const int value = 2;
    typedef arg<3> next;



    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
        typedef U2 type;
        enum { mpl_assertion_in_line_63 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))nullptr, 1 ) ) ) };
    };
};

template<> struct arg<3>
{
    static const int value = 3;
    typedef arg<4> next;



    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
        typedef U3 type;
        enum { mpl_assertion_in_line_81 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))nullptr, 1 ) ) ) };
    };
};

template<> struct arg<4>
{
    static const int value = 4;
    typedef arg<5> next;



    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
        typedef U4 type;
        enum { mpl_assertion_in_line_99 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))nullptr, 1 ) ) ) };
    };
};

template<> struct arg<5>
{
    static const int value = 5;
    typedef arg<6> next;



    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
        typedef U5 type;
        enum { mpl_assertion_in_line_117 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_not_arg( (void (*) (boost::mpl::is_na<type>))nullptr, 1 ) ) ) };
    };
};



}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 38 "/usr/include/boost/mpl/arg.hpp" 2 3 4
# 25 "/usr/include/boost/mpl/placeholders.hpp" 2 3 4
# 43 "/usr/include/boost/mpl/placeholders.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/placeholders.hpp" 1 3 4
# 13 "/usr/include/boost/mpl/aux_/preprocessed/gcc/placeholders.hpp" 3 4
namespace mpl_ {
typedef arg< -1 > _;
}
namespace boost { namespace mpl {

using ::mpl_::_;

namespace placeholders {
using mpl_::_;
}

}}



namespace mpl_ {
typedef arg<1> _1;

}
namespace boost { namespace mpl {

using ::mpl_::_1;

namespace placeholders {
using mpl_::_1;
}

}}
namespace mpl_ {
typedef arg<2> _2;

}
namespace boost { namespace mpl {

using ::mpl_::_2;

namespace placeholders {
using mpl_::_2;
}

}}
namespace mpl_ {
typedef arg<3> _3;

}
namespace boost { namespace mpl {

using ::mpl_::_3;

namespace placeholders {
using mpl_::_3;
}

}}
namespace mpl_ {
typedef arg<4> _4;

}
namespace boost { namespace mpl {

using ::mpl_::_4;

namespace placeholders {
using mpl_::_4;
}

}}
namespace mpl_ {
typedef arg<5> _5;

}
namespace boost { namespace mpl {

using ::mpl_::_5;

namespace placeholders {
using mpl_::_5;
}

}}
namespace mpl_ {
typedef arg<6> _6;

}
namespace boost { namespace mpl {

using ::mpl_::_6;

namespace placeholders {
using mpl_::_6;
}

}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 44 "/usr/include/boost/mpl/placeholders.hpp" 2 3 4
# 17 "/usr/include/boost/iterator/iterator_categories.hpp" 2 3 4








namespace boost {
namespace iterators {





struct no_traversal_tag {};

struct incrementable_traversal_tag
  : no_traversal_tag
{


};

struct single_pass_traversal_tag
  : incrementable_traversal_tag
{


};

struct forward_traversal_tag
  : single_pass_traversal_tag
{


};

struct bidirectional_traversal_tag
  : forward_traversal_tag
{


};

struct random_access_traversal_tag
  : bidirectional_traversal_tag
{


};

namespace detail
{






  template <class Cat>
  struct old_category_to_traversal
    : mpl::eval_if<
          is_convertible<Cat,std::random_access_iterator_tag>
        , mpl::identity<random_access_traversal_tag>
        , mpl::eval_if<
              is_convertible<Cat,std::bidirectional_iterator_tag>
            , mpl::identity<bidirectional_traversal_tag>
            , mpl::eval_if<
                  is_convertible<Cat,std::forward_iterator_tag>
                , mpl::identity<forward_traversal_tag>
                , mpl::eval_if<
                      is_convertible<Cat,std::input_iterator_tag>
                    , mpl::identity<single_pass_traversal_tag>
                    , mpl::eval_if<
                          is_convertible<Cat,std::output_iterator_tag>
                        , mpl::identity<incrementable_traversal_tag>
                        , void
                      >
                  >
              >
          >
      >
  {};

}




template <class Cat>
struct iterator_category_to_traversal
  : mpl::eval_if<
        is_convertible<Cat,incrementable_traversal_tag>
      , mpl::identity<Cat>
      , boost::iterators::detail::old_category_to_traversal<Cat>
    >
{};


template <class Iterator = mpl::_1>
struct iterator_traversal
  : iterator_category_to_traversal<
        typename std::iterator_traits<Iterator>::iterator_category
    >
{};
# 146 "/usr/include/boost/iterator/iterator_categories.hpp" 3 4
template <class Traversal>
struct pure_traversal_tag
  : mpl::eval_if<
        is_convertible<Traversal,random_access_traversal_tag>
      , mpl::identity<random_access_traversal_tag>
      , mpl::eval_if<
            is_convertible<Traversal,bidirectional_traversal_tag>
          , mpl::identity<bidirectional_traversal_tag>
          , mpl::eval_if<
                is_convertible<Traversal,forward_traversal_tag>
              , mpl::identity<forward_traversal_tag>
              , mpl::eval_if<
                    is_convertible<Traversal,single_pass_traversal_tag>
                  , mpl::identity<single_pass_traversal_tag>
                  , mpl::eval_if<
                        is_convertible<Traversal,incrementable_traversal_tag>
                      , mpl::identity<incrementable_traversal_tag>
                      , void
                    >
                >
            >
        >
    >
{
};




template <class Iterator = mpl::_1>
struct pure_iterator_traversal
  : pure_traversal_tag<typename iterator_traversal<Iterator>::type>
{};
# 194 "/usr/include/boost/iterator/iterator_categories.hpp" 3 4
}

using iterators::no_traversal_tag;
using iterators::incrementable_traversal_tag;
using iterators::single_pass_traversal_tag;
using iterators::forward_traversal_tag;
using iterators::bidirectional_traversal_tag;
using iterators::random_access_traversal_tag;
using iterators::iterator_category_to_traversal;
using iterators::iterator_traversal;




namespace detail {
using iterators::pure_traversal_tag;
}

}

# 1 "/usr/include/boost/iterator/detail/config_undef.hpp" 1 3 4
# 215 "/usr/include/boost/iterator/iterator_categories.hpp" 2 3 4
# 13 "/usr/include/boost/iterator/advance.hpp" 2 3 4

namespace boost {
namespace iterators {

    namespace detail {
        template <typename InputIterator, typename Distance>
        inline constexpr void
        advance_impl(
            InputIterator& it
          , Distance n
          , incrementable_traversal_tag
        )
        {
            while (n > 0) {
                ++it;
                --n;
            }
        }







        template <typename BidirectionalIterator, typename Distance>
        inline constexpr void
        advance_impl(
            BidirectionalIterator& it
          , Distance n
          , bidirectional_traversal_tag
        )
        {
            if (n >= 0) {
                while (n > 0) {
                    ++it;
                    --n;
                }
            }
            else {
                while (n < 0) {
                    --it;
                    ++n;
                }
            }
        }





        template <typename RandomAccessIterator, typename Distance>
        inline constexpr void
        advance_impl(
            RandomAccessIterator& it
          , Distance n
          , random_access_traversal_tag
        )
        {
            it += n;
        }
    }

    namespace advance_adl_barrier {
        template <typename InputIterator, typename Distance>
        inline constexpr void
        advance(InputIterator& it, Distance n)
        {
            detail::advance_impl(
                it, n, typename iterator_traversal<InputIterator>::type()
            );
        }
    }

    using namespace advance_adl_barrier;

}

using namespace iterators::advance_adl_barrier;

}
# 25 "/usr/include/boost/next_prior.hpp" 2 3 4
# 1 "/usr/include/boost/iterator/reverse_iterator.hpp" 1 3 4
# 10 "/usr/include/boost/iterator/reverse_iterator.hpp" 3 4
# 1 "/usr/include/boost/iterator/iterator_adaptor.hpp" 1 3 4
# 12 "/usr/include/boost/iterator/iterator_adaptor.hpp" 3 4
# 1 "/usr/include/boost/core/use_default.hpp" 1 3 4
# 11 "/usr/include/boost/core/use_default.hpp" 3 4
namespace boost {

struct use_default { };

}
# 13 "/usr/include/boost/iterator/iterator_adaptor.hpp" 2 3 4


# 1 "/usr/include/boost/iterator/iterator_facade.hpp" 1 3 4
# 11 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
# 1 "/usr/include/boost/iterator/interoperable.hpp" 1 3 4
# 11 "/usr/include/boost/iterator/interoperable.hpp" 3 4
# 1 "/usr/include/boost/mpl/or.hpp" 1 3 4
# 43 "/usr/include/boost/mpl/or.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/or.hpp" 1 3 4
# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/or.hpp" 3 4
namespace boost { namespace mpl {

namespace aux {

template< bool C_, typename T1, typename T2, typename T3, typename T4 >
struct or_impl
    : true_
{
};

template< typename T1, typename T2, typename T3, typename T4 >
struct or_impl< false,T1,T2,T3,T4 >
    : or_impl<
          ::boost::mpl::aux::nested_type_wknd<T1>::value
        , T2, T3, T4
        , false_
        >
{
};

template<>
struct or_impl<
          false
        , false_, false_, false_, false_
        >
    : false_
{
};

}

template<
      typename T1 = na
    , typename T2 = na
    , typename T3 = false_, typename T4 = false_, typename T5 = false_
    >
struct or_

    : aux::or_impl<
          ::boost::mpl::aux::nested_type_wknd<T1>::value
        , T2, T3, T4, T5
        >

{





};

template<> struct or_< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : or_< T1 , T2 > { }; }; template< typename Tag > struct lambda< or_< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef or_< na , na > result_; typedef or_< na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct template_arity< or_< T1 , T2 , T3 , T4 , T5 > > : int_<5> { }; template<> struct template_arity< or_< na , na > > : int_<-1> { }; }





}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 44 "/usr/include/boost/mpl/or.hpp" 2 3 4
# 12 "/usr/include/boost/iterator/interoperable.hpp" 2 3 4



# 1 "/usr/include/boost/iterator/detail/config_def.hpp" 1 3 4
# 16 "/usr/include/boost/iterator/interoperable.hpp" 2 3 4

namespace boost {
namespace iterators {
# 34 "/usr/include/boost/iterator/interoperable.hpp" 3 4
  template <typename A, typename B>
  struct is_interoperable



    : mpl::or_<
          is_convertible< A, B >
        , is_convertible< B, A > >

  {
  };

}

using iterators::is_interoperable;

}

# 1 "/usr/include/boost/iterator/detail/config_undef.hpp" 1 3 4
# 53 "/usr/include/boost/iterator/interoperable.hpp" 2 3 4
# 12 "/usr/include/boost/iterator/iterator_facade.hpp" 2 3 4
# 1 "/usr/include/boost/iterator/iterator_traits.hpp" 1 3 4
# 12 "/usr/include/boost/iterator/iterator_traits.hpp" 3 4
namespace boost {
namespace iterators {






template <class Iterator>
struct iterator_value
{
    typedef typename std::iterator_traits<Iterator>::value_type type;
};

template <class Iterator>
struct iterator_reference
{
    typedef typename std::iterator_traits<Iterator>::reference type;
};


template <class Iterator>
struct iterator_pointer
{
    typedef typename std::iterator_traits<Iterator>::pointer type;
};

template <class Iterator>
struct iterator_difference
{
    typedef typename std::iterator_traits<Iterator>::difference_type type;
};

template <class Iterator>
struct iterator_category
{
    typedef typename std::iterator_traits<Iterator>::iterator_category type;
};

}

using iterators::iterator_value;
using iterators::iterator_reference;
using iterators::iterator_pointer;
using iterators::iterator_difference;
using iterators::iterator_category;

}
# 13 "/usr/include/boost/iterator/iterator_facade.hpp" 2 3 4


# 1 "/usr/include/boost/iterator/detail/facade_iterator_category.hpp" 1 3 4
# 12 "/usr/include/boost/iterator/detail/facade_iterator_category.hpp" 3 4
# 1 "/usr/include/boost/mpl/and.hpp" 1 3 4
# 42 "/usr/include/boost/mpl/and.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/and.hpp" 1 3 4
# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/and.hpp" 3 4
namespace boost { namespace mpl {

namespace aux {

template< bool C_, typename T1, typename T2, typename T3, typename T4 >
struct and_impl
    : false_
{
};

template< typename T1, typename T2, typename T3, typename T4 >
struct and_impl< true,T1,T2,T3,T4 >
    : and_impl<
          ::boost::mpl::aux::nested_type_wknd<T1>::value
        , T2, T3, T4
        , true_
        >
{
};

template<>
struct and_impl<
          true
        , true_, true_, true_, true_
        >
    : true_
{
};

}

template<
      typename T1 = na
    , typename T2 = na
    , typename T3 = true_, typename T4 = true_, typename T5 = true_
    >
struct and_

    : aux::and_impl<
          ::boost::mpl::aux::nested_type_wknd<T1>::value
        , T2, T3, T4, T5
        >

{





};

template<> struct and_< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : and_< T1 , T2 > { }; }; template< typename Tag > struct lambda< and_< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef and_< na , na > result_; typedef and_< na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct template_arity< and_< T1 , T2 , T3 , T4 , T5 > > : int_<5> { }; template<> struct template_arity< and_< na , na > > : int_<-1> { }; }





}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 43 "/usr/include/boost/mpl/and.hpp" 2 3 4
# 13 "/usr/include/boost/iterator/detail/facade_iterator_category.hpp" 2 3 4
# 24 "/usr/include/boost/iterator/detail/facade_iterator_category.hpp" 3 4
# 1 "/usr/include/boost/iterator/detail/config_def.hpp" 1 3 4
# 25 "/usr/include/boost/iterator/detail/facade_iterator_category.hpp" 2 3 4


# 1 "/usr/include/boost/detail/indirect_traits.hpp" 1 3 4
# 11 "/usr/include/boost/detail/indirect_traits.hpp" 3 4
# 1 "/usr/include/boost/type_traits/is_class.hpp" 1 3 4
# 31 "/usr/include/boost/type_traits/is_class.hpp" 3 4
namespace boost {

namespace detail {
# 96 "/usr/include/boost/type_traits/is_class.hpp" 3 4
template <typename T>
struct is_class_impl
{
    static const bool value = __is_class(T);
};


}

template <class T> struct is_class : public integral_constant<bool, ::boost::detail::is_class_impl<T>::value> {};






}
# 12 "/usr/include/boost/detail/indirect_traits.hpp" 2 3 4
# 21 "/usr/include/boost/detail/indirect_traits.hpp" 3 4
# 1 "/usr/include/boost/detail/select_type.hpp" 1 3 4
# 16 "/usr/include/boost/detail/select_type.hpp" 3 4
namespace boost { namespace detail {






  template <bool b> struct if_true
  {
      template <class T, class F>
      struct then { typedef T type; };
  };

  template <>
  struct if_true<false>
  {
      template <class T, class F>
      struct then { typedef F type; };
  };
}}
# 22 "/usr/include/boost/detail/indirect_traits.hpp" 2 3 4


namespace boost { namespace detail {

namespace indirect_traits {

template <class T>
struct is_reference_to_const : boost::false_type
{
};

template <class T>
struct is_reference_to_const<T const&> : boost::true_type
{
};
# 45 "/usr/include/boost/detail/indirect_traits.hpp" 3 4
template <class T>
struct is_reference_to_function : boost::false_type
{
};

template <class T>
struct is_reference_to_function<T&> : is_function<T>
{
};

template <class T>
struct is_pointer_to_function : boost::false_type
{
};



template <class T>
struct is_pointer_to_function<T*> : is_function<T>
{
};

template <class T>
struct is_reference_to_member_function_pointer_impl : boost::false_type
{
};

template <class T>
struct is_reference_to_member_function_pointer_impl<T&>
    : is_member_function_pointer<typename remove_cv<T>::type>
{
};


template <class T>
struct is_reference_to_member_function_pointer
    : is_reference_to_member_function_pointer_impl<T>
{
};

template <class T>
struct is_reference_to_function_pointer_aux
    : boost::integral_constant<bool,
          is_reference<T>::value &&
          is_pointer_to_function<
              typename remove_cv<
                  typename remove_reference<T>::type
              >::type
          >::value
      >
{

};

template <class T>
struct is_reference_to_function_pointer
    : boost::detail::if_true<
          is_reference_to_function<T>::value
      >::template then<
          boost::false_type
        , is_reference_to_function_pointer_aux<T>
      >::type
{
};

template <class T>
struct is_reference_to_non_const
    : boost::integral_constant<bool,
          is_reference<T>::value &&
          !is_reference_to_const<T>::value
      >
{
};

template <class T>
struct is_reference_to_volatile : boost::false_type
{
};

template <class T>
struct is_reference_to_volatile<T volatile&> : boost::true_type
{
};
# 137 "/usr/include/boost/detail/indirect_traits.hpp" 3 4
template <class T>
struct is_reference_to_pointer : boost::false_type
{
};

template <class T>
struct is_reference_to_pointer<T*&> : boost::true_type
{
};

template <class T>
struct is_reference_to_pointer<T* const&> : boost::true_type
{
};

template <class T>
struct is_reference_to_pointer<T* volatile&> : boost::true_type
{
};

template <class T>
struct is_reference_to_pointer<T* const volatile&> : boost::true_type
{
};

template <class T>
struct is_reference_to_class
    : boost::integral_constant<bool,
          is_reference<T>::value &&
          is_class<
              typename remove_cv<
                  typename remove_reference<T>::type
              >::type
          >::value
      >
{
};

template <class T>
struct is_pointer_to_class
    : boost::integral_constant<bool,
          is_pointer<T>::value &&
          is_class<
              typename remove_cv<
                  typename remove_pointer<T>::type
              >::type
          >::value
      >
{
};


}

using namespace indirect_traits;

}}
# 28 "/usr/include/boost/iterator/detail/facade_iterator_category.hpp" 2 3 4






namespace boost {
namespace iterators {

using boost::use_default;

namespace detail {

struct input_output_iterator_tag
  : std::input_iterator_tag
{






    operator std::output_iterator_tag() const
    {
        return std::output_iterator_tag();
    }
};






template <class ValueParam, class Reference>
struct iterator_writability_disabled

  : mpl::or_<
        is_const<Reference>
      , boost::detail::indirect_traits::is_reference_to_const<Reference>
      , is_const<ValueParam>
    >



{};
# 83 "/usr/include/boost/iterator/detail/facade_iterator_category.hpp" 3 4
template <class Traversal, class ValueParam, class Reference>
struct iterator_facade_default_category
  : mpl::eval_if<
        mpl::and_<
            is_reference<Reference>
          , is_convertible<Traversal,forward_traversal_tag>
        >
      , mpl::eval_if<
            is_convertible<Traversal,random_access_traversal_tag>
          , mpl::identity<std::random_access_iterator_tag>
          , mpl::if_<
                is_convertible<Traversal,bidirectional_traversal_tag>
              , std::bidirectional_iterator_tag
              , std::forward_iterator_tag
            >
        >
      , typename mpl::eval_if<
            mpl::and_<
                is_convertible<Traversal, single_pass_traversal_tag>


              , is_convertible<Reference, ValueParam>
            >
          , mpl::identity<std::input_iterator_tag>
          , mpl::identity<Traversal>
        >
    >
{
};


template <class T>
struct is_iterator_category
  : mpl::or_<
        is_convertible<T,std::input_iterator_tag>
      , is_convertible<T,std::output_iterator_tag>
    >
{
};

template <class T>
struct is_iterator_traversal
  : is_convertible<T,incrementable_traversal_tag>
{};







template <class Category, class Traversal>
struct iterator_category_with_traversal
  : Category, Traversal
{



    static_assert(( !is_convertible< typename iterator_category_to_traversal<Category>::type , Traversal >::value), "( !is_convertible< typename iterator_category_to_traversal<Category>::type , Traversal >::value)");





    static_assert(is_iterator_category<Category>::value, "is_iterator_category<Category>::value");
    static_assert(!is_iterator_category<Traversal>::value, "!is_iterator_category<Traversal>::value");
    static_assert(!is_iterator_traversal<Category>::value, "!is_iterator_traversal<Category>::value");

    static_assert(is_iterator_traversal<Traversal>::value, "is_iterator_traversal<Traversal>::value");

};



template <class Traversal, class ValueParam, class Reference>
struct facade_iterator_category_impl
{
    static_assert(!is_iterator_category<Traversal>::value, "!is_iterator_category<Traversal>::value");

    typedef typename iterator_facade_default_category<
        Traversal,ValueParam,Reference
    >::type category;

    typedef typename mpl::if_<
        is_same<
            Traversal
          , typename iterator_category_to_traversal<category>::type
        >
      , category
      , iterator_category_with_traversal<category,Traversal>
    >::type type;
};




template <class CategoryOrTraversal, class ValueParam, class Reference>
struct facade_iterator_category
  : mpl::eval_if<
        is_iterator_category<CategoryOrTraversal>
      , mpl::identity<CategoryOrTraversal>
      , facade_iterator_category_impl<CategoryOrTraversal,ValueParam,Reference>
    >
{
};

}}}

# 1 "/usr/include/boost/iterator/detail/config_undef.hpp" 1 3 4
# 192 "/usr/include/boost/iterator/detail/facade_iterator_category.hpp" 2 3 4
# 16 "/usr/include/boost/iterator/iterator_facade.hpp" 2 3 4
# 1 "/usr/include/boost/iterator/detail/enable_if.hpp" 1 3 4
# 11 "/usr/include/boost/iterator/detail/enable_if.hpp" 3 4
# 1 "/usr/include/boost/iterator/detail/config_def.hpp" 1 3 4
# 12 "/usr/include/boost/iterator/detail/enable_if.hpp" 2 3 4
# 22 "/usr/include/boost/iterator/detail/enable_if.hpp" 3 4
namespace boost
{

  namespace iterators
  {



    template<bool>
    struct enabled
    {
      template<typename T>
      struct base
      {
        typedef T type;
      };
    };






    template<>
    struct enabled<false>
    {
      template<typename T>
      struct base
      {
# 62 "/usr/include/boost/iterator/detail/enable_if.hpp" 3 4
      };
    };


    template <class Cond,
              class Return>
    struct enable_if

      : enabled<(Cond::value)>::template base<Return>



    {
    };

  }

}

# 1 "/usr/include/boost/iterator/detail/config_undef.hpp" 1 3 4
# 82 "/usr/include/boost/iterator/detail/enable_if.hpp" 2 3 4
# 17 "/usr/include/boost/iterator/iterator_facade.hpp" 2 3 4







# 1 "/usr/include/boost/type_traits/add_lvalue_reference.hpp" 1 3 4
# 11 "/usr/include/boost/type_traits/add_lvalue_reference.hpp" 3 4
namespace boost{

template <class T> struct add_lvalue_reference
{
   typedef typename boost::add_reference<T>::type type;
};


template <class T> struct add_lvalue_reference<T&&>
{
   typedef T& type;
};




   template <class T> using add_lvalue_reference_t = typename add_lvalue_reference<T>::type;



}
# 25 "/usr/include/boost/iterator/iterator_facade.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/remove_const.hpp" 1 3 4
# 18 "/usr/include/boost/type_traits/remove_const.hpp" 3 4
namespace boost {


   template <class T> struct remove_const{ typedef T type; };
   template <class T> struct remove_const<T const>{ typedef T type; };


   template <class T, std::size_t N> struct remove_const<T const[N]>{ typedef T type[N]; };

   template <class T> struct remove_const<T const[]>{ typedef T type[]; };





   template <class T> using remove_const_t = typename remove_const<T>::type;



}
# 26 "/usr/include/boost/iterator/iterator_facade.hpp" 2 3 4
# 35 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
# 1 "/usr/include/boost/mpl/always.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/always.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessor/default_params.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/always.hpp" 2 3 4



namespace boost { namespace mpl {

template< typename Value > struct always
{
    template<
        typename T1 = na , typename T2 = na , typename T3 = na , typename T4 = na , typename T5 = na
        >
    struct apply
    {
        typedef Value type;
    };
};



}}
# 36 "/usr/include/boost/iterator/iterator_facade.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/apply.hpp" 1 3 4
# 22 "/usr/include/boost/mpl/apply.hpp" 3 4
# 1 "/usr/include/boost/mpl/apply_fwd.hpp" 1 3 4
# 31 "/usr/include/boost/mpl/apply_fwd.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/apply_fwd.hpp" 1 3 4
# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/apply_fwd.hpp" 3 4
namespace boost { namespace mpl {

template<
      typename F, typename T1 = na, typename T2 = na, typename T3 = na
    , typename T4 = na, typename T5 = na
    >
struct apply;

template<
      typename F
    >
struct apply0;

template<
      typename F, typename T1
    >
struct apply1;

template<
      typename F, typename T1, typename T2
    >
struct apply2;

template<
      typename F, typename T1, typename T2, typename T3
    >
struct apply3;

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    >
struct apply4;

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename T5
    >
struct apply5;

}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 32 "/usr/include/boost/mpl/apply_fwd.hpp" 2 3 4
# 23 "/usr/include/boost/mpl/apply.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/apply_wrap.hpp" 1 3 4
# 23 "/usr/include/boost/mpl/apply_wrap.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/has_apply.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/aux_/has_apply.hpp" 3 4
# 1 "/usr/include/boost/mpl/has_xxx.hpp" 1 3 4
# 21 "/usr/include/boost/mpl/has_xxx.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/type_wrapper.hpp" 1 3 4
# 20 "/usr/include/boost/mpl/aux_/type_wrapper.hpp" 3 4
namespace boost { namespace mpl { namespace aux {

template< typename T > struct type_wrapper
{
    typedef T type;
};






template< typename T > struct wrapped_type;

template< typename T > struct wrapped_type< type_wrapper<T> >
{
    typedef T type;
};







}}}
# 22 "/usr/include/boost/mpl/has_xxx.hpp" 2 3 4


# 1 "/usr/include/boost/mpl/aux_/config/has_xxx.hpp" 1 3 4
# 25 "/usr/include/boost/mpl/has_xxx.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/config/msvc_typename.hpp" 1 3 4
# 26 "/usr/include/boost/mpl/has_xxx.hpp" 2 3 4




# 1 "/usr/include/boost/preprocessor/array/elem.hpp" 1 3 4
# 15 "/usr/include/boost/preprocessor/array/elem.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/array/data.hpp" 1 3 4
# 16 "/usr/include/boost/preprocessor/array/elem.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/array/size.hpp" 1 3 4
# 17 "/usr/include/boost/preprocessor/array/elem.hpp" 2 3 4
# 31 "/usr/include/boost/mpl/has_xxx.hpp" 2 3 4



# 1 "/usr/include/boost/preprocessor/repetition/enum_trailing_params.hpp" 1 3 4
# 35 "/usr/include/boost/mpl/has_xxx.hpp" 2 3 4
# 18 "/usr/include/boost/mpl/aux_/has_apply.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/config/has_apply.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/aux_/has_apply.hpp" 2 3 4

namespace boost { namespace mpl { namespace aux {

template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_apply { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<typename U::apply>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };







}}}
# 24 "/usr/include/boost/mpl/apply_wrap.hpp" 2 3 4

# 1 "/usr/include/boost/mpl/aux_/msvc_never_true.hpp" 1 3 4
# 26 "/usr/include/boost/mpl/apply_wrap.hpp" 2 3 4








# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/apply_wrap.hpp" 1 3 4
# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/apply_wrap.hpp" 3 4
namespace boost { namespace mpl {

template<
      typename F

    , typename has_apply_ = typename aux::has_apply<F>::type

    >
struct apply_wrap0

    : F::template apply< >
{
};

template< typename F >
struct apply_wrap0< F,true_ >
    : F::apply
{
};

template<
      typename F, typename T1

    >
struct apply_wrap1

    : F::template apply<T1>
{
};

template<
      typename F, typename T1, typename T2

    >
struct apply_wrap2

    : F::template apply< T1,T2 >
{
};

template<
      typename F, typename T1, typename T2, typename T3

    >
struct apply_wrap3

    : F::template apply< T1,T2,T3 >
{
};

template<
      typename F, typename T1, typename T2, typename T3, typename T4

    >
struct apply_wrap4

    : F::template apply< T1,T2,T3,T4 >
{
};

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename T5

    >
struct apply_wrap5

    : F::template apply< T1,T2,T3,T4,T5 >
{
};

}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 35 "/usr/include/boost/mpl/apply_wrap.hpp" 2 3 4
# 24 "/usr/include/boost/mpl/apply.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/placeholders.hpp" 1 3 4
# 25 "/usr/include/boost/mpl/apply.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/lambda.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/lambda.hpp" 3 4
# 1 "/usr/include/boost/mpl/bind.hpp" 1 3 4
# 23 "/usr/include/boost/mpl/bind.hpp" 3 4
# 1 "/usr/include/boost/mpl/bind_fwd.hpp" 1 3 4
# 25 "/usr/include/boost/mpl/bind_fwd.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/config/bind.hpp" 1 3 4
# 26 "/usr/include/boost/mpl/bind_fwd.hpp" 2 3 4






# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/bind_fwd.hpp" 1 3 4
# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/bind_fwd.hpp" 3 4
namespace boost { namespace mpl {

template<
      typename F, typename T1 = na, typename T2 = na, typename T3 = na
    , typename T4 = na, typename T5 = na
    >
struct bind;

template<
      typename F
    >
struct bind0;

template<
      typename F, typename T1
    >
struct bind1;

template<
      typename F, typename T1, typename T2
    >
struct bind2;

template<
      typename F, typename T1, typename T2, typename T3
    >
struct bind3;

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    >
struct bind4;

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename T5
    >
struct bind5;

}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 33 "/usr/include/boost/mpl/bind_fwd.hpp" 2 3 4
# 24 "/usr/include/boost/mpl/bind.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/placeholders.hpp" 1 3 4
# 25 "/usr/include/boost/mpl/bind.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/next.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/next.hpp" 3 4
# 1 "/usr/include/boost/mpl/next_prior.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/next_prior.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/common_name_wknd.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/next_prior.hpp" 2 3 4



namespace boost { namespace mpl {




template<
      typename T = na
    >
struct next
{
    typedef typename T::next type;

};

template<
      typename T = na
    >
struct prior
{
    typedef typename T::prior type;

};

template<> struct next< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : next< T1 > { }; }; template< typename Tag > struct lambda< next< na > , Tag , int_<-1> > { typedef false_ is_le; typedef next< na > result_; typedef next< na > type; }; namespace aux { template< typename T1 > struct template_arity< next< T1 > > : int_<1> { }; template<> struct template_arity< next< na > > : int_<-1> { }; }
template<> struct prior< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : prior< T1 > { }; }; template< typename Tag > struct lambda< prior< na > , Tag , int_<-1> > { typedef false_ is_le; typedef prior< na > result_; typedef prior< na > type; }; namespace aux { template< typename T1 > struct template_arity< prior< T1 > > : int_<1> { }; template<> struct template_arity< prior< na > > : int_<-1> { }; }

}}
# 18 "/usr/include/boost/mpl/next.hpp" 2 3 4
# 26 "/usr/include/boost/mpl/bind.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/protect.hpp" 1 3 4
# 23 "/usr/include/boost/mpl/protect.hpp" 3 4
namespace boost { namespace mpl {

template<
      typename T = na
    , int not_le_ = 0
    >
struct protect : T
{



    typedef protect type;

};
# 48 "/usr/include/boost/mpl/protect.hpp" 3 4
template<> struct protect< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : protect< T1 > { }; };

namespace aux { template< typename T1 > struct template_arity< protect< T1 > > : int_<1> { }; template<> struct template_arity< protect< na > > : int_<-1> { }; }


}}
# 27 "/usr/include/boost/mpl/bind.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/apply_wrap.hpp" 1 3 4
# 28 "/usr/include/boost/mpl/bind.hpp" 2 3 4
# 50 "/usr/include/boost/mpl/bind.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/bind.hpp" 1 3 4
# 13 "/usr/include/boost/mpl/aux_/preprocessed/gcc/bind.hpp" 3 4
namespace boost { namespace mpl {

namespace aux {

template<
      typename T, typename U1, typename U2, typename U3, typename U4
    , typename U5
    >
struct resolve_bind_arg
{
    typedef T type;
};

template<
      typename T
    , typename Arg
    >
struct replace_unnamed_arg
{
    typedef Arg next;
    typedef T type;
};

template<
      typename Arg
    >
struct replace_unnamed_arg< arg< -1 >, Arg >
{
    typedef typename Arg::next next;
    typedef Arg type;
};

template<
      int N, typename U1, typename U2, typename U3, typename U4, typename U5
    >
struct resolve_bind_arg< arg<N>, U1, U2, U3, U4, U5 >
{
    typedef typename apply_wrap5<mpl::arg<N>, U1, U2, U3, U4, U5>::type type;
};

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename U1, typename U2, typename U3, typename U4
    , typename U5
    >
struct resolve_bind_arg< bind< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5 >
{
    typedef bind< F,T1,T2,T3,T4,T5 > f_;
    typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
};

}

template<
      typename F
    >
struct bind0
{
    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
     private:
        typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
        typedef typename r0::type a0;
        typedef typename r0::next n1;
        typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;

     public:
        typedef typename apply_wrap0<
              f_
            >::type type;

    };
};

namespace aux {

template<
      typename F, typename U1, typename U2, typename U3, typename U4
    , typename U5
    >
struct resolve_bind_arg<
      bind0<F>, U1, U2, U3, U4, U5
    >
{
    typedef bind0<F> f_;
    typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
};

}


namespace aux { template< typename T1 > struct template_arity< bind0< T1> > : int_<1> { }; }

template<
      typename F
    >
struct bind< F,na,na,na,na,na >
    : bind0<F>
{
};

template<
      typename F, typename T1
    >
struct bind1
{
    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
     private:
        typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
        typedef typename r0::type a0;
        typedef typename r0::next n1;
        typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;

        typedef aux::replace_unnamed_arg< T1,n1 > r1;
        typedef typename r1::type a1;
        typedef typename r1::next n2;
        typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;

     public:
        typedef typename apply_wrap1<
              f_
            , typename t1::type
            >::type type;

    };
};

namespace aux {

template<
      typename F, typename T1, typename U1, typename U2, typename U3
    , typename U4, typename U5
    >
struct resolve_bind_arg<
      bind1< F,T1 >, U1, U2, U3, U4, U5
    >
{
    typedef bind1< F,T1 > f_;
    typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
};

}


namespace aux { template< typename T1 , typename T2 > struct template_arity< bind1< T1 , T2> > : int_<2> { }; }

template<
      typename F, typename T1
    >
struct bind< F,T1,na,na,na,na >
    : bind1< F,T1 >
{
};

template<
      typename F, typename T1, typename T2
    >
struct bind2
{
    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
     private:
        typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
        typedef typename r0::type a0;
        typedef typename r0::next n1;
        typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;

        typedef aux::replace_unnamed_arg< T1,n1 > r1;
        typedef typename r1::type a1;
        typedef typename r1::next n2;
        typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;

        typedef aux::replace_unnamed_arg< T2,n2 > r2;
        typedef typename r2::type a2;
        typedef typename r2::next n3;
        typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2;

     public:
        typedef typename apply_wrap2<
              f_
            , typename t1::type, typename t2::type
            >::type type;

    };
};

namespace aux {

template<
      typename F, typename T1, typename T2, typename U1, typename U2
    , typename U3, typename U4, typename U5
    >
struct resolve_bind_arg<
      bind2< F,T1,T2 >, U1, U2, U3, U4, U5
    >
{
    typedef bind2< F,T1,T2 > f_;
    typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
};

}


namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< bind2< T1 , T2 , T3> > : int_<3> { }; }

template<
      typename F, typename T1, typename T2
    >
struct bind< F,T1,T2,na,na,na >
    : bind2< F,T1,T2 >
{
};

template<
      typename F, typename T1, typename T2, typename T3
    >
struct bind3
{
    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
     private:
        typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
        typedef typename r0::type a0;
        typedef typename r0::next n1;
        typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;

        typedef aux::replace_unnamed_arg< T1,n1 > r1;
        typedef typename r1::type a1;
        typedef typename r1::next n2;
        typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;

        typedef aux::replace_unnamed_arg< T2,n2 > r2;
        typedef typename r2::type a2;
        typedef typename r2::next n3;
        typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2;

        typedef aux::replace_unnamed_arg< T3,n3 > r3;
        typedef typename r3::type a3;
        typedef typename r3::next n4;
        typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3;

     public:
        typedef typename apply_wrap3<
              f_
            , typename t1::type, typename t2::type, typename t3::type
            >::type type;

    };
};

namespace aux {

template<
      typename F, typename T1, typename T2, typename T3, typename U1
    , typename U2, typename U3, typename U4, typename U5
    >
struct resolve_bind_arg<
      bind3< F,T1,T2,T3 >, U1, U2, U3, U4, U5
    >
{
    typedef bind3< F,T1,T2,T3 > f_;
    typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
};

}


namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 > struct template_arity< bind3< T1 , T2 , T3 , T4> > : int_<4> { }; }

template<
      typename F, typename T1, typename T2, typename T3
    >
struct bind< F,T1,T2,T3,na,na >
    : bind3< F,T1,T2,T3 >
{
};

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    >
struct bind4
{
    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
     private:
        typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
        typedef typename r0::type a0;
        typedef typename r0::next n1;
        typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;

        typedef aux::replace_unnamed_arg< T1,n1 > r1;
        typedef typename r1::type a1;
        typedef typename r1::next n2;
        typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;

        typedef aux::replace_unnamed_arg< T2,n2 > r2;
        typedef typename r2::type a2;
        typedef typename r2::next n3;
        typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2;

        typedef aux::replace_unnamed_arg< T3,n3 > r3;
        typedef typename r3::type a3;
        typedef typename r3::next n4;
        typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3;

        typedef aux::replace_unnamed_arg< T4,n4 > r4;
        typedef typename r4::type a4;
        typedef typename r4::next n5;
        typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4;

     public:
        typedef typename apply_wrap4<
              f_
            , typename t1::type, typename t2::type, typename t3::type
            , typename t4::type
            >::type type;

    };
};

namespace aux {

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename U1, typename U2, typename U3, typename U4, typename U5
    >
struct resolve_bind_arg<
      bind4< F,T1,T2,T3,T4 >, U1, U2, U3, U4, U5
    >
{
    typedef bind4< F,T1,T2,T3,T4 > f_;
    typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
};

}


namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct template_arity< bind4< T1 , T2 , T3 , T4 , T5> > : int_<5> { }; }

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    >
struct bind< F,T1,T2,T3,T4,na >
    : bind4< F,T1,T2,T3,T4 >
{
};

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename T5
    >
struct bind5
{
    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
     private:
        typedef aux::replace_unnamed_arg< F, mpl::arg<1> > r0;
        typedef typename r0::type a0;
        typedef typename r0::next n1;
        typedef typename aux::resolve_bind_arg< a0,U1,U2,U3,U4,U5 >::type f_;

        typedef aux::replace_unnamed_arg< T1,n1 > r1;
        typedef typename r1::type a1;
        typedef typename r1::next n2;
        typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;

        typedef aux::replace_unnamed_arg< T2,n2 > r2;
        typedef typename r2::type a2;
        typedef typename r2::next n3;
        typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2;

        typedef aux::replace_unnamed_arg< T3,n3 > r3;
        typedef typename r3::type a3;
        typedef typename r3::next n4;
        typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3;

        typedef aux::replace_unnamed_arg< T4,n4 > r4;
        typedef typename r4::type a4;
        typedef typename r4::next n5;
        typedef aux::resolve_bind_arg< a4,U1,U2,U3,U4,U5 > t4;

        typedef aux::replace_unnamed_arg< T5,n5 > r5;
        typedef typename r5::type a5;
        typedef typename r5::next n6;
        typedef aux::resolve_bind_arg< a5,U1,U2,U3,U4,U5 > t5;

     public:
        typedef typename apply_wrap5<
              f_
            , typename t1::type, typename t2::type, typename t3::type
            , typename t4::type, typename t5::type
            >::type type;

    };
};

namespace aux {

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename T5, typename U1, typename U2, typename U3, typename U4
    , typename U5
    >
struct resolve_bind_arg<
      bind5< F,T1,T2,T3,T4,T5 >, U1, U2, U3, U4, U5
    >
{
    typedef bind5< F,T1,T2,T3,T4,T5 > f_;
    typedef typename apply_wrap5< f_,U1,U2,U3,U4,U5 >::type type;
};

}


namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 > struct template_arity< bind5< T1 , T2 , T3 , T4 , T5 , T6> > : int_<6> { }; }



template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename T5
    >
struct bind
    : bind5< F,T1,T2,T3,T4,T5 >
{
};


template< template< typename T1, typename T2, typename T3 > class F, typename Tag >
struct quote3;

template< typename T1, typename T2, typename T3 > struct if_;

template<
      typename Tag, typename T1, typename T2, typename T3
    >
struct bind3<
      quote3< if_,Tag >
    , T1, T2, T3
    >
{
    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
     private:
        typedef mpl::arg<1> n1;
        typedef aux::replace_unnamed_arg< T1,n1 > r1;
        typedef typename r1::type a1;
        typedef typename r1::next n2;
        typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;

        typedef aux::replace_unnamed_arg< T2,n2 > r2;
        typedef typename r2::type a2;
        typedef typename r2::next n3;
        typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2;

        typedef aux::replace_unnamed_arg< T3,n3 > r3;
        typedef typename r3::type a3;
        typedef typename r3::next n4;
        typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3;

        typedef typename if_<
              typename t1::type
            , t2, t3
            >::type f_;

     public:
        typedef typename f_::type type;
    };
};

template<
      template< typename T1, typename T2, typename T3 > class F, typename Tag
    >
struct quote3;

template< typename T1, typename T2, typename T3 > struct eval_if;

template<
      typename Tag, typename T1, typename T2, typename T3
    >
struct bind3<
      quote3< eval_if,Tag >
    , T1, T2, T3
    >
{
    template<
          typename U1 = na, typename U2 = na, typename U3 = na
        , typename U4 = na, typename U5 = na
        >
    struct apply
    {
     private:
        typedef mpl::arg<1> n1;
        typedef aux::replace_unnamed_arg< T1,n1 > r1;
        typedef typename r1::type a1;
        typedef typename r1::next n2;
        typedef aux::resolve_bind_arg< a1,U1,U2,U3,U4,U5 > t1;

        typedef aux::replace_unnamed_arg< T2,n2 > r2;
        typedef typename r2::type a2;
        typedef typename r2::next n3;
        typedef aux::resolve_bind_arg< a2,U1,U2,U3,U4,U5 > t2;

        typedef aux::replace_unnamed_arg< T3,n3 > r3;
        typedef typename r3::type a3;
        typedef typename r3::next n4;
        typedef aux::resolve_bind_arg< a3,U1,U2,U3,U4,U5 > t3;

        typedef typename eval_if<
              typename t1::type
            , t2, t3
            >::type f_;

     public:
        typedef typename f_::type type;
    };
};

}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 51 "/usr/include/boost/mpl/bind.hpp" 2 3 4
# 19 "/usr/include/boost/mpl/lambda.hpp" 2 3 4



# 1 "/usr/include/boost/mpl/aux_/full_lambda.hpp" 1 3 4
# 23 "/usr/include/boost/mpl/aux_/full_lambda.hpp" 3 4
# 1 "/usr/include/boost/mpl/bind_fwd.hpp" 1 3 4
# 24 "/usr/include/boost/mpl/aux_/full_lambda.hpp" 2 3 4

# 1 "/usr/include/boost/mpl/quote.hpp" 1 3 4
# 22 "/usr/include/boost/mpl/quote.hpp" 3 4
# 1 "/usr/include/boost/mpl/void.hpp" 1 3 4
# 23 "/usr/include/boost/mpl/void.hpp" 3 4
namespace mpl_ {





struct void_ { typedef void_ type; };

}

namespace boost { namespace mpl {

template< typename T >
struct is_void_
    : false_
{



};

template<>
struct is_void_<void_>
    : true_
{



};

template< typename T >
struct is_not_void_
    : true_
{



};

template<>
struct is_not_void_<void_>
    : false_
{



};

template<> struct is_void_< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : is_void_< T1 > { }; }; template< typename Tag > struct lambda< is_void_< na > , Tag , int_<-1> > { typedef false_ is_le; typedef is_void_< na > result_; typedef is_void_< na > type; }; namespace aux { template< typename T1 > struct template_arity< is_void_< T1 > > : int_<1> { }; template<> struct template_arity< is_void_< na > > : int_<-1> { }; }
template<> struct is_not_void_< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : is_not_void_< T1 > { }; }; template< typename Tag > struct lambda< is_not_void_< na > , Tag , int_<-1> > { typedef false_ is_le; typedef is_not_void_< na > result_; typedef is_not_void_< na > type; }; namespace aux { template< typename T1 > struct template_arity< is_not_void_< T1 > > : int_<1> { }; template<> struct template_arity< is_not_void_< na > > : int_<-1> { }; }

}}
# 23 "/usr/include/boost/mpl/quote.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/has_type.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/aux_/has_type.hpp" 3 4
namespace boost { namespace mpl { namespace aux {
template< typename T, typename fallback_ = boost::mpl::bool_<true> > struct has_type { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<typename U::type>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };
}}}
# 24 "/usr/include/boost/mpl/quote.hpp" 2 3 4


# 1 "/usr/include/boost/mpl/aux_/config/bcc.hpp" 1 3 4
# 27 "/usr/include/boost/mpl/quote.hpp" 2 3 4
# 45 "/usr/include/boost/mpl/quote.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/quote.hpp" 1 3 4
# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/quote.hpp" 3 4
namespace boost { namespace mpl {

template< typename T, bool has_type_ >
struct quote_impl
{
    typedef typename T::type type;
};

template< typename T >
struct quote_impl< T,false >
{
    typedef T type;
};

template<
      template< typename P1 > class F
    , typename Tag = void_
    >
struct quote1
{
    template< typename U1 > struct apply

        : quote_impl<
              F<U1>
            , aux::has_type< F<U1> >::value
            >

    {
    };
};

template<
      template< typename P1, typename P2 > class F
    , typename Tag = void_
    >
struct quote2
{
    template< typename U1, typename U2 > struct apply

        : quote_impl<
              F< U1,U2 >
            , aux::has_type< F< U1,U2 > >::value
            >

    {
    };
};

template<
      template< typename P1, typename P2, typename P3 > class F
    , typename Tag = void_
    >
struct quote3
{
    template< typename U1, typename U2, typename U3 > struct apply

        : quote_impl<
              F< U1,U2,U3 >
            , aux::has_type< F< U1,U2,U3 > >::value
            >

    {
    };
};

template<
      template< typename P1, typename P2, typename P3, typename P4 > class F
    , typename Tag = void_
    >
struct quote4
{
    template<
          typename U1, typename U2, typename U3, typename U4
        >
    struct apply

        : quote_impl<
              F< U1,U2,U3,U4 >
            , aux::has_type< F< U1,U2,U3,U4 > >::value
            >

    {
    };
};

template<
      template<
          typename P1, typename P2, typename P3, typename P4
        , typename P5
        >
      class F
    , typename Tag = void_
    >
struct quote5
{
    template<
          typename U1, typename U2, typename U3, typename U4
        , typename U5
        >
    struct apply

        : quote_impl<
              F< U1,U2,U3,U4,U5 >
            , aux::has_type< F< U1,U2,U3,U4,U5 > >::value
            >

    {
    };
};

}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 46 "/usr/include/boost/mpl/quote.hpp" 2 3 4
# 26 "/usr/include/boost/mpl/aux_/full_lambda.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/arg.hpp" 1 3 4
# 27 "/usr/include/boost/mpl/aux_/full_lambda.hpp" 2 3 4


# 1 "/usr/include/boost/mpl/aux_/template_arity.hpp" 1 3 4
# 43 "/usr/include/boost/mpl/aux_/template_arity.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/template_arity.hpp" 1 3 4
# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/template_arity.hpp" 3 4
namespace boost { namespace mpl { namespace aux {
template< int N > struct arity_tag
{
    typedef char (&type)[(unsigned)N + 1];
};

template<
      int C1, int C2, int C3, int C4, int C5, int C6
    >
struct max_arity
{
    static const int value = ( C6 > 0 ? C6 : ( C5 > 0 ? C5 : ( C4 > 0 ? C4 : ( C3 > 0 ? C3 : ( C2 > 0 ? C2 : ( C1 > 0 ? C1 : -1 ) ) ) ) ) );


};

arity_tag<0>::type arity_helper(...);

template<
      template< typename P1 > class F
    , typename T1
    >
typename arity_tag<1>::type
arity_helper(type_wrapper< F<T1> >, arity_tag<1>);

template<
      template< typename P1, typename P2 > class F
    , typename T1, typename T2
    >
typename arity_tag<2>::type
arity_helper(type_wrapper< F< T1,T2 > >, arity_tag<2>);

template<
      template< typename P1, typename P2, typename P3 > class F
    , typename T1, typename T2, typename T3
    >
typename arity_tag<3>::type
arity_helper(type_wrapper< F< T1,T2,T3 > >, arity_tag<3>);

template<
      template< typename P1, typename P2, typename P3, typename P4 > class F
    , typename T1, typename T2, typename T3, typename T4
    >
typename arity_tag<4>::type
arity_helper(type_wrapper< F< T1,T2,T3,T4 > >, arity_tag<4>);

template<
      template<
          typename P1, typename P2, typename P3, typename P4
        , typename P5
        >
      class F
    , typename T1, typename T2, typename T3, typename T4, typename T5
    >
typename arity_tag<5>::type
arity_helper(type_wrapper< F< T1,T2,T3,T4,T5 > >, arity_tag<5>);

template<
      template<
          typename P1, typename P2, typename P3, typename P4
        , typename P5, typename P6
        >
      class F
    , typename T1, typename T2, typename T3, typename T4, typename T5
    , typename T6
    >
typename arity_tag<6>::type
arity_helper(type_wrapper< F< T1,T2,T3,T4,T5,T6 > >, arity_tag<6>);
template< typename F, int N >
struct template_arity_impl
{
    static const int value = sizeof(::boost::mpl::aux::arity_helper(type_wrapper<F>(), arity_tag<N>())) - 1;


};

template< typename F >
struct template_arity
{
    static const int value = ( max_arity< template_arity_impl< F,1 >::value, template_arity_impl< F,2 >::value, template_arity_impl< F,3 >::value, template_arity_impl< F,4 >::value, template_arity_impl< F,5 >::value, template_arity_impl< F,6 >::value >::value );


    typedef mpl::int_<value> type;
};

}}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 44 "/usr/include/boost/mpl/aux_/template_arity.hpp" 2 3 4
# 30 "/usr/include/boost/mpl/aux_/full_lambda.hpp" 2 3 4
# 44 "/usr/include/boost/mpl/aux_/full_lambda.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/full_lambda.hpp" 1 3 4
# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/full_lambda.hpp" 3 4
namespace boost { namespace mpl {

namespace aux {

template<
      bool C1 = false, bool C2 = false, bool C3 = false, bool C4 = false
    , bool C5 = false
    >
struct lambda_or
    : true_
{
};

template<>
struct lambda_or< false,false,false,false,false >
    : false_
{
};

}

template<
      typename T
    , typename Tag
    , typename Arity
    >
struct lambda
{
    typedef false_ is_le;
    typedef T result_;
    typedef T type;
};

template<
      typename T
    >
struct is_lambda_expression
    : lambda<T>::is_le
{
};

template< int N, typename Tag >
struct lambda< arg<N>,Tag, int_< -1 > >
{
    typedef true_ is_le;
    typedef mpl::arg<N> result_;
    typedef mpl::protect<result_> type;
};

template<
      typename F
    , typename Tag
    >
struct lambda<
          bind0<F>
        , Tag
        , int_<1>
        >
{
    typedef false_ is_le;
    typedef bind0<
          F
        > result_;

    typedef result_ type;
};

namespace aux {

template<
      typename IsLE, typename Tag
    , template< typename P1 > class F
    , typename L1
    >
struct le_result1
{
    typedef F<
          typename L1::type
        > result_;

    typedef result_ type;
};

template<
      typename Tag
    , template< typename P1 > class F
    , typename L1
    >
struct le_result1< true_,Tag,F,L1 >
{
    typedef bind1<
          quote1< F,Tag >
        , typename L1::result_
        > result_;

    typedef mpl::protect<result_> type;
};

}

template<
      template< typename P1 > class F
    , typename T1
    , typename Tag
    >
struct lambda<
          F<T1>
        , Tag
        , int_<1>
        >
{
    typedef lambda< T1,Tag > l1;
    typedef typename l1::is_le is_le1;
    typedef typename aux::lambda_or<
          is_le1::value
        >::type is_le;

    typedef aux::le_result1<
          is_le, Tag, F, l1
        > le_result_;

    typedef typename le_result_::result_ result_;
    typedef typename le_result_::type type;
};

template<
      typename F, typename T1
    , typename Tag
    >
struct lambda<
          bind1< F,T1 >
        , Tag
        , int_<2>
        >
{
    typedef false_ is_le;
    typedef bind1<
          F
        , T1
        > result_;

    typedef result_ type;
};

namespace aux {

template<
      typename IsLE, typename Tag
    , template< typename P1, typename P2 > class F
    , typename L1, typename L2
    >
struct le_result2
{
    typedef F<
          typename L1::type, typename L2::type
        > result_;

    typedef result_ type;
};

template<
      typename Tag
    , template< typename P1, typename P2 > class F
    , typename L1, typename L2
    >
struct le_result2< true_,Tag,F,L1,L2 >
{
    typedef bind2<
          quote2< F,Tag >
        , typename L1::result_, typename L2::result_
        > result_;

    typedef mpl::protect<result_> type;
};

}

template<
      template< typename P1, typename P2 > class F
    , typename T1, typename T2
    , typename Tag
    >
struct lambda<
          F< T1,T2 >
        , Tag
        , int_<2>
        >
{
    typedef lambda< T1,Tag > l1;
    typedef lambda< T2,Tag > l2;

    typedef typename l1::is_le is_le1;
    typedef typename l2::is_le is_le2;


    typedef typename aux::lambda_or<
          is_le1::value, is_le2::value
        >::type is_le;

    typedef aux::le_result2<
          is_le, Tag, F, l1, l2
        > le_result_;

    typedef typename le_result_::result_ result_;
    typedef typename le_result_::type type;
};

template<
      typename F, typename T1, typename T2
    , typename Tag
    >
struct lambda<
          bind2< F,T1,T2 >
        , Tag
        , int_<3>
        >
{
    typedef false_ is_le;
    typedef bind2<
          F
        , T1, T2
        > result_;

    typedef result_ type;
};

namespace aux {

template<
      typename IsLE, typename Tag
    , template< typename P1, typename P2, typename P3 > class F
    , typename L1, typename L2, typename L3
    >
struct le_result3
{
    typedef F<
          typename L1::type, typename L2::type, typename L3::type
        > result_;

    typedef result_ type;
};

template<
      typename Tag
    , template< typename P1, typename P2, typename P3 > class F
    , typename L1, typename L2, typename L3
    >
struct le_result3< true_,Tag,F,L1,L2,L3 >
{
    typedef bind3<
          quote3< F,Tag >
        , typename L1::result_, typename L2::result_, typename L3::result_
        > result_;

    typedef mpl::protect<result_> type;
};

}

template<
      template< typename P1, typename P2, typename P3 > class F
    , typename T1, typename T2, typename T3
    , typename Tag
    >
struct lambda<
          F< T1,T2,T3 >
        , Tag
        , int_<3>
        >
{
    typedef lambda< T1,Tag > l1;
    typedef lambda< T2,Tag > l2;
    typedef lambda< T3,Tag > l3;

    typedef typename l1::is_le is_le1;
    typedef typename l2::is_le is_le2;
    typedef typename l3::is_le is_le3;


    typedef typename aux::lambda_or<
          is_le1::value, is_le2::value, is_le3::value
        >::type is_le;

    typedef aux::le_result3<
          is_le, Tag, F, l1, l2, l3
        > le_result_;

    typedef typename le_result_::result_ result_;
    typedef typename le_result_::type type;
};

template<
      typename F, typename T1, typename T2, typename T3
    , typename Tag
    >
struct lambda<
          bind3< F,T1,T2,T3 >
        , Tag
        , int_<4>
        >
{
    typedef false_ is_le;
    typedef bind3<
          F
        , T1, T2, T3
        > result_;

    typedef result_ type;
};

namespace aux {

template<
      typename IsLE, typename Tag
    , template< typename P1, typename P2, typename P3, typename P4 > class F
    , typename L1, typename L2, typename L3, typename L4
    >
struct le_result4
{
    typedef F<
          typename L1::type, typename L2::type, typename L3::type
        , typename L4::type
        > result_;

    typedef result_ type;
};

template<
      typename Tag
    , template< typename P1, typename P2, typename P3, typename P4 > class F
    , typename L1, typename L2, typename L3, typename L4
    >
struct le_result4< true_,Tag,F,L1,L2,L3,L4 >
{
    typedef bind4<
          quote4< F,Tag >
        , typename L1::result_, typename L2::result_, typename L3::result_
        , typename L4::result_
        > result_;

    typedef mpl::protect<result_> type;
};

}

template<
      template< typename P1, typename P2, typename P3, typename P4 > class F
    , typename T1, typename T2, typename T3, typename T4
    , typename Tag
    >
struct lambda<
          F< T1,T2,T3,T4 >
        , Tag
        , int_<4>
        >
{
    typedef lambda< T1,Tag > l1;
    typedef lambda< T2,Tag > l2;
    typedef lambda< T3,Tag > l3;
    typedef lambda< T4,Tag > l4;

    typedef typename l1::is_le is_le1;
    typedef typename l2::is_le is_le2;
    typedef typename l3::is_le is_le3;
    typedef typename l4::is_le is_le4;


    typedef typename aux::lambda_or<
          is_le1::value, is_le2::value, is_le3::value, is_le4::value
        >::type is_le;

    typedef aux::le_result4<
          is_le, Tag, F, l1, l2, l3, l4
        > le_result_;

    typedef typename le_result_::result_ result_;
    typedef typename le_result_::type type;
};

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename Tag
    >
struct lambda<
          bind4< F,T1,T2,T3,T4 >
        , Tag
        , int_<5>
        >
{
    typedef false_ is_le;
    typedef bind4<
          F
        , T1, T2, T3, T4
        > result_;

    typedef result_ type;
};

namespace aux {

template<
      typename IsLE, typename Tag
    , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F
    , typename L1, typename L2, typename L3, typename L4, typename L5
    >
struct le_result5
{
    typedef F<
          typename L1::type, typename L2::type, typename L3::type
        , typename L4::type, typename L5::type
        > result_;

    typedef result_ type;
};

template<
      typename Tag
    , template< typename P1, typename P2, typename P3, typename P4, typename P5 > class F
    , typename L1, typename L2, typename L3, typename L4, typename L5
    >
struct le_result5< true_,Tag,F,L1,L2,L3,L4,L5 >
{
    typedef bind5<
          quote5< F,Tag >
        , typename L1::result_, typename L2::result_, typename L3::result_
        , typename L4::result_, typename L5::result_
        > result_;

    typedef mpl::protect<result_> type;
};

}

template<
      template<
          typename P1, typename P2, typename P3, typename P4
        , typename P5
        >
      class F
    , typename T1, typename T2, typename T3, typename T4, typename T5
    , typename Tag
    >
struct lambda<
          F< T1,T2,T3,T4,T5 >
        , Tag
        , int_<5>
        >
{
    typedef lambda< T1,Tag > l1;
    typedef lambda< T2,Tag > l2;
    typedef lambda< T3,Tag > l3;
    typedef lambda< T4,Tag > l4;
    typedef lambda< T5,Tag > l5;

    typedef typename l1::is_le is_le1;
    typedef typename l2::is_le is_le2;
    typedef typename l3::is_le is_le3;
    typedef typename l4::is_le is_le4;
    typedef typename l5::is_le is_le5;


    typedef typename aux::lambda_or<
          is_le1::value, is_le2::value, is_le3::value, is_le4::value
        , is_le5::value
        >::type is_le;

    typedef aux::le_result5<
          is_le, Tag, F, l1, l2, l3, l4, l5
        > le_result_;

    typedef typename le_result_::result_ result_;
    typedef typename le_result_::type type;
};

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename T5
    , typename Tag
    >
struct lambda<
          bind5< F,T1,T2,T3,T4,T5 >
        , Tag
        , int_<6>
        >
{
    typedef false_ is_le;
    typedef bind5<
          F
        , T1, T2, T3, T4, T5
        > result_;

    typedef result_ type;
};


template< typename T, typename Tag >
struct lambda< mpl::protect<T>,Tag, int_<1> >
{
    typedef false_ is_le;
    typedef mpl::protect<T> result_;
    typedef result_ type;
};



template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename T5
    , typename Tag
    >
struct lambda<
          bind< F,T1,T2,T3,T4,T5 >
        , Tag
        , int_<6>
        >
{
    typedef false_ is_le;
    typedef bind< F,T1,T2,T3,T4,T5 > result_;
    typedef result_ type;
};

template<
      typename F
    , typename Tag1
    , typename Tag2
    , typename Arity
    >
struct lambda<
          lambda< F,Tag1,Arity >
        , Tag2
        , int_<3>
        >
{
    typedef lambda< F,Tag2 > l1;
    typedef lambda< Tag1,Tag2 > l2;
    typedef typename l1::is_le is_le;
    typedef bind1< quote1<aux::template_arity>, typename l1::result_ > arity_;
    typedef lambda< typename if_< is_le,arity_,Arity >::type, Tag2 > l3;
    typedef aux::le_result3<is_le, Tag2, mpl::lambda, l1, l2, l3> le_result_;
    typedef typename le_result_::result_ result_;
    typedef typename le_result_::type type;
};

template<> struct lambda< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : lambda< T1 , T2 > { }; }; template< typename Tag > struct lambda< lambda< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef lambda< na , na > result_; typedef lambda< na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< lambda< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< lambda< na , na > > : int_<-1> { }; }

}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 45 "/usr/include/boost/mpl/aux_/full_lambda.hpp" 2 3 4
# 23 "/usr/include/boost/mpl/lambda.hpp" 2 3 4
# 26 "/usr/include/boost/mpl/apply.hpp" 2 3 4
# 36 "/usr/include/boost/mpl/apply.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/apply.hpp" 1 3 4
# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/apply.hpp" 3 4
namespace boost { namespace mpl {

template<
      typename F
    >
struct apply0

    : apply_wrap0<
          typename lambda<F>::type

        >
{





};

template<
      typename F
    >
struct apply< F,na,na,na,na,na >
    : apply0<F>
{
};

template<
      typename F, typename T1
    >
struct apply1

    : apply_wrap1<
          typename lambda<F>::type
        , T1
        >
{





};

template<
      typename F, typename T1
    >
struct apply< F,T1,na,na,na,na >
    : apply1< F,T1 >
{
};

template<
      typename F, typename T1, typename T2
    >
struct apply2

    : apply_wrap2<
          typename lambda<F>::type
        , T1, T2
        >
{





};

template<
      typename F, typename T1, typename T2
    >
struct apply< F,T1,T2,na,na,na >
    : apply2< F,T1,T2 >
{
};

template<
      typename F, typename T1, typename T2, typename T3
    >
struct apply3

    : apply_wrap3<
          typename lambda<F>::type
        , T1, T2, T3
        >
{





};

template<
      typename F, typename T1, typename T2, typename T3
    >
struct apply< F,T1,T2,T3,na,na >
    : apply3< F,T1,T2,T3 >
{
};

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    >
struct apply4

    : apply_wrap4<
          typename lambda<F>::type
        , T1, T2, T3, T4
        >
{





};

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    >
struct apply< F,T1,T2,T3,T4,na >
    : apply4< F,T1,T2,T3,T4 >
{
};

template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename T5
    >
struct apply5

    : apply_wrap5<
          typename lambda<F>::type
        , T1, T2, T3, T4, T5
        >
{





};



template<
      typename F, typename T1, typename T2, typename T3, typename T4
    , typename T5
    >
struct apply
    : apply5< F,T1,T2,T3,T4,T5 >
{
};

}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 37 "/usr/include/boost/mpl/apply.hpp" 2 3 4
# 37 "/usr/include/boost/iterator/iterator_facade.hpp" 2 3 4




# 1 "/usr/include/boost/iterator/detail/config_def.hpp" 1 3 4
# 42 "/usr/include/boost/iterator/iterator_facade.hpp" 2 3 4

namespace boost {
namespace iterators {



  template <class I, class V, class TC, class R, class D> class iterator_facade;

  namespace detail
  {



    struct always_bool2
    {
        template <class T, class U>
        struct apply
        {
            typedef bool type;
        };
    };


    template< typename CategoryOrTraversal, typename Required >
    struct is_traversal_at_least :
        public boost::is_convertible< typename iterator_category_to_traversal< CategoryOrTraversal >::type, Required >
    {};




    template <
        class Facade1
      , class Facade2
      , class Return
    >
    struct enable_if_interoperable :
        public boost::iterators::enable_if<
            is_interoperable< Facade1, Facade2 >
          , Return
        >
    {};




    template <
        class Facade1
      , class Facade2
      , class Return
    >
    struct enable_if_interoperable_and_random_access_traversal :
        public boost::iterators::enable_if<
            mpl::and_<
                is_interoperable< Facade1, Facade2 >
              , is_traversal_at_least< typename iterator_category< Facade1 >::type, random_access_traversal_tag >
              , is_traversal_at_least< typename iterator_category< Facade2 >::type, random_access_traversal_tag >
            >
          , Return
        >
    {};





    template <
        class ValueParam
      , class CategoryOrTraversal
      , class Reference
      , class Difference
    >
    struct iterator_facade_types
    {
        typedef typename facade_iterator_category<
            CategoryOrTraversal, ValueParam, Reference
        >::type iterator_category;

        typedef typename remove_const<ValueParam>::type value_type;


        typedef typename mpl::eval_if<
            boost::iterators::detail::iterator_writability_disabled<ValueParam,Reference>
          , add_pointer<const value_type>
          , add_pointer<value_type>
        >::type pointer;
# 145 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
    };







    template <class Iterator>
    class postfix_increment_proxy
    {
        typedef typename iterator_value<Iterator>::type value_type;

     public:
        explicit postfix_increment_proxy(Iterator const& x)
          : stored_iterator(x)
          , stored_value(*x)
        {}






        value_type& operator*() const
        {
            return stored_value;
        }


        operator Iterator const&() const
        {
            return stored_iterator;
        }


        value_type* operator->() const
        {
            return boost::addressof(stored_value);
        }

     private:
        Iterator stored_iterator;
        mutable value_type stored_value;
    };


    template <class Iterator>
    class writable_postfix_increment_dereference_proxy;

    template <class T>
    struct is_not_writable_postfix_increment_dereference_proxy :
        public boost::true_type
    {};

    template <class Iterator>
    struct is_not_writable_postfix_increment_dereference_proxy<
        writable_postfix_increment_dereference_proxy<Iterator>
    > :
        public boost::false_type
    {};

    template <class Iterator>
    class writable_postfix_increment_proxy;





    template <class Iterator>
    class writable_postfix_increment_dereference_proxy
    {
        friend class writable_postfix_increment_proxy<Iterator>;

        typedef typename iterator_value<Iterator>::type value_type;

     public:
        explicit writable_postfix_increment_dereference_proxy(Iterator const& x)
          : stored_iterator(x)
          , stored_value(*x)
        {}


        operator value_type&() const
        {
            return this->stored_value;
        }

        template <class OtherIterator>
        writable_postfix_increment_dereference_proxy const&
        operator=(writable_postfix_increment_dereference_proxy<OtherIterator> const& x) const
        {
            typedef typename iterator_value<OtherIterator>::type other_value_type;
            *this->stored_iterator = static_cast<other_value_type&>(x);
            return *this;
        }



        template <class T>
        typename iterators::enable_if<
            is_not_writable_postfix_increment_dereference_proxy< T >,
            writable_postfix_increment_dereference_proxy const&
        >::type operator=(T&& x) const
        {
            *this->stored_iterator = static_cast< T&& >(x);
            return *this;
        }
# 276 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
     private:
        Iterator stored_iterator;
        mutable value_type stored_value;
    };

    template <class Iterator>
    class writable_postfix_increment_proxy
    {
        typedef typename iterator_value<Iterator>::type value_type;

     public:
        explicit writable_postfix_increment_proxy(Iterator const& x)
          : dereference_proxy(x)
        {}

        writable_postfix_increment_dereference_proxy<Iterator> const&
        operator*() const
        {
            return dereference_proxy;
        }


        operator Iterator const&() const
        {
            return dereference_proxy.stored_iterator;
        }


        value_type* operator->() const
        {
            return boost::addressof(dereference_proxy.stored_value);
        }

     private:
        writable_postfix_increment_dereference_proxy<Iterator> dereference_proxy;
    };
# 340 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
    template <class Reference, class Value>
    struct is_non_proxy_reference
      : is_convertible<
            typename remove_reference<Reference>::type
            const volatile*
          , Value const volatile*
        >
    {};
# 365 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
    template <class Iterator, class Value, class Reference, class CategoryOrTraversal>
    struct postfix_increment_result
      : mpl::eval_if<
            mpl::and_<

                is_convertible<
                    Reference





                  , typename add_lvalue_reference<Value const>::type
                >



              , mpl::not_<
                    is_convertible<
                        typename iterator_category_to_traversal<CategoryOrTraversal>::type
                      , forward_traversal_tag
                    >
                >
            >
          , mpl::if_<
                is_non_proxy_reference<Reference,Value>
              , postfix_increment_proxy<Iterator>
              , writable_postfix_increment_proxy<Iterator>
            >
          , mpl::identity<Iterator>
        >
    {};





    template <class Reference, class Pointer>
    struct operator_arrow_dispatch
    {
        struct proxy
        {
            explicit proxy(Reference const & x) : m_ref(x) {}
            Reference* operator->() { return boost::addressof(m_ref); }


            operator Reference*() { return boost::addressof(m_ref); }
            Reference m_ref;
        };
        typedef proxy result_type;
        static result_type apply(Reference const & x)
        {
            return result_type(x);
        }
    };

    template <class T, class Pointer>
    struct operator_arrow_dispatch<T&, Pointer>
    {
        typedef Pointer result_type;
        static result_type apply(T& x)
        {
            return boost::addressof(x);
        }
    };




    template <class Iterator>
    class operator_brackets_proxy
    {


        typedef typename Iterator::reference reference;
        typedef typename Iterator::value_type value_type;

     public:
        operator_brackets_proxy(Iterator const& iter)
          : m_iter(iter)
        {}

        operator reference() const
        {
            return *m_iter;
        }

        operator_brackets_proxy& operator=(value_type const& val)
        {
            *m_iter = val;
            return *this;
        }

     private:
        Iterator m_iter;
    };



    template <class ValueType, class Reference>
    struct use_operator_brackets_proxy
      : mpl::not_<
            mpl::and_<


                boost::is_POD<ValueType>
              , iterator_writability_disabled<ValueType,Reference>
            >
        >
    {};

    template <class Iterator, class Value, class Reference>
    struct operator_brackets_result
    {
        typedef typename mpl::if_<
            use_operator_brackets_proxy<Value,Reference>
          , operator_brackets_proxy<Iterator>
          , Value
        >::type type;
    };

    template <class Iterator>
    operator_brackets_proxy<Iterator> make_operator_brackets_result(Iterator const& iter, mpl::true_)
    {
        return operator_brackets_proxy<Iterator>(iter);
    }

    template <class Iterator>
    typename Iterator::value_type make_operator_brackets_result(Iterator const& iter, mpl::false_)
    {
      return *iter;
    }

    struct choose_difference_type
    {
        template <class I1, class I2>
        struct apply
          :



          mpl::eval_if<
              is_convertible<I2,I1>
            , iterator_difference<I1>
            , iterator_difference<I2>
          >

        {};

    };

    template <
        class Derived
      , class Value
      , class CategoryOrTraversal
      , class Reference
      , class Difference
      , bool IsBidirectionalTraversal
      , bool IsRandomAccessTraversal
    >
    class iterator_facade_base;

  }
# 578 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
  class iterator_core_access
  {






      template <class I, class V, class TC, class R, class D> friend class iterator_facade;
      template <class I, class V, class TC, class R, class D, bool IsBidirectionalTraversal, bool IsRandomAccessTraversal>
      friend class detail::iterator_facade_base;




      template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > friend typename boost::iterators::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::iterators::detail::always_bool2,Derived1,Derived2>::type >::type operator ==( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs);
      template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > friend typename boost::iterators::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::iterators::detail::always_bool2,Derived1,Derived2>::type >::type operator !=( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs);






      template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > friend typename boost::iterators::detail::enable_if_interoperable_and_random_access_traversal< Derived1, Derived2 , typename mpl::apply2<boost::iterators::detail::always_bool2,Derived1,Derived2>::type >::type operator <( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs);
      template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > friend typename boost::iterators::detail::enable_if_interoperable_and_random_access_traversal< Derived1, Derived2 , typename mpl::apply2<boost::iterators::detail::always_bool2,Derived1,Derived2>::type >::type operator >( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs);
      template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > friend typename boost::iterators::detail::enable_if_interoperable_and_random_access_traversal< Derived1, Derived2 , typename mpl::apply2<boost::iterators::detail::always_bool2,Derived1,Derived2>::type >::type operator <=( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs);
      template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > friend typename boost::iterators::detail::enable_if_interoperable_and_random_access_traversal< Derived1, Derived2 , typename mpl::apply2<boost::iterators::detail::always_bool2,Derived1,Derived2>::type >::type operator >=( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs);



      template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > friend typename boost::iterators::detail::enable_if_interoperable_and_random_access_traversal< Derived1, Derived2 , typename mpl::apply2<boost::iterators::detail::choose_difference_type,Derived1,Derived2>::type >::type operator -( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs)

      ;

      template <class Derived, class V, class TC, class R, class D> friend inline typename boost::iterators::enable_if< boost::iterators::detail::is_traversal_at_least< TC, boost::iterators::random_access_traversal_tag >, Derived >::type operator+ (iterator_facade<Derived, V, TC, R, D> const& , typename Derived::difference_type)




      ;

      template <class Derived, class V, class TC, class R, class D> friend inline typename boost::iterators::enable_if< boost::iterators::detail::is_traversal_at_least< TC, boost::iterators::random_access_traversal_tag >, Derived >::type operator+ (typename Derived::difference_type , iterator_facade<Derived, V, TC, R, D> const&)




      ;



      template <class Facade>
      static typename Facade::reference dereference(Facade const& f)
      {
          return f.dereference();
      }

      template <class Facade>
      static void increment(Facade& f)
      {
          f.increment();
      }

      template <class Facade>
      static void decrement(Facade& f)
      {
          f.decrement();
      }

      template <class Facade1, class Facade2>
      static bool equal(Facade1 const& f1, Facade2 const& f2, mpl::true_)
      {
          return f1.equal(f2);
      }

      template <class Facade1, class Facade2>
      static bool equal(Facade1 const& f1, Facade2 const& f2, mpl::false_)
      {
          return f2.equal(f1);
      }

      template <class Facade>
      static void advance(Facade& f, typename Facade::difference_type n)
      {
          f.advance(n);
      }

      template <class Facade1, class Facade2>
      static typename Facade1::difference_type distance_from(
          Facade1 const& f1, Facade2 const& f2, mpl::true_)
      {
          return -f1.distance_to(f2);
      }

      template <class Facade1, class Facade2>
      static typename Facade2::difference_type distance_from(
          Facade1 const& f1, Facade2 const& f2, mpl::false_)
      {
          return f2.distance_to(f1);
      }




      template <class I, class V, class TC, class R, class D>
      static I& derived(iterator_facade<I,V,TC,R,D>& facade)
      {
          return *static_cast<I*>(&facade);
      }

      template <class I, class V, class TC, class R, class D>
      static I const& derived(iterator_facade<I,V,TC,R,D> const& facade)
      {
          return *static_cast<I const*>(&facade);
      }


      iterator_core_access() = delete;
  };

  namespace detail {


    template <
        class Derived
      , class Value
      , class CategoryOrTraversal
      , class Reference
      , class Difference
    >
    class iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, false, false >






    {
    private:
        typedef boost::iterators::detail::iterator_facade_types<
            Value, CategoryOrTraversal, Reference, Difference
        > associated_types;

        typedef boost::iterators::detail::operator_arrow_dispatch<
            Reference
          , typename associated_types::pointer
        > operator_arrow_dispatch_;

    public:
        typedef typename associated_types::value_type value_type;
        typedef Reference reference;
        typedef Difference difference_type;

        typedef typename operator_arrow_dispatch_::result_type pointer;

        typedef typename associated_types::iterator_category iterator_category;

    public:
        reference operator*() const
        {
            return iterator_core_access::dereference(this->derived());
        }

        pointer operator->() const
        {
            return operator_arrow_dispatch_::apply(*this->derived());
        }

        Derived& operator++()
        {
            iterator_core_access::increment(this->derived());
            return this->derived();
        }

    protected:



        Derived& derived()
        {
            return *static_cast<Derived*>(this);
        }

        Derived const& derived() const
        {
            return *static_cast<Derived const*>(this);
        }
    };


    template <
        class Derived
      , class Value
      , class CategoryOrTraversal
      , class Reference
      , class Difference
    >
    class iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, true, false > :
        public iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, false, false >
    {
    public:
        Derived& operator--()
        {
            iterator_core_access::decrement(this->derived());
            return this->derived();
        }

        Derived operator--(int)
        {
            Derived tmp(this->derived());
            --*this;
            return tmp;
        }
    };


    template <
        class Derived
      , class Value
      , class CategoryOrTraversal
      , class Reference
      , class Difference
    >
    class iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, true, true > :
        public iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, true, false >
    {
    private:
        typedef iterator_facade_base< Derived, Value, CategoryOrTraversal, Reference, Difference, true, false > base_type;

    public:
        typedef typename base_type::reference reference;
        typedef typename base_type::difference_type difference_type;

    public:
        typename boost::iterators::detail::operator_brackets_result<Derived, Value, reference>::type
        operator[](difference_type n) const
        {
            typedef boost::iterators::detail::use_operator_brackets_proxy<Value, Reference> use_proxy;

            return boost::iterators::detail::make_operator_brackets_result<Derived>(
                this->derived() + n
              , use_proxy()
            );
        }

        Derived& operator+=(difference_type n)
        {
            iterator_core_access::advance(this->derived(), n);
            return this->derived();
        }

        Derived& operator-=(difference_type n)
        {
            iterator_core_access::advance(this->derived(), -n);
            return this->derived();
        }

        Derived operator-(difference_type x) const
        {
            Derived result(this->derived());
            return result -= x;
        }
    };

  }





  template <
      class Derived
    , class Value
    , class CategoryOrTraversal
    , class Reference = Value&
    , class Difference = std::ptrdiff_t
  >
  class iterator_facade :
      public detail::iterator_facade_base<
          Derived,
          Value,
          CategoryOrTraversal,
          Reference,
          Difference,
          detail::is_traversal_at_least< CategoryOrTraversal, bidirectional_traversal_tag >::value,
          detail::is_traversal_at_least< CategoryOrTraversal, random_access_traversal_tag >::value
      >
  {
  protected:

      typedef iterator_facade<Derived,Value,CategoryOrTraversal,Reference,Difference> iterator_facade_;
  };

  template <class I, class V, class TC, class R, class D>
  inline typename boost::iterators::detail::postfix_increment_result<I,V,R,TC>::type
  operator++(
      iterator_facade<I,V,TC,R,D>& i
    , int
  )
  {
      typename boost::iterators::detail::postfix_increment_result<I,V,R,TC>::type
          tmp(*static_cast<I*>(&i));

      ++i;

      return tmp;
  }
# 981 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
  template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > inline typename boost::iterators::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::iterators::detail::always_bool2,Derived1,Derived2>::type >::type operator ==( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs) { static_assert(( is_interoperable< Derived1, Derived2 >::value ), "( is_interoperable< Derived1, Derived2 >::value )"); return iterator_core_access::equal( *static_cast<Derived1 const*>(&lhs) , *static_cast<Derived2 const*>(&rhs) , is_convertible<Derived2,Derived1>() ); }
  template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > inline typename boost::iterators::detail::enable_if_interoperable< Derived1, Derived2 , typename mpl::apply2<boost::iterators::detail::always_bool2,Derived1,Derived2>::type >::type operator !=( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs) { static_assert(( is_interoperable< Derived1, Derived2 >::value ), "( is_interoperable< Derived1, Derived2 >::value )"); return ! iterator_core_access::equal( *static_cast<Derived1 const*>(&lhs) , *static_cast<Derived2 const*>(&rhs) , is_convertible<Derived2,Derived1>() ); }
# 1011 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
  template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > inline typename boost::iterators::detail::enable_if_interoperable_and_random_access_traversal< Derived1, Derived2 , typename mpl::apply2<boost::iterators::detail::always_bool2,Derived1,Derived2>::type >::type operator <( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs) { static_assert(( is_interoperable< Derived1, Derived2 >::value && boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived1 >::type, random_access_traversal_tag >::value && boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived2 >::type, random_access_traversal_tag >::value ), "( is_interoperable< Derived1, Derived2 >::value && boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived1 >::type, random_access_traversal_tag >::value && boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived2 >::type, random_access_traversal_tag >::value )"); return 0 > iterator_core_access::distance_from( *static_cast<Derived1 const*>(&lhs) , *static_cast<Derived2 const*>(&rhs) , is_convertible<Derived2,Derived1>() ); }
  template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > inline typename boost::iterators::detail::enable_if_interoperable_and_random_access_traversal< Derived1, Derived2 , typename mpl::apply2<boost::iterators::detail::always_bool2,Derived1,Derived2>::type >::type operator >( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs) { static_assert(( is_interoperable< Derived1, Derived2 >::value && boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived1 >::type, random_access_traversal_tag >::value && boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived2 >::type, random_access_traversal_tag >::value ), "( is_interoperable< Derived1, Derived2 >::value && boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived1 >::type, random_access_traversal_tag >::value && boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived2 >::type, random_access_traversal_tag >::value )"); return 0 < iterator_core_access::distance_from( *static_cast<Derived1 const*>(&lhs) , *static_cast<Derived2 const*>(&rhs) , is_convertible<Derived2,Derived1>() ); }
  template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > inline typename boost::iterators::detail::enable_if_interoperable_and_random_access_traversal< Derived1, Derived2 , typename mpl::apply2<boost::iterators::detail::always_bool2,Derived1,Derived2>::type >::type operator <=( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs) { static_assert(( is_interoperable< Derived1, Derived2 >::value && boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived1 >::type, random_access_traversal_tag >::value && boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived2 >::type, random_access_traversal_tag >::value ), "( is_interoperable< Derived1, Derived2 >::value && boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived1 >::type, random_access_traversal_tag >::value && boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived2 >::type, random_access_traversal_tag >::value )"); return 0 >= iterator_core_access::distance_from( *static_cast<Derived1 const*>(&lhs) , *static_cast<Derived2 const*>(&rhs) , is_convertible<Derived2,Derived1>() ); }
  template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > inline typename boost::iterators::detail::enable_if_interoperable_and_random_access_traversal< Derived1, Derived2 , typename mpl::apply2<boost::iterators::detail::always_bool2,Derived1,Derived2>::type >::type operator >=( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs) { static_assert(( is_interoperable< Derived1, Derived2 >::value && boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived1 >::type, random_access_traversal_tag >::value && boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived2 >::type, random_access_traversal_tag >::value ), "( is_interoperable< Derived1, Derived2 >::value && boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived1 >::type, random_access_traversal_tag >::value && boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived2 >::type, random_access_traversal_tag >::value )"); return 0 <= iterator_core_access::distance_from( *static_cast<Derived1 const*>(&lhs) , *static_cast<Derived2 const*>(&rhs) , is_convertible<Derived2,Derived1>() ); }




  template < class Derived1, class V1, class TC1, class Reference1, class Difference1 , class Derived2, class V2, class TC2, class Reference2, class Difference2 > inline typename boost::iterators::detail::enable_if_interoperable_and_random_access_traversal< Derived1, Derived2 , typename mpl::apply2<boost::iterators::detail::choose_difference_type,Derived1,Derived2>::type >::type operator -( iterator_facade<Derived1, V1, TC1, Reference1, Difference1> const& lhs , iterator_facade<Derived2, V2, TC2, Reference2, Difference2> const& rhs) { static_assert(( is_interoperable< Derived1, Derived2 >::value && boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived1 >::type, random_access_traversal_tag >::value && boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived2 >::type, random_access_traversal_tag >::value ), "( is_interoperable< Derived1, Derived2 >::value && boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived1 >::type, random_access_traversal_tag >::value && boost::iterators::detail::is_traversal_at_least< typename iterator_category< Derived2 >::type, random_access_traversal_tag >::value )"); return iterator_core_access::distance_from( *static_cast<Derived1 const*>(&lhs) , *static_cast<Derived2 const*>(&rhs) , is_convertible<Derived2,Derived1>() ); }
# 1036 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
  template <class Derived, class V, class TC, class R, class D> inline typename boost::iterators::enable_if< boost::iterators::detail::is_traversal_at_least< TC, boost::iterators::random_access_traversal_tag >, Derived >::type operator+ ( iterator_facade<Derived, V, TC, R, D> const& i , typename Derived::difference_type n ) { Derived tmp(static_cast<Derived const&>(i)); return tmp += n; }




  template <class Derived, class V, class TC, class R, class D> inline typename boost::iterators::enable_if< boost::iterators::detail::is_traversal_at_least< TC, boost::iterators::random_access_traversal_tag >, Derived >::type operator+ ( typename Derived::difference_type n , iterator_facade<Derived, V, TC, R, D> const& i ) { Derived tmp(static_cast<Derived const&>(i)); return tmp += n; }
# 1053 "/usr/include/boost/iterator/iterator_facade.hpp" 3 4
}

using iterators::iterator_core_access;
using iterators::iterator_facade;

}

# 1 "/usr/include/boost/iterator/detail/config_undef.hpp" 1 3 4
# 1061 "/usr/include/boost/iterator/iterator_facade.hpp" 2 3 4
# 16 "/usr/include/boost/iterator/iterator_adaptor.hpp" 2 3 4
# 30 "/usr/include/boost/iterator/iterator_adaptor.hpp" 3 4
# 1 "/usr/include/boost/iterator/detail/config_def.hpp" 1 3 4
# 31 "/usr/include/boost/iterator/iterator_adaptor.hpp" 2 3 4



namespace boost {
namespace iterators {




  using boost::use_default;

}




template<class To>
struct is_convertible<use_default,To>
  : mpl::false_ {};

namespace iterators {

  namespace detail
  {
# 63 "/usr/include/boost/iterator/iterator_adaptor.hpp" 3 4
    struct enable_type;
  }
# 130 "/usr/include/boost/iterator/iterator_adaptor.hpp" 3 4
  template<typename From, typename To>
  struct enable_if_convertible
    : iterators::enable_if<
          is_convertible<From, To>
        , boost::iterators::detail::enable_type
      >
  {};






  namespace detail
  {


    template <class T, class DefaultNullaryFn>
    struct ia_dflt_help
      : mpl::eval_if<
            is_same<T, use_default>
          , DefaultNullaryFn
          , mpl::identity<T>
        >
    {
    };



    template <
        class Derived
      , class Base
      , class Value
      , class Traversal
      , class Reference
      , class Difference
    >
    struct iterator_adaptor_base
    {
        typedef iterator_facade<
            Derived


          , typename boost::iterators::detail::ia_dflt_help<
                Value
              , mpl::eval_if<
                    is_same<Reference,use_default>
                  , iterator_value<Base>
                  , remove_reference<Reference>
                >
            >::type






          , typename boost::iterators::detail::ia_dflt_help<
                Traversal
              , iterator_traversal<Base>
            >::type

          , typename boost::iterators::detail::ia_dflt_help<
                Reference
              , mpl::eval_if<
                    is_same<Value,use_default>
                  , iterator_reference<Base>
                  , add_reference<Value>
                >
            >::type

          , typename boost::iterators::detail::ia_dflt_help<
                Difference, iterator_difference<Base>
            >::type
        >
        type;
    };


    template <class Tr1, class Tr2>
    inline void iterator_adaptor_assert_traversal ()
    {
      static_assert((is_convertible<Tr1, Tr2>::value), "(is_convertible<Tr1, Tr2>::value)");
    }
  }
# 241 "/usr/include/boost/iterator/iterator_adaptor.hpp" 3 4
  template <
      class Derived
    , class Base
    , class Value = use_default
    , class Traversal = use_default
    , class Reference = use_default
    , class Difference = use_default
  >
  class iterator_adaptor
    : public boost::iterators::detail::iterator_adaptor_base<
        Derived, Base, Value, Traversal, Reference, Difference
      >::type
  {
      friend class iterator_core_access;

   protected:
      typedef typename boost::iterators::detail::iterator_adaptor_base<
          Derived, Base, Value, Traversal, Reference, Difference
      >::type super_t;
   public:
      iterator_adaptor() {}

      explicit iterator_adaptor(Base const &iter)
          : m_iterator(iter)
      {
      }

      typedef Base base_type;

      Base const& base() const
        { return m_iterator; }

   protected:

      typedef iterator_adaptor<Derived,Base,Value,Traversal,Reference,Difference> iterator_adaptor_;




      Base const& base_reference() const
        { return m_iterator; }

      Base& base_reference()
        { return m_iterator; }

   private:






      typename super_t::reference dereference() const
        { return *m_iterator; }

      template <
      class OtherDerived, class OtherIterator, class V, class C, class R, class D
      >
      bool equal(iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& x) const
      {




          return m_iterator == x.base();
      }

      typedef typename iterator_category_to_traversal<
          typename super_t::iterator_category
      >::type my_traversal;




      void advance(typename super_t::difference_type n)
      {
          boost::iterators::detail::iterator_adaptor_assert_traversal<my_traversal, random_access_traversal_tag>();
          m_iterator += n;
      }

      void increment() { ++m_iterator; }

      void decrement()
      {
          boost::iterators::detail::iterator_adaptor_assert_traversal<my_traversal, bidirectional_traversal_tag>();
           --m_iterator;
      }

      template <
          class OtherDerived, class OtherIterator, class V, class C, class R, class D
      >
      typename super_t::difference_type distance_to(
          iterator_adaptor<OtherDerived, OtherIterator, V, C, R, D> const& y) const
      {
          boost::iterators::detail::iterator_adaptor_assert_traversal<my_traversal, random_access_traversal_tag>();




          return y.base() - m_iterator;
      }



   private:
      Base m_iterator;
  };

}

using iterators::iterator_adaptor;
using iterators::enable_if_convertible;

}

# 1 "/usr/include/boost/iterator/detail/config_undef.hpp" 1 3 4
# 357 "/usr/include/boost/iterator/iterator_adaptor.hpp" 2 3 4
# 11 "/usr/include/boost/iterator/reverse_iterator.hpp" 2 3 4

namespace boost {
namespace iterators {




  template <class Iterator>
  class reverse_iterator
      : public iterator_adaptor< reverse_iterator<Iterator>, Iterator >
  {
      typedef iterator_adaptor< reverse_iterator<Iterator>, Iterator > super_t;

      friend class iterator_core_access;

   public:
      reverse_iterator() {}

      explicit reverse_iterator(Iterator x)
          : super_t(x) {}

      template<class OtherIterator>
      reverse_iterator(
          reverse_iterator<OtherIterator> const& r
          , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0
          )
          : super_t(r.base())
      {}

   private:
      typename super_t::reference dereference() const
      {
          Iterator it = this->base_reference();
          --it;
          return *it;
      }

      void increment() { --this->base_reference(); }
      void decrement() { ++this->base_reference(); }

      void advance(typename super_t::difference_type n)
      {
          this->base_reference() -= n;
      }

      template <class OtherIterator>
      typename super_t::difference_type
      distance_to(reverse_iterator<OtherIterator> const& y) const
      {
          return this->base_reference() - y.base();
      }
  };

  template <class BidirectionalIterator>
  inline reverse_iterator<BidirectionalIterator> make_reverse_iterator(BidirectionalIterator x)
  {
      return reverse_iterator<BidirectionalIterator>(x);
  }

}

using iterators::reverse_iterator;
using iterators::make_reverse_iterator;

}
# 26 "/usr/include/boost/next_prior.hpp" 2 3 4

namespace boost {
# 39 "/usr/include/boost/next_prior.hpp" 3 4
namespace next_prior_detail {

template< typename T, typename Distance, bool HasPlus = has_plus< T, Distance >::value >
struct next_plus_impl;

template< typename T, typename Distance >
struct next_plus_impl< T, Distance, true >
{
    static T call(T x, Distance n)
    {
        return x + n;
    }
};

template< typename T, typename Distance, bool HasPlusAssign = has_plus_assign< T, Distance >::value >
struct next_plus_assign_impl :
    public next_plus_impl< T, Distance >
{
};

template< typename T, typename Distance >
struct next_plus_assign_impl< T, Distance, true >
{
    static T call(T x, Distance n)
    {
        x += n;
        return x;
    }
};

template< typename T, typename Distance, bool IsIterator = boost::iterators::is_iterator< T >::value >
struct next_advance_impl :
    public next_plus_assign_impl< T, Distance >
{
};

template< typename T, typename Distance >
struct next_advance_impl< T, Distance, true >
{
    static T call(T x, Distance n)
    {
        boost::iterators::advance(x, n);
        return x;
    }
};


template< typename T, typename Distance, bool HasMinus = has_minus< T, Distance >::value >
struct prior_minus_impl;

template< typename T, typename Distance >
struct prior_minus_impl< T, Distance, true >
{
    static T call(T x, Distance n)
    {
        return x - n;
    }
};

template< typename T, typename Distance, bool HasMinusAssign = has_minus_assign< T, Distance >::value >
struct prior_minus_assign_impl :
    public prior_minus_impl< T, Distance >
{
};

template< typename T, typename Distance >
struct prior_minus_assign_impl< T, Distance, true >
{
    static T call(T x, Distance n)
    {
        x -= n;
        return x;
    }
};

template< typename T, typename Distance, bool IsIterator = boost::iterators::is_iterator< T >::value >
struct prior_advance_impl :
    public prior_minus_assign_impl< T, Distance >
{
};

template< typename T, typename Distance >
struct prior_advance_impl< T, Distance, true >
{
    static T call(T x, Distance n)
    {

        boost::iterators::reverse_iterator< T > rx(x);
        boost::iterators::advance(rx, n);
        return rx.base();
    }
};

}

template <class T>
inline T next(T x) { return ++x; }

template <class T, class Distance>
inline T next(T x, Distance n)
{
    return next_prior_detail::next_advance_impl< T, Distance >::call(x, n);
}

template <class T>
inline T prior(T x) { return --x; }

template <class T, class Distance>
inline T prior(T x, Distance n)
{
    return next_prior_detail::prior_advance_impl< T, Distance >::call(x, n);
}

}
# 22 "/usr/include/boost/lockfree/spsc_queue.hpp" 2 3 4



# 1 "/usr/include/boost/type_traits/has_trivial_destructor.hpp" 1 3 4
# 25 "/usr/include/boost/type_traits/has_trivial_destructor.hpp" 3 4
# 1 "/usr/include/boost/type_traits/is_destructible.hpp" 1 3 4
# 23 "/usr/include/boost/type_traits/is_destructible.hpp" 3 4
namespace boost{

   namespace detail{

      struct is_destructible_imp
      {
         template<typename T, typename = decltype(boost::declval<T&>().~T())>
         static boost::type_traits::yes_type test(int);
         template<typename>
         static boost::type_traits::no_type test(...);
      };

   }

   template <class T> struct is_destructible : public integral_constant<bool, sizeof(boost::detail::is_destructible_imp::test<T>(0)) == sizeof(boost::type_traits::yes_type)>
   {
      static_assert(boost::is_complete<T>::value, "Arguments to is_destructible must be complete types");
   };
# 56 "/usr/include/boost/type_traits/is_destructible.hpp" 3 4
   template <> struct is_destructible<void> : public false_type{};
   template <> struct is_destructible<void const> : public false_type{};
   template <> struct is_destructible<void volatile> : public false_type{};
   template <> struct is_destructible<void const volatile> : public false_type{};
   template <class T> struct is_destructible<T&> : public is_destructible<T>{};

   template <class T> struct is_destructible<T&&> : public is_destructible<T>{};

   template <class T, std::size_t N> struct is_destructible<T[N]> : public is_destructible<T>{};
   template <class T> struct is_destructible<T[]> : public is_destructible<T>{};

}
# 26 "/usr/include/boost/type_traits/has_trivial_destructor.hpp" 2 3 4


namespace boost {

template <typename T> struct has_trivial_destructor : public integral_constant<bool, (__is_trivially_destructible(T) && is_destructible<T>::value)>{};
# 39 "/usr/include/boost/type_traits/has_trivial_destructor.hpp" 3 4
template <> struct has_trivial_destructor<void> : public false_type{};

template <> struct has_trivial_destructor<void const> : public false_type{};
template <> struct has_trivial_destructor<void const volatile> : public false_type{};
template <> struct has_trivial_destructor<void volatile> : public false_type{};


}
# 26 "/usr/include/boost/lockfree/spsc_queue.hpp" 2 3 4


# 1 "/usr/include/boost/lockfree/detail/atomic.hpp" 1 3 4
# 60 "/usr/include/boost/lockfree/detail/atomic.hpp" 3 4
namespace boost {
namespace lockfree {
namespace detail {
# 71 "/usr/include/boost/lockfree/detail/atomic.hpp" 3 4
using std::atomic;
using std::memory_order_acquire;
using std::memory_order_consume;
using std::memory_order_relaxed;
using std::memory_order_release;


}
using detail::atomic;
using detail::memory_order_acquire;
using detail::memory_order_consume;
using detail::memory_order_relaxed;
using detail::memory_order_release;

}}
# 29 "/usr/include/boost/lockfree/spsc_queue.hpp" 2 3 4
# 1 "/usr/include/boost/lockfree/detail/copy_payload.hpp" 1 3 4
# 20 "/usr/include/boost/lockfree/detail/copy_payload.hpp" 3 4
namespace boost {
namespace lockfree {
namespace detail {

struct copy_convertible
{
    template <typename T, typename U>
    static void copy(T & t, U & u)
    {
        u = t;
    }
};

struct copy_constructible_and_copyable
{
    template <typename T, typename U>
    static void copy(T & t, U & u)
    {
        u = U(t);
    }
};

template <typename T, typename U>
void copy_payload(T & t, U & u)
{
    typedef typename boost::mpl::if_<typename boost::is_convertible<T, U>::type,
                                     copy_convertible,
                                     copy_constructible_and_copyable
                                    >::type copy_type;
    copy_type::copy(t, u);
}

template <typename T>
struct consume_via_copy
{
    consume_via_copy(T & out):
        out_(out)
    {}

    template <typename U>
    void operator()(U & element)
    {
        copy_payload(element, out_);
    }

    T & out_;
};

struct consume_noop
{
    template <typename U>
    void operator()(const U &)
    {
    }
};


}}}
# 30 "/usr/include/boost/lockfree/spsc_queue.hpp" 2 3 4
# 1 "/usr/include/boost/lockfree/detail/parameter.hpp" 1 3 4
# 12 "/usr/include/boost/lockfree/detail/parameter.hpp" 3 4
# 1 "/usr/include/boost/align/aligned_allocator.hpp" 1 3 4
# 11 "/usr/include/boost/align/aligned_allocator.hpp" 3 4
# 1 "/usr/include/boost/align/detail/add_reference.hpp" 1 3 4
# 17 "/usr/include/boost/align/detail/add_reference.hpp" 3 4
namespace boost {
namespace alignment {
namespace detail {


using std::add_lvalue_reference;
# 40 "/usr/include/boost/align/detail/add_reference.hpp" 3 4
}
}
}
# 12 "/usr/include/boost/align/aligned_allocator.hpp" 2 3 4
# 1 "/usr/include/boost/align/detail/is_alignment_constant.hpp" 1 3 4
# 11 "/usr/include/boost/align/detail/is_alignment_constant.hpp" 3 4
# 1 "/usr/include/boost/align/detail/integral_constant.hpp" 1 3 4
# 17 "/usr/include/boost/align/detail/integral_constant.hpp" 3 4
namespace boost {
namespace alignment {
namespace detail {


using std::integral_constant;
using std::true_type;
using std::false_type;
# 49 "/usr/include/boost/align/detail/integral_constant.hpp" 3 4
}
}
}
# 12 "/usr/include/boost/align/detail/is_alignment_constant.hpp" 2 3 4


namespace boost {
namespace alignment {
namespace detail {

template<std::size_t N>
struct is_alignment_constant
    : integral_constant<bool, (N > 0) && ((N & (N - 1)) == 0)> { };

}
}
}
# 13 "/usr/include/boost/align/aligned_allocator.hpp" 2 3 4
# 1 "/usr/include/boost/align/detail/max_objects.hpp" 1 3 4
# 14 "/usr/include/boost/align/detail/max_objects.hpp" 3 4
namespace boost {
namespace alignment {
namespace detail {

template<class T>
struct max_objects
    : integral_constant<std::size_t,
        ~static_cast<std::size_t>(0) / sizeof(T)> { };

}
}
}
# 14 "/usr/include/boost/align/aligned_allocator.hpp" 2 3 4
# 1 "/usr/include/boost/align/detail/max_size.hpp" 1 3 4
# 14 "/usr/include/boost/align/detail/max_size.hpp" 3 4
namespace boost {
namespace alignment {
namespace detail {

template<std::size_t A, std::size_t B>
struct max_size
    : integral_constant<std::size_t, (A > B) ? A : B> { };

}
}
}
# 15 "/usr/include/boost/align/aligned_allocator.hpp" 2 3 4
# 1 "/usr/include/boost/align/detail/throw_exception.hpp" 1 3 4
# 16 "/usr/include/boost/align/detail/throw_exception.hpp" 3 4
namespace boost {





namespace alignment {
namespace detail {


template<class E>
__attribute__ ((__noreturn__)) inline void
throw_exception(const E& error)
{
    throw error;
}
# 40 "/usr/include/boost/align/detail/throw_exception.hpp" 3 4
}
}
}
# 16 "/usr/include/boost/align/aligned_allocator.hpp" 2 3 4
# 1 "/usr/include/boost/align/aligned_alloc.hpp" 1 3 4
# 42 "/usr/include/boost/align/aligned_alloc.hpp" 3 4
# 1 "/usr/include/boost/align/detail/aligned_alloc_posix.hpp" 1 3 4
# 11 "/usr/include/boost/align/detail/aligned_alloc_posix.hpp" 3 4
# 1 "/usr/include/boost/align/detail/is_alignment.hpp" 1 3 4
# 14 "/usr/include/boost/align/detail/is_alignment.hpp" 3 4
namespace boost {
namespace alignment {
namespace detail {

constexpr inline bool
is_alignment(std::size_t value) noexcept
{
    return (value > 0) && ((value & (value - 1)) == 0);
}

}
}
}
# 12 "/usr/include/boost/align/detail/aligned_alloc_posix.hpp" 2 3 4
# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 58 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 59 "/usr/include/boost/assert.hpp" 2 3 4
# 13 "/usr/include/boost/align/detail/aligned_alloc_posix.hpp" 2 3 4
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/stdlib.h" 1 3 4
# 14 "/usr/include/boost/align/detail/aligned_alloc_posix.hpp" 2 3 4

namespace boost {
namespace alignment {

inline void*
aligned_alloc(std::size_t alignment, std::size_t size) noexcept
{
    (static_cast <bool> (detail::is_alignment(alignment)) ? void (0) : __assert_fail ("detail::is_alignment(alignment)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
    if (alignment < sizeof(void*)) {
        alignment = sizeof(void*);
    }
    void* p;
    if (::posix_memalign(&p, alignment, size) != 0) {
        p = 0;
    }
    return p;
}

inline void
aligned_free(void* ptr) noexcept
{
    ::free(ptr);
}

}
}
# 43 "/usr/include/boost/align/aligned_alloc.hpp" 2 3 4
# 17 "/usr/include/boost/align/aligned_allocator.hpp" 2 3 4
# 1 "/usr/include/boost/align/aligned_allocator_forward.hpp" 1 3 4
# 13 "/usr/include/boost/align/aligned_allocator_forward.hpp" 3 4
namespace boost {
namespace alignment {

template<class T, std::size_t Alignment = 1>
class aligned_allocator;

}
}
# 18 "/usr/include/boost/align/aligned_allocator.hpp" 2 3 4
# 1 "/usr/include/boost/align/alignment_of.hpp" 1 3 4
# 11 "/usr/include/boost/align/alignment_of.hpp" 3 4
# 1 "/usr/include/boost/align/detail/element_type.hpp" 1 3 4
# 19 "/usr/include/boost/align/detail/element_type.hpp" 3 4
namespace boost {
namespace alignment {
namespace detail {


using std::remove_reference;
using std::remove_all_extents;
using std::remove_cv;
# 81 "/usr/include/boost/align/detail/element_type.hpp" 3 4
template<class T>
struct element_type {
    typedef typename remove_cv<typename remove_all_extents<typename
        remove_reference<T>::type>::type>::type type;
};

}
}
}
# 12 "/usr/include/boost/align/alignment_of.hpp" 2 3 4
# 1 "/usr/include/boost/align/alignment_of_forward.hpp" 1 3 4
# 11 "/usr/include/boost/align/alignment_of_forward.hpp" 3 4
namespace boost {
namespace alignment {

template<class T>
struct alignment_of;

}
}
# 13 "/usr/include/boost/align/alignment_of.hpp" 2 3 4
# 23 "/usr/include/boost/align/alignment_of.hpp" 3 4
# 1 "/usr/include/boost/align/detail/alignment_of_cxx11.hpp" 1 3 4
# 13 "/usr/include/boost/align/detail/alignment_of_cxx11.hpp" 3 4
namespace boost {
namespace alignment {
namespace detail {

using std::alignment_of;

}
}
}
# 24 "/usr/include/boost/align/alignment_of.hpp" 2 3 4
# 38 "/usr/include/boost/align/alignment_of.hpp" 3 4
namespace boost {
namespace alignment {

template<class T>
struct alignment_of
    : detail::alignment_of<typename
        detail::element_type<T>::type>::type { };


template<class T>
constexpr std::size_t alignment_of_v = alignment_of<T>::value;


}
}
# 19 "/usr/include/boost/align/aligned_allocator.hpp" 2 3 4







namespace boost {
namespace alignment {

template<class T, std::size_t Alignment>
class aligned_allocator {
    static_assert(detail::is_alignment_constant<Alignment>::value, "detail::is_alignment_constant<Alignment>::value");

public:
    typedef T value_type;
    typedef T* pointer;
    typedef const T* const_pointer;
    typedef void* void_pointer;
    typedef const void* const_void_pointer;
    typedef typename detail::add_lvalue_reference<T>::type reference;
    typedef typename detail::add_lvalue_reference<const
        T>::type const_reference;
    typedef std::size_t size_type;
    typedef std::ptrdiff_t difference_type;
    typedef detail::true_type propagate_on_container_move_assignment;
    typedef detail::true_type is_always_equal;

    template<class U>
    struct rebind {
        typedef aligned_allocator<U, Alignment> other;
    };


    aligned_allocator() = default;




    template<class U>
    aligned_allocator(const aligned_allocator<U, Alignment>&)
        noexcept { }

    pointer allocate(size_type size, const_void_pointer = 0) {
        enum {
            m = detail::max_size<Alignment,
                alignment_of<value_type>::value>::value
        };
        if (size == 0) {
            return 0;
        }
        void* p = boost::alignment::aligned_alloc(m, sizeof(T) * size);
        if (!p) {
            detail::throw_exception(std::bad_alloc());
        }
        return static_cast<T*>(p);
    }

    void deallocate(pointer ptr, size_type) {
        boost::alignment::aligned_free(ptr);
    }

    constexpr size_type max_size() const noexcept {
        return detail::max_objects<T>::value;
    }



    template<class U, class... Args>
    void construct(U* ptr, Args&&... args) {
        ::new((void*)ptr) U(std::forward<Args>(args)...);
    }
# 109 "/usr/include/boost/align/aligned_allocator.hpp" 3 4
    template<class U>
    void construct(U* ptr) {
        ::new((void*)ptr) U();
    }

    template<class U>
    void destroy(U* ptr) {
        (void)ptr;
        ptr->~U();
    }
};

template<class T, class U, std::size_t Alignment>
inline bool
operator==(const aligned_allocator<T, Alignment>&,
    const aligned_allocator<U, Alignment>&) noexcept
{
    return true;
}

template<class T, class U, std::size_t Alignment>
inline bool
operator!=(const aligned_allocator<T, Alignment>&,
    const aligned_allocator<U, Alignment>&) noexcept
{
    return false;
}

}
}
# 13 "/usr/include/boost/lockfree/detail/parameter.hpp" 2 3 4

# 1 "/usr/include/boost/lockfree/detail/prefix.hpp" 1 3 4
# 24 "/usr/include/boost/lockfree/detail/prefix.hpp" 3 4
# 1 "/usr/include/boost/predef.h" 1 3 4
# 13 "/usr/include/boost/predef.h" 3 4
# 1 "/usr/include/boost/predef/language.h" 1 3 4
# 13 "/usr/include/boost/predef/language.h" 3 4
# 1 "/usr/include/boost/predef/language/stdc.h" 1 3 4
# 11 "/usr/include/boost/predef/language/stdc.h" 3 4
# 1 "/usr/include/boost/predef/version_number.h" 1 3 4
# 12 "/usr/include/boost/predef/language/stdc.h" 2 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4






# 1 "/usr/include/boost/predef/detail/test.h" 1 3 4
# 8 "/usr/include/boost/predef/make.h" 2 3 4
# 13 "/usr/include/boost/predef/language/stdc.h" 2 3 4
# 14 "/usr/include/boost/predef/language.h" 2 3 4
# 1 "/usr/include/boost/predef/language/stdcpp.h" 1 3 4
# 12 "/usr/include/boost/predef/language/stdcpp.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/language/stdcpp.h" 2 3 4
# 15 "/usr/include/boost/predef/language.h" 2 3 4
# 1 "/usr/include/boost/predef/language/objc.h" 1 3 4
# 12 "/usr/include/boost/predef/language/objc.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/language/objc.h" 2 3 4
# 16 "/usr/include/boost/predef/language.h" 2 3 4
# 1 "/usr/include/boost/predef/language/cuda.h" 1 3 4
# 12 "/usr/include/boost/predef/language/cuda.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/language/cuda.h" 2 3 4
# 17 "/usr/include/boost/predef/language.h" 2 3 4
# 14 "/usr/include/boost/predef.h" 2 3 4
# 1 "/usr/include/boost/predef/architecture.h" 1 3 4
# 13 "/usr/include/boost/predef/architecture.h" 3 4
# 1 "/usr/include/boost/predef/architecture/alpha.h" 1 3 4
# 12 "/usr/include/boost/predef/architecture/alpha.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/architecture/alpha.h" 2 3 4
# 14 "/usr/include/boost/predef/architecture.h" 2 3 4
# 1 "/usr/include/boost/predef/architecture/arm.h" 1 3 4
# 14 "/usr/include/boost/predef/architecture/arm.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 15 "/usr/include/boost/predef/architecture/arm.h" 2 3 4
# 15 "/usr/include/boost/predef/architecture.h" 2 3 4
# 1 "/usr/include/boost/predef/architecture/blackfin.h" 1 3 4
# 12 "/usr/include/boost/predef/architecture/blackfin.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/architecture/blackfin.h" 2 3 4
# 16 "/usr/include/boost/predef/architecture.h" 2 3 4
# 1 "/usr/include/boost/predef/architecture/convex.h" 1 3 4
# 12 "/usr/include/boost/predef/architecture/convex.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/architecture/convex.h" 2 3 4
# 17 "/usr/include/boost/predef/architecture.h" 2 3 4
# 1 "/usr/include/boost/predef/architecture/e2k.h" 1 3 4
# 12 "/usr/include/boost/predef/architecture/e2k.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/architecture/e2k.h" 2 3 4
# 18 "/usr/include/boost/predef/architecture.h" 2 3 4
# 1 "/usr/include/boost/predef/architecture/ia64.h" 1 3 4
# 12 "/usr/include/boost/predef/architecture/ia64.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/architecture/ia64.h" 2 3 4
# 19 "/usr/include/boost/predef/architecture.h" 2 3 4
# 1 "/usr/include/boost/predef/architecture/loongarch.h" 1 3 4
# 12 "/usr/include/boost/predef/architecture/loongarch.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/architecture/loongarch.h" 2 3 4
# 20 "/usr/include/boost/predef/architecture.h" 2 3 4
# 1 "/usr/include/boost/predef/architecture/m68k.h" 1 3 4
# 12 "/usr/include/boost/predef/architecture/m68k.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/architecture/m68k.h" 2 3 4
# 21 "/usr/include/boost/predef/architecture.h" 2 3 4
# 1 "/usr/include/boost/predef/architecture/mips.h" 1 3 4
# 12 "/usr/include/boost/predef/architecture/mips.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/architecture/mips.h" 2 3 4
# 22 "/usr/include/boost/predef/architecture.h" 2 3 4
# 1 "/usr/include/boost/predef/architecture/parisc.h" 1 3 4
# 12 "/usr/include/boost/predef/architecture/parisc.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/architecture/parisc.h" 2 3 4
# 23 "/usr/include/boost/predef/architecture.h" 2 3 4
# 1 "/usr/include/boost/predef/architecture/ppc.h" 1 3 4
# 12 "/usr/include/boost/predef/architecture/ppc.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/architecture/ppc.h" 2 3 4
# 24 "/usr/include/boost/predef/architecture.h" 2 3 4
# 1 "/usr/include/boost/predef/architecture/ptx.h" 1 3 4
# 12 "/usr/include/boost/predef/architecture/ptx.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/architecture/ptx.h" 2 3 4
# 25 "/usr/include/boost/predef/architecture.h" 2 3 4
# 1 "/usr/include/boost/predef/architecture/pyramid.h" 1 3 4
# 12 "/usr/include/boost/predef/architecture/pyramid.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/architecture/pyramid.h" 2 3 4
# 26 "/usr/include/boost/predef/architecture.h" 2 3 4
# 1 "/usr/include/boost/predef/architecture/riscv.h" 1 3 4
# 12 "/usr/include/boost/predef/architecture/riscv.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/architecture/riscv.h" 2 3 4
# 27 "/usr/include/boost/predef/architecture.h" 2 3 4
# 1 "/usr/include/boost/predef/architecture/rs6k.h" 1 3 4
# 12 "/usr/include/boost/predef/architecture/rs6k.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/architecture/rs6k.h" 2 3 4
# 28 "/usr/include/boost/predef/architecture.h" 2 3 4
# 1 "/usr/include/boost/predef/architecture/sparc.h" 1 3 4
# 12 "/usr/include/boost/predef/architecture/sparc.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/architecture/sparc.h" 2 3 4
# 29 "/usr/include/boost/predef/architecture.h" 2 3 4
# 1 "/usr/include/boost/predef/architecture/superh.h" 1 3 4
# 12 "/usr/include/boost/predef/architecture/superh.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/architecture/superh.h" 2 3 4
# 30 "/usr/include/boost/predef/architecture.h" 2 3 4
# 1 "/usr/include/boost/predef/architecture/sys370.h" 1 3 4
# 12 "/usr/include/boost/predef/architecture/sys370.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/architecture/sys370.h" 2 3 4
# 31 "/usr/include/boost/predef/architecture.h" 2 3 4
# 1 "/usr/include/boost/predef/architecture/sys390.h" 1 3 4
# 12 "/usr/include/boost/predef/architecture/sys390.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/architecture/sys390.h" 2 3 4
# 32 "/usr/include/boost/predef/architecture.h" 2 3 4
# 1 "/usr/include/boost/predef/architecture/x86.h" 1 3 4







# 1 "/usr/include/boost/predef/architecture/x86/32.h" 1 3 4
# 12 "/usr/include/boost/predef/architecture/x86/32.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/architecture/x86/32.h" 2 3 4
# 88 "/usr/include/boost/predef/architecture/x86/32.h" 3 4
# 1 "/usr/include/boost/predef/architecture/x86.h" 1 3 4







# 1 "/usr/include/boost/predef/architecture/x86/32.h" 1 3 4
# 9 "/usr/include/boost/predef/architecture/x86.h" 2 3 4
# 1 "/usr/include/boost/predef/architecture/x86/64.h" 1 3 4
# 12 "/usr/include/boost/predef/architecture/x86/64.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/architecture/x86/64.h" 2 3 4
# 51 "/usr/include/boost/predef/architecture/x86/64.h" 3 4
# 1 "/usr/include/boost/predef/architecture/x86.h" 1 3 4







# 1 "/usr/include/boost/predef/architecture/x86/32.h" 1 3 4
# 9 "/usr/include/boost/predef/architecture/x86.h" 2 3 4
# 1 "/usr/include/boost/predef/architecture/x86/64.h" 1 3 4
# 10 "/usr/include/boost/predef/architecture/x86.h" 2 3 4
# 52 "/usr/include/boost/predef/architecture/x86/64.h" 2 3 4
# 10 "/usr/include/boost/predef/architecture/x86.h" 2 3 4
# 89 "/usr/include/boost/predef/architecture/x86/32.h" 2 3 4
# 9 "/usr/include/boost/predef/architecture/x86.h" 2 3 4
# 1 "/usr/include/boost/predef/architecture/x86/64.h" 1 3 4
# 10 "/usr/include/boost/predef/architecture/x86.h" 2 3 4
# 33 "/usr/include/boost/predef/architecture.h" 2 3 4
# 1 "/usr/include/boost/predef/architecture/z.h" 1 3 4
# 12 "/usr/include/boost/predef/architecture/z.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/architecture/z.h" 2 3 4
# 34 "/usr/include/boost/predef/architecture.h" 2 3 4
# 15 "/usr/include/boost/predef.h" 2 3 4
# 1 "/usr/include/boost/predef/compiler.h" 1 3 4
# 13 "/usr/include/boost/predef/compiler.h" 3 4
# 1 "/usr/include/boost/predef/compiler/borland.h" 1 3 4
# 12 "/usr/include/boost/predef/compiler/borland.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/compiler/borland.h" 2 3 4
# 14 "/usr/include/boost/predef/compiler.h" 2 3 4
# 1 "/usr/include/boost/predef/compiler/clang.h" 1 3 4
# 12 "/usr/include/boost/predef/compiler/clang.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/compiler/clang.h" 2 3 4
# 44 "/usr/include/boost/predef/compiler/clang.h" 3 4
# 1 "/usr/include/boost/predef/detail/comp_detected.h" 1 3 4
# 45 "/usr/include/boost/predef/compiler/clang.h" 2 3 4
# 15 "/usr/include/boost/predef/compiler.h" 2 3 4
# 1 "/usr/include/boost/predef/compiler/comeau.h" 1 3 4
# 12 "/usr/include/boost/predef/compiler/comeau.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/compiler/comeau.h" 2 3 4
# 16 "/usr/include/boost/predef/compiler.h" 2 3 4
# 1 "/usr/include/boost/predef/compiler/compaq.h" 1 3 4
# 12 "/usr/include/boost/predef/compiler/compaq.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/compiler/compaq.h" 2 3 4
# 17 "/usr/include/boost/predef/compiler.h" 2 3 4
# 1 "/usr/include/boost/predef/compiler/diab.h" 1 3 4
# 12 "/usr/include/boost/predef/compiler/diab.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/compiler/diab.h" 2 3 4
# 18 "/usr/include/boost/predef/compiler.h" 2 3 4
# 1 "/usr/include/boost/predef/compiler/digitalmars.h" 1 3 4
# 12 "/usr/include/boost/predef/compiler/digitalmars.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/compiler/digitalmars.h" 2 3 4
# 19 "/usr/include/boost/predef/compiler.h" 2 3 4
# 1 "/usr/include/boost/predef/compiler/dignus.h" 1 3 4
# 12 "/usr/include/boost/predef/compiler/dignus.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/compiler/dignus.h" 2 3 4
# 20 "/usr/include/boost/predef/compiler.h" 2 3 4
# 1 "/usr/include/boost/predef/compiler/edg.h" 1 3 4
# 12 "/usr/include/boost/predef/compiler/edg.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/compiler/edg.h" 2 3 4
# 21 "/usr/include/boost/predef/compiler.h" 2 3 4
# 1 "/usr/include/boost/predef/compiler/ekopath.h" 1 3 4
# 12 "/usr/include/boost/predef/compiler/ekopath.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/compiler/ekopath.h" 2 3 4
# 22 "/usr/include/boost/predef/compiler.h" 2 3 4
# 1 "/usr/include/boost/predef/compiler/gcc_xml.h" 1 3 4
# 12 "/usr/include/boost/predef/compiler/gcc_xml.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/compiler/gcc_xml.h" 2 3 4
# 23 "/usr/include/boost/predef/compiler.h" 2 3 4
# 1 "/usr/include/boost/predef/compiler/gcc.h" 1 3 4
# 13 "/usr/include/boost/predef/compiler/gcc.h" 3 4
# 1 "/usr/include/boost/predef/compiler/clang.h" 1 3 4
# 14 "/usr/include/boost/predef/compiler/gcc.h" 2 3 4


# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 17 "/usr/include/boost/predef/compiler/gcc.h" 2 3 4
# 24 "/usr/include/boost/predef/compiler.h" 2 3 4
# 1 "/usr/include/boost/predef/compiler/greenhills.h" 1 3 4
# 12 "/usr/include/boost/predef/compiler/greenhills.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/compiler/greenhills.h" 2 3 4
# 25 "/usr/include/boost/predef/compiler.h" 2 3 4
# 1 "/usr/include/boost/predef/compiler/hp_acc.h" 1 3 4
# 12 "/usr/include/boost/predef/compiler/hp_acc.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/compiler/hp_acc.h" 2 3 4
# 26 "/usr/include/boost/predef/compiler.h" 2 3 4
# 1 "/usr/include/boost/predef/compiler/iar.h" 1 3 4
# 12 "/usr/include/boost/predef/compiler/iar.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/compiler/iar.h" 2 3 4
# 27 "/usr/include/boost/predef/compiler.h" 2 3 4
# 1 "/usr/include/boost/predef/compiler/ibm.h" 1 3 4
# 12 "/usr/include/boost/predef/compiler/ibm.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/compiler/ibm.h" 2 3 4
# 28 "/usr/include/boost/predef/compiler.h" 2 3 4
# 1 "/usr/include/boost/predef/compiler/intel.h" 1 3 4
# 12 "/usr/include/boost/predef/compiler/intel.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/compiler/intel.h" 2 3 4
# 29 "/usr/include/boost/predef/compiler.h" 2 3 4
# 1 "/usr/include/boost/predef/compiler/kai.h" 1 3 4
# 12 "/usr/include/boost/predef/compiler/kai.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/compiler/kai.h" 2 3 4
# 30 "/usr/include/boost/predef/compiler.h" 2 3 4
# 1 "/usr/include/boost/predef/compiler/llvm.h" 1 3 4
# 13 "/usr/include/boost/predef/compiler/llvm.h" 3 4
# 1 "/usr/include/boost/predef/compiler/clang.h" 1 3 4
# 14 "/usr/include/boost/predef/compiler/llvm.h" 2 3 4


# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 17 "/usr/include/boost/predef/compiler/llvm.h" 2 3 4
# 31 "/usr/include/boost/predef/compiler.h" 2 3 4
# 1 "/usr/include/boost/predef/compiler/metaware.h" 1 3 4
# 12 "/usr/include/boost/predef/compiler/metaware.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/compiler/metaware.h" 2 3 4
# 32 "/usr/include/boost/predef/compiler.h" 2 3 4
# 1 "/usr/include/boost/predef/compiler/metrowerks.h" 1 3 4
# 12 "/usr/include/boost/predef/compiler/metrowerks.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/compiler/metrowerks.h" 2 3 4
# 33 "/usr/include/boost/predef/compiler.h" 2 3 4
# 1 "/usr/include/boost/predef/compiler/microtec.h" 1 3 4
# 12 "/usr/include/boost/predef/compiler/microtec.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/compiler/microtec.h" 2 3 4
# 34 "/usr/include/boost/predef/compiler.h" 2 3 4
# 1 "/usr/include/boost/predef/compiler/mpw.h" 1 3 4
# 12 "/usr/include/boost/predef/compiler/mpw.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/compiler/mpw.h" 2 3 4
# 35 "/usr/include/boost/predef/compiler.h" 2 3 4
# 1 "/usr/include/boost/predef/compiler/nvcc.h" 1 3 4
# 12 "/usr/include/boost/predef/compiler/nvcc.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/compiler/nvcc.h" 2 3 4
# 36 "/usr/include/boost/predef/compiler.h" 2 3 4
# 1 "/usr/include/boost/predef/compiler/palm.h" 1 3 4
# 12 "/usr/include/boost/predef/compiler/palm.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/compiler/palm.h" 2 3 4
# 37 "/usr/include/boost/predef/compiler.h" 2 3 4
# 1 "/usr/include/boost/predef/compiler/pgi.h" 1 3 4
# 12 "/usr/include/boost/predef/compiler/pgi.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/compiler/pgi.h" 2 3 4
# 38 "/usr/include/boost/predef/compiler.h" 2 3 4
# 1 "/usr/include/boost/predef/compiler/sgi_mipspro.h" 1 3 4
# 12 "/usr/include/boost/predef/compiler/sgi_mipspro.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/compiler/sgi_mipspro.h" 2 3 4
# 39 "/usr/include/boost/predef/compiler.h" 2 3 4
# 1 "/usr/include/boost/predef/compiler/sunpro.h" 1 3 4
# 12 "/usr/include/boost/predef/compiler/sunpro.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/compiler/sunpro.h" 2 3 4
# 40 "/usr/include/boost/predef/compiler.h" 2 3 4
# 1 "/usr/include/boost/predef/compiler/tendra.h" 1 3 4
# 12 "/usr/include/boost/predef/compiler/tendra.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/compiler/tendra.h" 2 3 4
# 41 "/usr/include/boost/predef/compiler.h" 2 3 4
# 1 "/usr/include/boost/predef/compiler/visualc.h" 1 3 4
# 13 "/usr/include/boost/predef/compiler/visualc.h" 3 4
# 1 "/usr/include/boost/predef/compiler/clang.h" 1 3 4
# 14 "/usr/include/boost/predef/compiler/visualc.h" 2 3 4


# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 17 "/usr/include/boost/predef/compiler/visualc.h" 2 3 4
# 42 "/usr/include/boost/predef/compiler.h" 2 3 4
# 1 "/usr/include/boost/predef/compiler/watcom.h" 1 3 4
# 12 "/usr/include/boost/predef/compiler/watcom.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/compiler/watcom.h" 2 3 4
# 43 "/usr/include/boost/predef/compiler.h" 2 3 4
# 16 "/usr/include/boost/predef.h" 2 3 4
# 1 "/usr/include/boost/predef/library.h" 1 3 4
# 13 "/usr/include/boost/predef/library.h" 3 4
# 1 "/usr/include/boost/predef/library/c.h" 1 3 4
# 13 "/usr/include/boost/predef/library/c.h" 3 4
# 1 "/usr/include/boost/predef/library/c/_prefix.h" 1 3 4
# 11 "/usr/include/boost/predef/library/c/_prefix.h" 3 4
# 1 "/usr/include/boost/predef/detail/_cassert.h" 1 3 4
# 12 "/usr/include/boost/predef/detail/_cassert.h" 3 4
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 1 3 4
# 42 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 3


# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 45 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 2 3
# 13 "/usr/include/boost/predef/detail/_cassert.h" 2 3 4
# 12 "/usr/include/boost/predef/library/c/_prefix.h" 2 3 4
# 14 "/usr/include/boost/predef/library/c.h" 2 3 4

# 1 "/usr/include/boost/predef/library/c/cloudabi.h" 1 3 4
# 13 "/usr/include/boost/predef/library/c/cloudabi.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 14 "/usr/include/boost/predef/library/c/cloudabi.h" 2 3 4
# 16 "/usr/include/boost/predef/library/c.h" 2 3 4
# 1 "/usr/include/boost/predef/library/c/gnu.h" 1 3 4
# 12 "/usr/include/boost/predef/library/c/gnu.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/library/c/gnu.h" 2 3 4




# 1 "/usr/bin/../lib/clang/18/include/stddef.h" 1 3 4
# 72 "/usr/bin/../lib/clang/18/include/stddef.h" 3 4
# 1 "/usr/bin/../lib/clang/18/include/__stddef_ptrdiff_t.h" 1 3 4
# 18 "/usr/bin/../lib/clang/18/include/__stddef_ptrdiff_t.h" 3 4
typedef long int ptrdiff_t;
# 73 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3 4




# 1 "/usr/bin/../lib/clang/18/include/__stddef_size_t.h" 1 3 4
# 18 "/usr/bin/../lib/clang/18/include/__stddef_size_t.h" 3 4
typedef long unsigned int size_t;
# 78 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3 4
# 87 "/usr/bin/../lib/clang/18/include/stddef.h" 3 4
# 1 "/usr/bin/../lib/clang/18/include/__stddef_wchar_t.h" 1 3 4
# 88 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3 4




# 1 "/usr/bin/../lib/clang/18/include/__stddef_null.h" 1 3 4
# 93 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3 4




# 1 "/usr/bin/../lib/clang/18/include/__stddef_nullptr_t.h" 1 3 4
# 98 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3 4
# 112 "/usr/bin/../lib/clang/18/include/stddef.h" 3 4
# 1 "/usr/bin/../lib/clang/18/include/__stddef_offsetof.h" 1 3 4
# 113 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3 4
# 18 "/usr/include/boost/predef/library/c/gnu.h" 2 3 4
# 17 "/usr/include/boost/predef/library/c.h" 2 3 4
# 1 "/usr/include/boost/predef/library/c/uc.h" 1 3 4
# 14 "/usr/include/boost/predef/library/c/uc.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 15 "/usr/include/boost/predef/library/c/uc.h" 2 3 4
# 18 "/usr/include/boost/predef/library/c.h" 2 3 4
# 1 "/usr/include/boost/predef/library/c/vms.h" 1 3 4
# 14 "/usr/include/boost/predef/library/c/vms.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 15 "/usr/include/boost/predef/library/c/vms.h" 2 3 4
# 19 "/usr/include/boost/predef/library/c.h" 2 3 4
# 1 "/usr/include/boost/predef/library/c/zos.h" 1 3 4
# 14 "/usr/include/boost/predef/library/c/zos.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 15 "/usr/include/boost/predef/library/c/zos.h" 2 3 4
# 20 "/usr/include/boost/predef/library/c.h" 2 3 4
# 14 "/usr/include/boost/predef/library.h" 2 3 4
# 1 "/usr/include/boost/predef/library/std.h" 1 3 4
# 12 "/usr/include/boost/predef/library/std.h" 3 4
# 1 "/usr/include/boost/predef/library/std/_prefix.h" 1 3 4
# 21 "/usr/include/boost/predef/library/std/_prefix.h" 3 4
# 1 "/usr/include/boost/predef/detail/_exception.h" 1 3 4
# 22 "/usr/include/boost/predef/library/std/_prefix.h" 2 3 4
# 13 "/usr/include/boost/predef/library/std.h" 2 3 4

# 1 "/usr/include/boost/predef/library/std/cxx.h" 1 3 4
# 14 "/usr/include/boost/predef/library/std/cxx.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 15 "/usr/include/boost/predef/library/std/cxx.h" 2 3 4
# 15 "/usr/include/boost/predef/library/std.h" 2 3 4
# 1 "/usr/include/boost/predef/library/std/dinkumware.h" 1 3 4
# 14 "/usr/include/boost/predef/library/std/dinkumware.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 15 "/usr/include/boost/predef/library/std/dinkumware.h" 2 3 4
# 16 "/usr/include/boost/predef/library/std.h" 2 3 4
# 1 "/usr/include/boost/predef/library/std/libcomo.h" 1 3 4
# 14 "/usr/include/boost/predef/library/std/libcomo.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 15 "/usr/include/boost/predef/library/std/libcomo.h" 2 3 4
# 17 "/usr/include/boost/predef/library/std.h" 2 3 4
# 1 "/usr/include/boost/predef/library/std/modena.h" 1 3 4
# 14 "/usr/include/boost/predef/library/std/modena.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 15 "/usr/include/boost/predef/library/std/modena.h" 2 3 4
# 18 "/usr/include/boost/predef/library/std.h" 2 3 4
# 1 "/usr/include/boost/predef/library/std/msl.h" 1 3 4
# 14 "/usr/include/boost/predef/library/std/msl.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 15 "/usr/include/boost/predef/library/std/msl.h" 2 3 4
# 19 "/usr/include/boost/predef/library/std.h" 2 3 4
# 1 "/usr/include/boost/predef/library/std/roguewave.h" 1 3 4
# 14 "/usr/include/boost/predef/library/std/roguewave.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 15 "/usr/include/boost/predef/library/std/roguewave.h" 2 3 4
# 20 "/usr/include/boost/predef/library/std.h" 2 3 4
# 1 "/usr/include/boost/predef/library/std/sgi.h" 1 3 4
# 14 "/usr/include/boost/predef/library/std/sgi.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 15 "/usr/include/boost/predef/library/std/sgi.h" 2 3 4
# 21 "/usr/include/boost/predef/library/std.h" 2 3 4
# 1 "/usr/include/boost/predef/library/std/stdcpp3.h" 1 3 4
# 14 "/usr/include/boost/predef/library/std/stdcpp3.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 15 "/usr/include/boost/predef/library/std/stdcpp3.h" 2 3 4
# 22 "/usr/include/boost/predef/library/std.h" 2 3 4
# 1 "/usr/include/boost/predef/library/std/stlport.h" 1 3 4
# 14 "/usr/include/boost/predef/library/std/stlport.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 15 "/usr/include/boost/predef/library/std/stlport.h" 2 3 4
# 23 "/usr/include/boost/predef/library/std.h" 2 3 4
# 1 "/usr/include/boost/predef/library/std/vacpp.h" 1 3 4
# 14 "/usr/include/boost/predef/library/std/vacpp.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 15 "/usr/include/boost/predef/library/std/vacpp.h" 2 3 4
# 24 "/usr/include/boost/predef/library/std.h" 2 3 4
# 15 "/usr/include/boost/predef/library.h" 2 3 4
# 17 "/usr/include/boost/predef.h" 2 3 4
# 1 "/usr/include/boost/predef/os.h" 1 3 4
# 14 "/usr/include/boost/predef/os.h" 3 4
# 1 "/usr/include/boost/predef/os/aix.h" 1 3 4
# 12 "/usr/include/boost/predef/os/aix.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/os/aix.h" 2 3 4
# 15 "/usr/include/boost/predef/os.h" 2 3 4
# 1 "/usr/include/boost/predef/os/amigaos.h" 1 3 4
# 12 "/usr/include/boost/predef/os/amigaos.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/os/amigaos.h" 2 3 4
# 16 "/usr/include/boost/predef/os.h" 2 3 4
# 1 "/usr/include/boost/predef/os/beos.h" 1 3 4
# 12 "/usr/include/boost/predef/os/beos.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/os/beos.h" 2 3 4
# 17 "/usr/include/boost/predef/os.h" 2 3 4
# 1 "/usr/include/boost/predef/os/bsd.h" 1 3 4
# 16 "/usr/include/boost/predef/os/bsd.h" 3 4
# 1 "/usr/include/boost/predef/os/macos.h" 1 3 4
# 17 "/usr/include/boost/predef/os/macos.h" 3 4
# 1 "/usr/include/boost/predef/os/ios.h" 1 3 4
# 13 "/usr/include/boost/predef/os/ios.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 14 "/usr/include/boost/predef/os/ios.h" 2 3 4
# 18 "/usr/include/boost/predef/os/macos.h" 2 3 4


# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 21 "/usr/include/boost/predef/os/macos.h" 2 3 4
# 17 "/usr/include/boost/predef/os/bsd.h" 2 3 4


# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 20 "/usr/include/boost/predef/os/bsd.h" 2 3 4
# 53 "/usr/include/boost/predef/os/bsd.h" 3 4
# 1 "/usr/include/boost/predef/os/bsd/bsdi.h" 1 3 4
# 11 "/usr/include/boost/predef/os/bsd/bsdi.h" 3 4
# 1 "/usr/include/boost/predef/os/bsd.h" 1 3 4
# 95 "/usr/include/boost/predef/os/bsd.h" 3 4
# 1 "/usr/include/boost/predef/os/bsd/bsdi.h" 1 3 4
# 96 "/usr/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/usr/include/boost/predef/os/bsd/dragonfly.h" 1 3 4
# 11 "/usr/include/boost/predef/os/bsd/dragonfly.h" 3 4
# 1 "/usr/include/boost/predef/os/bsd.h" 1 3 4
# 95 "/usr/include/boost/predef/os/bsd.h" 3 4
# 1 "/usr/include/boost/predef/os/bsd/bsdi.h" 1 3 4
# 96 "/usr/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/usr/include/boost/predef/os/bsd/dragonfly.h" 1 3 4
# 97 "/usr/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/usr/include/boost/predef/os/bsd/free.h" 1 3 4
# 11 "/usr/include/boost/predef/os/bsd/free.h" 3 4
# 1 "/usr/include/boost/predef/os/bsd.h" 1 3 4
# 95 "/usr/include/boost/predef/os/bsd.h" 3 4
# 1 "/usr/include/boost/predef/os/bsd/bsdi.h" 1 3 4
# 96 "/usr/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/usr/include/boost/predef/os/bsd/dragonfly.h" 1 3 4
# 97 "/usr/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/usr/include/boost/predef/os/bsd/free.h" 1 3 4
# 98 "/usr/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/usr/include/boost/predef/os/bsd/open.h" 1 3 4
# 11 "/usr/include/boost/predef/os/bsd/open.h" 3 4
# 1 "/usr/include/boost/predef/os/bsd.h" 1 3 4
# 95 "/usr/include/boost/predef/os/bsd.h" 3 4
# 1 "/usr/include/boost/predef/os/bsd/bsdi.h" 1 3 4
# 96 "/usr/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/usr/include/boost/predef/os/bsd/dragonfly.h" 1 3 4
# 97 "/usr/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/usr/include/boost/predef/os/bsd/free.h" 1 3 4
# 98 "/usr/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/usr/include/boost/predef/os/bsd/open.h" 1 3 4
# 99 "/usr/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/usr/include/boost/predef/os/bsd/net.h" 1 3 4
# 11 "/usr/include/boost/predef/os/bsd/net.h" 3 4
# 1 "/usr/include/boost/predef/os/bsd.h" 1 3 4
# 95 "/usr/include/boost/predef/os/bsd.h" 3 4
# 1 "/usr/include/boost/predef/os/bsd/bsdi.h" 1 3 4
# 96 "/usr/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/usr/include/boost/predef/os/bsd/dragonfly.h" 1 3 4
# 97 "/usr/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/usr/include/boost/predef/os/bsd/free.h" 1 3 4
# 98 "/usr/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/usr/include/boost/predef/os/bsd/open.h" 1 3 4
# 99 "/usr/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/usr/include/boost/predef/os/bsd/net.h" 1 3 4
# 100 "/usr/include/boost/predef/os/bsd.h" 2 3 4
# 12 "/usr/include/boost/predef/os/bsd/net.h" 2 3 4
# 100 "/usr/include/boost/predef/os/bsd.h" 2 3 4
# 12 "/usr/include/boost/predef/os/bsd/open.h" 2 3 4
# 99 "/usr/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/usr/include/boost/predef/os/bsd/net.h" 1 3 4
# 100 "/usr/include/boost/predef/os/bsd.h" 2 3 4
# 12 "/usr/include/boost/predef/os/bsd/free.h" 2 3 4
# 98 "/usr/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/usr/include/boost/predef/os/bsd/open.h" 1 3 4
# 99 "/usr/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/usr/include/boost/predef/os/bsd/net.h" 1 3 4
# 100 "/usr/include/boost/predef/os/bsd.h" 2 3 4
# 12 "/usr/include/boost/predef/os/bsd/dragonfly.h" 2 3 4
# 97 "/usr/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/usr/include/boost/predef/os/bsd/free.h" 1 3 4
# 98 "/usr/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/usr/include/boost/predef/os/bsd/open.h" 1 3 4
# 99 "/usr/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/usr/include/boost/predef/os/bsd/net.h" 1 3 4
# 100 "/usr/include/boost/predef/os/bsd.h" 2 3 4
# 12 "/usr/include/boost/predef/os/bsd/bsdi.h" 2 3 4
# 54 "/usr/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/usr/include/boost/predef/os/bsd/dragonfly.h" 1 3 4
# 55 "/usr/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/usr/include/boost/predef/os/bsd/free.h" 1 3 4
# 56 "/usr/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/usr/include/boost/predef/os/bsd/open.h" 1 3 4
# 57 "/usr/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/usr/include/boost/predef/os/bsd/net.h" 1 3 4
# 58 "/usr/include/boost/predef/os/bsd.h" 2 3 4
# 95 "/usr/include/boost/predef/os/bsd.h" 3 4
# 1 "/usr/include/boost/predef/os/bsd/bsdi.h" 1 3 4
# 96 "/usr/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/usr/include/boost/predef/os/bsd/dragonfly.h" 1 3 4
# 97 "/usr/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/usr/include/boost/predef/os/bsd/free.h" 1 3 4
# 98 "/usr/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/usr/include/boost/predef/os/bsd/open.h" 1 3 4
# 99 "/usr/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/usr/include/boost/predef/os/bsd/net.h" 1 3 4
# 100 "/usr/include/boost/predef/os/bsd.h" 2 3 4
# 18 "/usr/include/boost/predef/os.h" 2 3 4
# 1 "/usr/include/boost/predef/os/cygwin.h" 1 3 4
# 12 "/usr/include/boost/predef/os/cygwin.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/os/cygwin.h" 2 3 4
# 19 "/usr/include/boost/predef/os.h" 2 3 4
# 1 "/usr/include/boost/predef/os/haiku.h" 1 3 4
# 13 "/usr/include/boost/predef/os/haiku.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 14 "/usr/include/boost/predef/os/haiku.h" 2 3 4
# 20 "/usr/include/boost/predef/os.h" 2 3 4
# 1 "/usr/include/boost/predef/os/hpux.h" 1 3 4
# 12 "/usr/include/boost/predef/os/hpux.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/os/hpux.h" 2 3 4
# 21 "/usr/include/boost/predef/os.h" 2 3 4
# 1 "/usr/include/boost/predef/os/irix.h" 1 3 4
# 12 "/usr/include/boost/predef/os/irix.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/os/irix.h" 2 3 4
# 22 "/usr/include/boost/predef/os.h" 2 3 4
# 1 "/usr/include/boost/predef/os/ios.h" 1 3 4
# 23 "/usr/include/boost/predef/os.h" 2 3 4
# 1 "/usr/include/boost/predef/os/linux.h" 1 3 4
# 12 "/usr/include/boost/predef/os/linux.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/os/linux.h" 2 3 4
# 42 "/usr/include/boost/predef/os/linux.h" 3 4
# 1 "/usr/include/boost/predef/detail/os_detected.h" 1 3 4
# 43 "/usr/include/boost/predef/os/linux.h" 2 3 4
# 24 "/usr/include/boost/predef/os.h" 2 3 4
# 1 "/usr/include/boost/predef/os/macos.h" 1 3 4
# 25 "/usr/include/boost/predef/os.h" 2 3 4
# 1 "/usr/include/boost/predef/os/os400.h" 1 3 4
# 12 "/usr/include/boost/predef/os/os400.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/os/os400.h" 2 3 4
# 26 "/usr/include/boost/predef/os.h" 2 3 4
# 1 "/usr/include/boost/predef/os/qnxnto.h" 1 3 4
# 12 "/usr/include/boost/predef/os/qnxnto.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/os/qnxnto.h" 2 3 4
# 27 "/usr/include/boost/predef/os.h" 2 3 4
# 1 "/usr/include/boost/predef/os/solaris.h" 1 3 4
# 12 "/usr/include/boost/predef/os/solaris.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/os/solaris.h" 2 3 4
# 28 "/usr/include/boost/predef/os.h" 2 3 4
# 1 "/usr/include/boost/predef/os/unix.h" 1 3 4
# 12 "/usr/include/boost/predef/os/unix.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/os/unix.h" 2 3 4
# 29 "/usr/include/boost/predef/os.h" 2 3 4
# 1 "/usr/include/boost/predef/os/vms.h" 1 3 4
# 12 "/usr/include/boost/predef/os/vms.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/os/vms.h" 2 3 4
# 30 "/usr/include/boost/predef/os.h" 2 3 4
# 1 "/usr/include/boost/predef/os/windows.h" 1 3 4
# 12 "/usr/include/boost/predef/os/windows.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/os/windows.h" 2 3 4
# 31 "/usr/include/boost/predef/os.h" 2 3 4
# 18 "/usr/include/boost/predef.h" 2 3 4
# 1 "/usr/include/boost/predef/other.h" 1 3 4
# 13 "/usr/include/boost/predef/other.h" 3 4
# 1 "/usr/include/boost/predef/other/endian.h" 1 3 4
# 12 "/usr/include/boost/predef/other/endian.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/other/endian.h" 2 3 4
# 1 "/usr/include/boost/predef/library/c/gnu.h" 1 3 4
# 14 "/usr/include/boost/predef/other/endian.h" 2 3 4
# 1 "/usr/include/boost/predef/os/macos.h" 1 3 4
# 15 "/usr/include/boost/predef/other/endian.h" 2 3 4
# 1 "/usr/include/boost/predef/os/bsd.h" 1 3 4
# 95 "/usr/include/boost/predef/os/bsd.h" 3 4
# 1 "/usr/include/boost/predef/os/bsd/bsdi.h" 1 3 4
# 96 "/usr/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/usr/include/boost/predef/os/bsd/dragonfly.h" 1 3 4
# 97 "/usr/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/usr/include/boost/predef/os/bsd/free.h" 1 3 4
# 98 "/usr/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/usr/include/boost/predef/os/bsd/open.h" 1 3 4
# 99 "/usr/include/boost/predef/os/bsd.h" 2 3 4
# 1 "/usr/include/boost/predef/os/bsd/net.h" 1 3 4
# 100 "/usr/include/boost/predef/os/bsd.h" 2 3 4
# 16 "/usr/include/boost/predef/other/endian.h" 2 3 4
# 1 "/usr/include/boost/predef/platform/android.h" 1 3 4
# 12 "/usr/include/boost/predef/platform/android.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/platform/android.h" 2 3 4
# 17 "/usr/include/boost/predef/other/endian.h" 2 3 4
# 14 "/usr/include/boost/predef/other.h" 2 3 4
# 1 "/usr/include/boost/predef/other/wordsize.h" 1 3 4
# 11 "/usr/include/boost/predef/other/wordsize.h" 3 4
# 1 "/usr/include/boost/predef/architecture.h" 1 3 4
# 12 "/usr/include/boost/predef/other/wordsize.h" 2 3 4

# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 14 "/usr/include/boost/predef/other/wordsize.h" 2 3 4
# 15 "/usr/include/boost/predef/other.h" 2 3 4
# 1 "/usr/include/boost/predef/other/workaround.h" 1 3 4
# 16 "/usr/include/boost/predef/other.h" 2 3 4
# 19 "/usr/include/boost/predef.h" 2 3 4
# 1 "/usr/include/boost/predef/platform.h" 1 3 4
# 14 "/usr/include/boost/predef/platform.h" 3 4
# 1 "/usr/include/boost/predef/platform/android.h" 1 3 4
# 15 "/usr/include/boost/predef/platform.h" 2 3 4
# 1 "/usr/include/boost/predef/platform/cloudabi.h" 1 3 4
# 12 "/usr/include/boost/predef/platform/cloudabi.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/platform/cloudabi.h" 2 3 4
# 16 "/usr/include/boost/predef/platform.h" 2 3 4
# 1 "/usr/include/boost/predef/platform/mingw.h" 1 3 4
# 12 "/usr/include/boost/predef/platform/mingw.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/platform/mingw.h" 2 3 4
# 17 "/usr/include/boost/predef/platform.h" 2 3 4
# 1 "/usr/include/boost/predef/platform/mingw32.h" 1 3 4
# 12 "/usr/include/boost/predef/platform/mingw32.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/platform/mingw32.h" 2 3 4
# 18 "/usr/include/boost/predef/platform.h" 2 3 4
# 1 "/usr/include/boost/predef/platform/mingw64.h" 1 3 4
# 12 "/usr/include/boost/predef/platform/mingw64.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/platform/mingw64.h" 2 3 4
# 19 "/usr/include/boost/predef/platform.h" 2 3 4
# 1 "/usr/include/boost/predef/platform/windows_uwp.h" 1 3 4
# 11 "/usr/include/boost/predef/platform/windows_uwp.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 12 "/usr/include/boost/predef/platform/windows_uwp.h" 2 3 4
# 1 "/usr/include/boost/predef/os/windows.h" 1 3 4
# 13 "/usr/include/boost/predef/platform/windows_uwp.h" 2 3 4
# 20 "/usr/include/boost/predef/platform.h" 2 3 4
# 1 "/usr/include/boost/predef/platform/windows_desktop.h" 1 3 4
# 12 "/usr/include/boost/predef/platform/windows_desktop.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/platform/windows_desktop.h" 2 3 4
# 1 "/usr/include/boost/predef/os/windows.h" 1 3 4
# 14 "/usr/include/boost/predef/platform/windows_desktop.h" 2 3 4
# 1 "/usr/include/boost/predef/platform/windows_uwp.h" 1 3 4
# 15 "/usr/include/boost/predef/platform/windows_desktop.h" 2 3 4
# 21 "/usr/include/boost/predef/platform.h" 2 3 4
# 1 "/usr/include/boost/predef/platform/windows_phone.h" 1 3 4
# 12 "/usr/include/boost/predef/platform/windows_phone.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/platform/windows_phone.h" 2 3 4
# 1 "/usr/include/boost/predef/os/windows.h" 1 3 4
# 14 "/usr/include/boost/predef/platform/windows_phone.h" 2 3 4
# 1 "/usr/include/boost/predef/platform/windows_uwp.h" 1 3 4
# 15 "/usr/include/boost/predef/platform/windows_phone.h" 2 3 4
# 22 "/usr/include/boost/predef/platform.h" 2 3 4
# 1 "/usr/include/boost/predef/platform/windows_server.h" 1 3 4
# 11 "/usr/include/boost/predef/platform/windows_server.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 12 "/usr/include/boost/predef/platform/windows_server.h" 2 3 4
# 1 "/usr/include/boost/predef/os/windows.h" 1 3 4
# 13 "/usr/include/boost/predef/platform/windows_server.h" 2 3 4
# 1 "/usr/include/boost/predef/platform/windows_uwp.h" 1 3 4
# 14 "/usr/include/boost/predef/platform/windows_server.h" 2 3 4
# 23 "/usr/include/boost/predef/platform.h" 2 3 4
# 1 "/usr/include/boost/predef/platform/windows_store.h" 1 3 4
# 12 "/usr/include/boost/predef/platform/windows_store.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/platform/windows_store.h" 2 3 4
# 1 "/usr/include/boost/predef/os/windows.h" 1 3 4
# 14 "/usr/include/boost/predef/platform/windows_store.h" 2 3 4
# 1 "/usr/include/boost/predef/platform/windows_uwp.h" 1 3 4
# 15 "/usr/include/boost/predef/platform/windows_store.h" 2 3 4
# 24 "/usr/include/boost/predef/platform.h" 2 3 4
# 1 "/usr/include/boost/predef/platform/windows_system.h" 1 3 4
# 11 "/usr/include/boost/predef/platform/windows_system.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 12 "/usr/include/boost/predef/platform/windows_system.h" 2 3 4
# 1 "/usr/include/boost/predef/os/windows.h" 1 3 4
# 13 "/usr/include/boost/predef/platform/windows_system.h" 2 3 4
# 1 "/usr/include/boost/predef/platform/windows_uwp.h" 1 3 4
# 14 "/usr/include/boost/predef/platform/windows_system.h" 2 3 4
# 25 "/usr/include/boost/predef/platform.h" 2 3 4
# 1 "/usr/include/boost/predef/platform/windows_runtime.h" 1 3 4
# 12 "/usr/include/boost/predef/platform/windows_runtime.h" 3 4
# 1 "/usr/include/boost/predef/make.h" 1 3 4
# 13 "/usr/include/boost/predef/platform/windows_runtime.h" 2 3 4
# 1 "/usr/include/boost/predef/os/windows.h" 1 3 4
# 14 "/usr/include/boost/predef/platform/windows_runtime.h" 2 3 4
# 1 "/usr/include/boost/predef/platform/windows_phone.h" 1 3 4
# 15 "/usr/include/boost/predef/platform/windows_runtime.h" 2 3 4
# 1 "/usr/include/boost/predef/platform/windows_store.h" 1 3 4
# 16 "/usr/include/boost/predef/platform/windows_runtime.h" 2 3 4
# 26 "/usr/include/boost/predef/platform.h" 2 3 4
# 1 "/usr/include/boost/predef/platform/ios.h" 1 3 4
# 12 "/usr/include/boost/predef/platform/ios.h" 3 4
# 1 "/usr/include/boost/predef/os/ios.h" 1 3 4
# 13 "/usr/include/boost/predef/platform/ios.h" 2 3 4
# 27 "/usr/include/boost/predef/platform.h" 2 3 4
# 20 "/usr/include/boost/predef.h" 2 3 4
# 1 "/usr/include/boost/predef/hardware.h" 1 3 4
# 14 "/usr/include/boost/predef/hardware.h" 3 4
# 1 "/usr/include/boost/predef/hardware/simd.h" 1 3 4








# 1 "/usr/include/boost/predef/hardware/simd/x86.h" 1 3 4
# 13 "/usr/include/boost/predef/hardware/simd/x86.h" 3 4
# 1 "/usr/include/boost/predef/hardware/simd/x86/versions.h" 1 3 4
# 14 "/usr/include/boost/predef/hardware/simd/x86.h" 2 3 4
# 10 "/usr/include/boost/predef/hardware/simd.h" 2 3 4
# 1 "/usr/include/boost/predef/hardware/simd/x86_amd.h" 1 3 4
# 13 "/usr/include/boost/predef/hardware/simd/x86_amd.h" 3 4
# 1 "/usr/include/boost/predef/hardware/simd/x86_amd/versions.h" 1 3 4
# 14 "/usr/include/boost/predef/hardware/simd/x86_amd.h" 2 3 4
# 11 "/usr/include/boost/predef/hardware/simd.h" 2 3 4
# 1 "/usr/include/boost/predef/hardware/simd/arm.h" 1 3 4
# 13 "/usr/include/boost/predef/hardware/simd/arm.h" 3 4
# 1 "/usr/include/boost/predef/hardware/simd/arm/versions.h" 1 3 4
# 14 "/usr/include/boost/predef/hardware/simd/arm.h" 2 3 4
# 12 "/usr/include/boost/predef/hardware/simd.h" 2 3 4
# 1 "/usr/include/boost/predef/hardware/simd/ppc.h" 1 3 4
# 13 "/usr/include/boost/predef/hardware/simd/ppc.h" 3 4
# 1 "/usr/include/boost/predef/hardware/simd/ppc/versions.h" 1 3 4
# 14 "/usr/include/boost/predef/hardware/simd/ppc.h" 2 3 4
# 13 "/usr/include/boost/predef/hardware/simd.h" 2 3 4
# 15 "/usr/include/boost/predef/hardware.h" 2 3 4
# 21 "/usr/include/boost/predef.h" 2 3 4

# 1 "/usr/include/boost/predef/version.h" 1 3 4
# 23 "/usr/include/boost/predef.h" 2 3 4
# 25 "/usr/include/boost/lockfree/detail/prefix.hpp" 2 3 4
# 15 "/usr/include/boost/lockfree/detail/parameter.hpp" 2 3 4
# 1 "/usr/include/boost/lockfree/policies.hpp" 1 3 4
# 12 "/usr/include/boost/lockfree/policies.hpp" 3 4
# 1 "/usr/include/boost/parameter/template_keyword.hpp" 1 3 4
# 10 "/usr/include/boost/parameter/template_keyword.hpp" 3 4
# 1 "/usr/include/boost/parameter/aux_/template_keyword.hpp" 1 3 4
# 10 "/usr/include/boost/parameter/aux_/template_keyword.hpp" 3 4
namespace boost { namespace parameter { namespace aux {

    struct template_keyword_base
    {
    };
}}}

# 1 "/usr/include/boost/parameter/config.hpp" 1 3 4
# 60 "/usr/include/boost/parameter/config.hpp" 3 4
# 1 "/usr/include/boost/mpl/limits/vector.hpp" 1 3 4
# 61 "/usr/include/boost/parameter/config.hpp" 2 3 4
# 18 "/usr/include/boost/parameter/aux_/template_keyword.hpp" 2 3 4




namespace boost { namespace parameter { namespace aux {

    template <typename T>
    using is_template_keyword = ::std::is_base_of<
        ::boost::parameter::aux::template_keyword_base
      , typename ::std::remove_const<
            typename ::std::remove_reference<T>::type
        >::type
    >;
}}}
# 11 "/usr/include/boost/parameter/template_keyword.hpp" 2 3 4
# 27 "/usr/include/boost/parameter/template_keyword.hpp" 3 4
namespace boost { namespace parameter {

    template <typename Tag, typename T>
    struct template_keyword : ::boost::parameter::aux::template_keyword_base
    {
        typedef Tag key_type;
        typedef T value_type;
# 51 "/usr/include/boost/parameter/template_keyword.hpp" 3 4
        using reference = typename ::boost::mp11::mp_eval_if<
            ::boost::mp11::mp_if<
                ::std::is_function<value_type>
              , ::boost::mp11::mp_true
              , ::std::is_array<value_type>
            >
          , ::std::add_lvalue_reference<value_type>
          , ::boost::mp11::mp_identity
          , value_type
        >::type;
# 72 "/usr/include/boost/parameter/template_keyword.hpp" 3 4
    };
}}
# 13 "/usr/include/boost/lockfree/policies.hpp" 2 3 4

# 1 "/usr/include/boost/mpl/size_t.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/size_t.hpp" 3 4
# 1 "/usr/include/boost/mpl/size_t_fwd.hpp" 1 3 4
# 21 "/usr/include/boost/mpl/size_t_fwd.hpp" 3 4
namespace mpl_ {

template< std::size_t N > struct size_t;

}
namespace boost { namespace mpl { using ::mpl_::size_t; } }
# 18 "/usr/include/boost/mpl/size_t.hpp" 2 3 4





# 1 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 1 3 4
# 40 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 3 4
namespace mpl_ {

template< std::size_t N >
struct size_t
{
    static const std::size_t value = N;





    typedef size_t type;

    typedef std::size_t value_type;
    typedef integral_c_tag tag;
# 72 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 3 4
    typedef mpl_::size_t< static_cast<std::size_t>((value + 1)) > next;
    typedef mpl_::size_t< static_cast<std::size_t>((value - 1)) > prior;






    constexpr operator std::size_t() const { return static_cast<std::size_t>(this->value); }
};


template< std::size_t N >
std::size_t const mpl_::size_t< N >::value;


}
# 24 "/usr/include/boost/mpl/size_t.hpp" 2 3 4
# 15 "/usr/include/boost/lockfree/policies.hpp" 2 3 4

namespace boost {
namespace lockfree {


namespace tag { struct allocator ; }
namespace tag { struct fixed_sized; }
namespace tag { struct capacity; }
# 33 "/usr/include/boost/lockfree/policies.hpp" 3 4
template <bool IsFixedSized>
struct fixed_sized:
    boost::parameter::template_keyword<tag::fixed_sized, boost::mpl::bool_<IsFixedSized> >
{};





template <size_t Size>
struct capacity:
    boost::parameter::template_keyword<tag::capacity, boost::mpl::size_t<Size> >
{};



template <class Alloc>
struct allocator:
    boost::parameter::template_keyword<tag::allocator, Alloc>
{};

}
}
# 16 "/usr/include/boost/lockfree/detail/parameter.hpp" 2 3 4
# 1 "/usr/include/boost/parameter/binding.hpp" 1 3 4








# 1 "/usr/include/boost/parameter/aux_/void.hpp" 1 3 4








namespace boost { namespace parameter {



    struct void_
    {
    };
}}

namespace boost { namespace parameter { namespace aux {

    inline ::boost::parameter::void_& void_reference()
    {
        static ::boost::parameter::void_ instance;
        return instance;
    }
}}}
# 10 "/usr/include/boost/parameter/binding.hpp" 2 3 4
# 27 "/usr/include/boost/parameter/binding.hpp" 3 4
namespace boost { namespace parameter {





    template <typename Parameters, typename Keyword, typename Default>
    struct binding0
    {

        using type = ::boost::mp11::mp_apply_q<
            typename Parameters::binding
          , ::boost::mp11::mp_list<Keyword,Default,::boost::mp11::mp_true>
        >;

        static_assert(
            ::boost::mp11::mp_if<
                ::std::is_same<Default,::boost::parameter::void_>
              , ::boost::mp11::mp_if<
                    ::std::is_same<type,::boost::parameter::void_>
                  , ::boost::mp11::mp_false
                  , ::boost::mp11::mp_true
                >
              , ::boost::mp11::mp_true
            >::value
          , "required parameters must not result in void_ type"
        );
# 74 "/usr/include/boost/parameter/binding.hpp" 3 4
    };


    template <typename Placeholder, typename Keyword, typename Default>
    struct binding1
    {
        using type = ::boost::mp11::mp_apply_q<
            Placeholder
          , ::boost::mp11::mp_list<Keyword,Default,::boost::mp11::mp_true>
        >;

        static_assert(
            ::boost::mp11::mp_if<
                ::std::is_same<Default,::boost::parameter::void_>
              , ::boost::mp11::mp_if<
                    ::std::is_same<type,::boost::parameter::void_>
                  , ::boost::mp11::mp_false
                  , ::boost::mp11::mp_true
                >
              , ::boost::mp11::mp_true
            >::value
          , "required parameters must not result in void_ type"
        );
    };

}}

# 1 "/usr/include/boost/parameter/aux_/is_placeholder.hpp" 1 3 4
# 17 "/usr/include/boost/parameter/aux_/is_placeholder.hpp" 3 4
namespace boost { namespace parameter { namespace aux {

    template <typename T>
    struct is_mpl_placeholder

      : ::boost::mp11::mp_false



    {
    };
}}}



namespace boost { namespace parameter { namespace aux {

    template <int I>
    struct is_mpl_placeholder< ::boost::mpl::arg<I> >

      : ::boost::mp11::mp_true



    {
    };
}}}




namespace boost { namespace parameter { namespace aux {

    template <typename T>
    struct is_mp11_placeholder : ::boost::mp11::mp_false
    {
    };

    template < ::std::size_t I>
    struct is_mp11_placeholder< ::boost::mp11::mp_arg<I> >
      : ::boost::mp11::mp_true
    {
    };
}}}
# 102 "/usr/include/boost/parameter/binding.hpp" 2 3 4

namespace boost { namespace parameter {

    template <
        typename Parameters
      , typename Keyword
      , typename Default = ::boost::parameter::void_
    >
    struct binding







    {

        using type = typename ::boost::mp11::mp_if<
            ::boost::parameter::aux::is_mpl_placeholder<Parameters>
          , ::boost::mp11::mp_identity<int>
          , ::boost::mp11::mp_if<
                ::boost::parameter::aux::is_mp11_placeholder<Parameters>
              , ::boost::parameter::binding1<Parameters,Keyword,Default>
              , ::boost::parameter::binding0<Parameters,Keyword,Default>
            >
        >::type;

    };
}}

# 1 "/usr/include/boost/parameter/aux_/result_of0.hpp" 1 3 4








# 1 "/usr/include/boost/parameter/aux_/use_default_tag.hpp" 1 3 4
# 11 "/usr/include/boost/parameter/aux_/use_default_tag.hpp" 3 4
namespace boost { namespace parameter { namespace aux {

    struct use_default_tag
    {
        inline constexpr use_default_tag() = default;

        inline constexpr use_default_tag(use_default_tag const&) = default;



        inline constexpr use_default_tag operator()() const
        {
            return *this;
        }
    };
}}}
# 10 "/usr/include/boost/parameter/aux_/result_of0.hpp" 2 3 4

# 1 "/usr/include/boost/utility/result_of.hpp" 1 3 4
# 21 "/usr/include/boost/utility/result_of.hpp" 3 4
# 1 "/usr/include/boost/type_traits/type_identity.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/type_identity.hpp" 3 4
namespace boost
{

template<class T> struct type_identity
{
    typedef T type;
};



template <class T> using type_identity_t = typename type_identity<T>::type;




}
# 22 "/usr/include/boost/utility/result_of.hpp" 2 3 4
# 70 "/usr/include/boost/utility/result_of.hpp" 3 4
namespace boost {

template<typename F> struct result_of;
template<typename F> struct tr1_result_of;


namespace detail {

typedef char result_of_yes_type;
typedef char (&result_of_no_type)[2];

template<class T> struct result_of_has_type {};

template<class T> struct result_of_has_result_type_impl
{
    template<class U> static result_of_yes_type f( result_of_has_type<typename U::result_type>* );
    template<class U> static result_of_no_type f( ... );

    typedef boost::integral_constant<bool, sizeof(f<T>(0)) == sizeof(result_of_yes_type)> type;
};

template<class T> struct result_of_has_result_type: result_of_has_result_type_impl<T>::type
{
};
# 114 "/usr/include/boost/utility/result_of.hpp" 3 4
template<typename F, typename FArgs, bool HasResultType> struct tr1_result_of_impl;

template<typename F> struct cpp0x_result_of;
# 180 "/usr/include/boost/utility/result_of.hpp" 3 4
template<typename T>
struct result_of_always_void
{
  typedef void type;
};

template<typename F, typename Enable = void> struct cpp0x_result_of_impl {};



template<typename F>
struct result_of_void_impl
{
  typedef void type;
};

template<typename R>
struct result_of_void_impl<R (*)(void)>
{
  typedef R type;
};

template<typename R>
struct result_of_void_impl<R (&)(void)>
{
  typedef R type;
};


template<typename F, typename FArgs>
struct result_of_pointer
  : tr1_result_of_impl<typename remove_cv<F>::type, FArgs, false> { };

template<typename F, typename FArgs>
struct tr1_result_of_impl<F, FArgs, true>
{
  typedef typename F::result_type type;
};

template<typename FArgs>
struct is_function_with_no_args : false_type {};

template<typename F>
struct is_function_with_no_args<F(void)> : true_type {};

template<typename F, typename FArgs>
struct result_of_nested_result : F::template result<FArgs>
{};

template<typename F, typename FArgs>
struct tr1_result_of_impl<F, FArgs, false>
  : conditional<is_function_with_no_args<FArgs>::value,
             result_of_void_impl<F>,
             result_of_nested_result<F, FArgs> >::type
{};

}


# 1 "/usr/include/boost/utility/detail/result_of_variadic.hpp" 1 3 4
# 19 "/usr/include/boost/utility/detail/result_of_variadic.hpp" 3 4
template<typename F, typename... Args>
struct tr1_result_of<F(Args...)>
    : conditional<
        is_pointer<F>::value || is_member_function_pointer<F>::value
        , boost::detail::tr1_result_of_impl<
            typename remove_cv<F>::type,
            typename remove_cv<F>::type(Args...),
            (boost::detail::result_of_has_result_type<F>::value)>
        , boost::detail::tr1_result_of_impl<
            F,
            F(Args...),
            (boost::detail::result_of_has_result_type<F>::value)> >::type { };


template<typename F, typename... Args>
struct result_of<F(Args...)>
    : detail::cpp0x_result_of<F(Args...)> { };
# 48 "/usr/include/boost/utility/detail/result_of_variadic.hpp" 3 4
namespace detail {

template<typename F, typename... Args>
struct cpp0x_result_of<F(Args...)>
    : conditional<
          is_member_function_pointer<F>::value
        , detail::tr1_result_of_impl<
            typename remove_cv<F>::type,
            typename remove_cv<F>::type(Args...), false
          >
        , detail::cpp0x_result_of_impl<
              F(Args...)
          >
      >::type
{};
# 126 "/usr/include/boost/utility/detail/result_of_variadic.hpp" 3 4
template<typename F, typename... Args>
struct cpp0x_result_of_impl<F(Args...),
                            typename result_of_always_void<decltype(
                                boost::declval<F>()(
                                    boost::declval<Args>()...
                                )
                            )>::type> {
  typedef decltype(
    boost::declval<F>()(
      boost::declval<Args>()...
    )
  ) type;
};



}
# 152 "/usr/include/boost/utility/detail/result_of_variadic.hpp" 3 4
namespace detail {

template<typename R, typename FArgs, typename... Args>
struct tr1_result_of_impl<R (*)(Args...), FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs, typename... Args>
struct tr1_result_of_impl<R (&)(Args...), FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs, typename C, typename... Args>
struct tr1_result_of_impl<R (C::*)(Args...), FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs, typename C, typename... Args>
struct tr1_result_of_impl<R (C::*)(Args...) const, FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs, typename C, typename... Args>
struct tr1_result_of_impl<R (C::*)(Args...) volatile, FArgs, false>
{
  typedef R type;
};

template<typename R, typename FArgs, typename C, typename... Args>
struct tr1_result_of_impl<R (C::*)(Args...) const volatile, FArgs, false>
{
  typedef R type;
};

}
# 240 "/usr/include/boost/utility/result_of.hpp" 2 3 4
# 254 "/usr/include/boost/utility/result_of.hpp" 3 4
}
# 12 "/usr/include/boost/parameter/aux_/result_of0.hpp" 2 3 4
# 21 "/usr/include/boost/parameter/aux_/result_of0.hpp" 3 4
namespace boost { namespace parameter { namespace aux {



    template <typename F>
    class result_of0
    {



        typedef typename ::boost::result_of<F()>::type result_of_F;


     public:

        using type = ::boost::mp11::mp_if<
            ::std::is_void<result_of_F>




          , ::boost::parameter::aux::use_default_tag
          , result_of_F

        >;



    };
}}}
# 134 "/usr/include/boost/parameter/binding.hpp" 2 3 4

namespace boost { namespace parameter {




    template <typename Parameters, typename Keyword, typename DefaultFn>
    struct lazy_binding
    {

        using type = ::boost::mp11::mp_apply_q<
            typename Parameters::binding
          , ::boost::mp11::mp_list<
                Keyword
              , typename ::boost::parameter::aux::result_of0<DefaultFn>::type
              , ::boost::mp11::mp_true
            >
        >;
# 160 "/usr/include/boost/parameter/binding.hpp" 3 4
    };
}}
# 17 "/usr/include/boost/lockfree/detail/parameter.hpp" 2 3 4
# 1 "/usr/include/boost/parameter/parameters.hpp" 1 3 4
# 14 "/usr/include/boost/parameter/parameters.hpp" 3 4
namespace boost { namespace parameter { namespace aux {



    template <typename ArgList, typename ...Args>
    struct arg_list_factory;
}}}

# 1 "/usr/include/boost/parameter/aux_/arg_list.hpp" 1 3 4
# 10 "/usr/include/boost/parameter/aux_/arg_list.hpp" 3 4
namespace boost { namespace parameter { namespace aux {
# 23 "/usr/include/boost/parameter/aux_/arg_list.hpp" 3 4
    struct arg_list_tag;

    template <typename T>
    struct get_reference
    {
        typedef typename T::reference type;
    };
}}}





namespace boost { namespace parameter { namespace aux {

    struct value_type_is_void
    {
    };

    struct value_type_is_not_void
    {
    };
}}}




# 1 "/usr/include/boost/parameter/aux_/yesno.hpp" 1 3 4








namespace boost { namespace parameter { namespace aux {



    typedef char yes_tag;
    typedef char (&no_tag)[2];
}}}



namespace boost { namespace parameter { namespace aux {



    ::boost::parameter::aux::yes_tag to_yesno(::boost::mpl::true_);
    ::boost::parameter::aux::no_tag to_yesno(::boost::mpl::false_);
}}}






namespace boost { namespace parameter { namespace aux {



    ::boost::parameter::aux::yes_tag to_yesno(::boost::mp11::mp_true);
    ::boost::parameter::aux::no_tag to_yesno(::boost::mp11::mp_false);
}}}
# 51 "/usr/include/boost/parameter/aux_/arg_list.hpp" 2 3 4

# 1 "/usr/include/boost/parameter/aux_/default.hpp" 1 3 4
# 10 "/usr/include/boost/parameter/aux_/default.hpp" 3 4
namespace boost { namespace parameter { namespace aux {



    template <typename Keyword, typename Value>
    struct default_
    {
        inline constexpr default_(Value& x) : value(x)
        {
        }

        Value& value;
    };
}}}



namespace boost { namespace parameter { namespace aux {
# 57 "/usr/include/boost/parameter/aux_/default.hpp" 3 4
    template <typename KW, typename DefaultComputer>
    struct lazy_default
    {
        inline constexpr lazy_default(DefaultComputer& x)
          : compute_default(x)
        {
        }

        DefaultComputer& compute_default;
    };

}}}
# 84 "/usr/include/boost/parameter/aux_/default.hpp" 3 4
namespace boost { namespace parameter { namespace aux {

    template <typename Keyword, typename Value>
    struct default_r_
    {
        inline constexpr default_r_(Value&& x)
          : value(::std::forward<Value>(x))
        {
        }
# 105 "/usr/include/boost/parameter/aux_/default.hpp" 3 4
        Value&& value;
    };
}}}
# 53 "/usr/include/boost/parameter/aux_/arg_list.hpp" 2 3 4
# 64 "/usr/include/boost/parameter/aux_/arg_list.hpp" 3 4
namespace boost { namespace parameter { namespace aux {




    struct empty_arg_list
    {
        struct tagged_arg
        {
            typedef ::boost::parameter::void_ value_type;
        };


        template <typename ...Args>
        inline constexpr empty_arg_list(Args&&...)
        {
        }




        struct binding
        {
            template <typename KW, typename Default, typename Reference>
            struct apply
            {
                typedef Default type;
            };


            template <typename KW, typename Default, typename Reference>
            using fn = Default;

        };


        template <typename KW>
        static ::boost::parameter::aux::no_tag has_key(KW*);




        template <typename K, typename Default>
        inline constexpr Default&
            operator[](::boost::parameter::aux::default_<K,Default> x) const
        {
            return x.value;
        }

        template <typename K, typename Default>
        inline constexpr Default&&
            operator[](::boost::parameter::aux::default_r_<K,Default> x) const
        {
            return ::std::forward<Default>(x.value);
        }




        template <typename K, typename F>
        inline constexpr
        typename ::boost::parameter::aux::result_of0<F>::type
            operator[](::boost::parameter::aux::lazy_default<K,F> x) const
        {
            return x.compute_default();
        }





        template <typename ParameterRequirements, typename ArgPack>
        static typename ParameterRequirements::has_default
            satisfies(ParameterRequirements*, ArgPack*);


        typedef ::boost::parameter::aux::empty_arg_list type;

        typedef ::boost::parameter::aux::arg_list_tag tag;
    };
}}}

# 1 "/usr/include/boost/parameter/aux_/preprocessor/nullptr.hpp" 1 3 4
# 147 "/usr/include/boost/parameter/aux_/arg_list.hpp" 2 3 4

# 1 "/usr/include/boost/parameter/aux_/is_maybe.hpp" 1 3 4








namespace boost { namespace parameter { namespace aux {

    struct maybe_base
    {
    };
}}}




namespace boost { namespace parameter { namespace aux {

    template <typename T>
    using is_maybe = ::std::is_base_of<
        ::boost::parameter::aux::maybe_base
      , typename ::std::remove_const<T>::type
    >;
}}}
# 149 "/usr/include/boost/parameter/aux_/arg_list.hpp" 2 3 4
# 1 "/usr/include/boost/parameter/aux_/tagged_argument_fwd.hpp" 1 3 4
# 10 "/usr/include/boost/parameter/aux_/tagged_argument_fwd.hpp" 3 4
namespace boost { namespace parameter { namespace aux {

    template <typename Keyword, typename Arg>
    class tagged_argument;
}}}





namespace boost { namespace parameter { namespace aux {

    template <typename Keyword, typename Arg>
    struct tagged_argument_rref;
}}}





namespace boost { namespace parameter { namespace aux {

    template <typename TaggedArg>
    struct tagged_argument_list_of_1;
}}}
# 150 "/usr/include/boost/parameter/aux_/arg_list.hpp" 2 3 4
# 1 "/usr/include/boost/parameter/aux_/parameter_requirements.hpp" 1 3 4








# 1 "/usr/include/boost/parameter/aux_/pack/parameter_requirements.hpp" 1 3 4








namespace boost { namespace parameter { namespace aux {





    template <typename Keyword, typename Predicate, typename HasDefault>
    struct parameter_requirements
    {
        typedef Keyword keyword;
        typedef Predicate predicate;
        typedef HasDefault has_default;
    };
}}}
# 10 "/usr/include/boost/parameter/aux_/parameter_requirements.hpp" 2 3 4
# 151 "/usr/include/boost/parameter/aux_/arg_list.hpp" 2 3 4
# 1 "/usr/include/boost/parameter/aux_/augment_predicate.hpp" 1 3 4








# 1 "/usr/include/boost/parameter/keyword_fwd.hpp" 1 3 4








namespace boost { namespace parameter {

    struct in_reference;
    struct out_reference;
    typedef ::boost::parameter::out_reference in_out_reference;
    struct forward_reference;
    struct consume_reference;
    typedef ::boost::parameter::consume_reference move_from_reference;

    template <typename Tag>
    struct keyword;
}}
# 10 "/usr/include/boost/parameter/aux_/augment_predicate.hpp" 2 3 4







namespace boost { namespace parameter { namespace aux {

    template <typename V, typename R, typename Tag>
    struct augment_predicate_check_consume_ref
      : ::boost::mpl::eval_if<
            ::boost::is_scalar<V>
          , ::boost::mpl::true_
          , ::boost::mpl::eval_if<
                ::boost::is_same<
                    typename Tag::qualifier
                  , ::boost::parameter::consume_reference
                >
              , ::boost::mpl::if_<
                    ::boost::is_lvalue_reference<R>
                  , ::boost::mpl::false_
                  , ::boost::mpl::true_
                >
              , boost::mpl::true_
            >
        >::type
    {
    };
}}}



namespace boost { namespace parameter { namespace aux {

    template <typename V, typename R, typename Tag>
    struct augment_predicate_check_out_ref
      : ::boost::mpl::eval_if<
            ::boost::is_same<
                typename Tag::qualifier
              , ::boost::parameter::out_reference
            >
          , ::boost::mpl::eval_if<
                ::boost::is_lvalue_reference<R>
              , ::boost::mpl::if_<
                    ::boost::is_const<V>
                  , ::boost::mpl::false_
                  , ::boost::mpl::true_
                >
              , ::boost::mpl::false_
            >
          , ::boost::mpl::true_
        >::type
    {
    };
}}}

# 1 "/usr/include/boost/parameter/aux_/lambda_tag.hpp" 1 3 4








namespace boost { namespace parameter { namespace aux {


    struct lambda_tag;
}}}
# 68 "/usr/include/boost/parameter/aux_/augment_predicate.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/apply_wrap.hpp" 1 3 4
# 69 "/usr/include/boost/parameter/aux_/augment_predicate.hpp" 2 3 4


namespace boost { namespace parameter { namespace aux {

    template <
        typename Predicate
      , typename R
      , typename Tag
      , typename T
      , typename Args
    >
    class augment_predicate
    {
        typedef typename ::boost::mpl::lambda<
            Predicate
          , ::boost::parameter::aux::lambda_tag
        >::type _actual_predicate;

     public:
        typedef typename ::boost::mpl::eval_if<
            typename ::boost::mpl::if_<
                ::boost::parameter::aux
                ::augment_predicate_check_consume_ref<T,R,Tag>
              , ::boost::parameter::aux
                ::augment_predicate_check_out_ref<T,R,Tag>
              , ::boost::mpl::false_
            >::type
          , ::boost::mpl::apply_wrap2<_actual_predicate,T,Args>
          , ::boost::mpl::false_
        >::type type;
    };
}}}
# 109 "/usr/include/boost/parameter/aux_/augment_predicate.hpp" 3 4
namespace boost { namespace parameter { namespace aux {

    template <typename V, typename R, typename Tag>
    using augment_predicate_check_consume_ref_mp11 = ::boost::mp11::mp_if<
        ::std::is_scalar<V>
      , ::boost::mp11::mp_true
      , ::boost::mp11::mp_if<
            ::std::is_same<
                typename Tag::qualifier
              , ::boost::parameter::consume_reference
            >
          , ::boost::mp11::mp_if<
                ::std::is_lvalue_reference<R>
              , ::boost::mp11::mp_false
              , ::boost::mp11::mp_true
            >
          , boost::mp11::mp_true
        >
    >;

    template <typename V, typename R, typename Tag>
    using augment_predicate_check_out_ref_mp11 = ::boost::mp11::mp_if<
        ::std::is_same<
            typename Tag::qualifier
          , ::boost::parameter::out_reference
        >
      , ::boost::mp11::mp_if<
            ::std::is_lvalue_reference<R>
          , ::boost::mp11::mp_if<
                ::std::is_const<V>
              , ::boost::mp11::mp_false
              , ::boost::mp11::mp_true
            >
          , ::boost::mp11::mp_false
        >
      , ::boost::mp11::mp_true
    >;
}}}



namespace boost { namespace parameter { namespace aux {

    template <
        typename Predicate
      , typename R
      , typename Tag
      , typename T
      , typename Args
    >
    struct augment_predicate_mp11_impl
    {
        using type = ::boost::mp11::mp_if<
            ::boost::mp11::mp_if<
                ::boost::parameter::aux
                ::augment_predicate_check_consume_ref_mp11<T,R,Tag>
              , ::boost::parameter::aux
                ::augment_predicate_check_out_ref_mp11<T,R,Tag>
              , ::boost::mp11::mp_false
            >
          , ::boost::mp11
            ::mp_apply_q<Predicate,::boost::mp11::mp_list<T,Args> >
          , ::boost::mp11::mp_false
        >;
    };
}}}

# 1 "/usr/include/boost/parameter/aux_/has_nested_template_fn.hpp" 1 3 4
# 21 "/usr/include/boost/parameter/aux_/has_nested_template_fn.hpp" 3 4
namespace boost { namespace parameter { namespace aux {


    template <template <typename ...> class F>
    struct has_nested_template_fn_variadic
    {
    };







    template <typename T>
    class has_nested_template_fn_impl
    {
        template <typename U>
        static ::boost::parameter::aux::no_tag _check(...);


        template <typename U>
        static ::boost::parameter::aux::yes_tag
            _check(
                ::boost::mp11::mp_identity<U> const volatile*
              , ::boost::parameter::aux::has_nested_template_fn_variadic<
                    U::template fn
                >* = nullptr
            );
# 61 "/usr/include/boost/parameter/aux_/has_nested_template_fn.hpp" 3 4
     public:

        using type = ::boost::mp11::mp_bool<



            sizeof(
                ::boost::parameter::aux::has_nested_template_fn_impl<T>
                ::template _check<T>(
                    static_cast<

                        ::boost::mp11::mp_identity<T> const volatile*



                    >(nullptr)
                )
            ) == sizeof(::boost::parameter::aux::yes_tag)

        >;



    };
}}}







namespace boost { namespace parameter { namespace aux {

    template <typename T>

    using has_nested_template_fn = typename ::boost::parameter::aux
    ::has_nested_template_fn_impl<typename ::std::remove_const<T>::type>
    ::type;
# 108 "/usr/include/boost/parameter/aux_/has_nested_template_fn.hpp" 3 4
}}}
# 177 "/usr/include/boost/parameter/aux_/augment_predicate.hpp" 2 3 4

namespace boost { namespace parameter { namespace aux {

    template <
        typename Predicate
      , typename R
      , typename Tag
      , typename T
      , typename Args
    >
    using augment_predicate_mp11 = ::boost::mp11::mp_if<
        ::boost::parameter::aux::has_nested_template_fn<Predicate>
      , ::boost::parameter::aux
        ::augment_predicate_mp11_impl<Predicate,R,Tag,T,Args>
      , ::boost::parameter::aux
        ::augment_predicate<Predicate,R,Tag,T,Args>
    >;
}}}
# 152 "/usr/include/boost/parameter/aux_/arg_list.hpp" 2 3 4




# 1 "/usr/include/boost/mpl/apply_wrap.hpp" 1 3 4
# 157 "/usr/include/boost/parameter/aux_/arg_list.hpp" 2 3 4




namespace boost { namespace parameter { namespace aux {




    template <
        typename TaggedArg
      , typename Next = ::boost::parameter::aux::empty_arg_list

      , typename EmitsErrors = ::boost::mp11::mp_true



    >
    class arg_list : public Next
    {

        using _holds_maybe = typename ::boost::parameter::aux
        ::is_maybe<typename TaggedArg::value_type>::type;





        TaggedArg arg;

     public:
        typedef TaggedArg tagged_arg;
        typedef ::boost::parameter::aux::arg_list<TaggedArg,Next> self;
        typedef typename TaggedArg::key_type key_type;


        using reference = typename ::boost::mp11::mp_if<
            _holds_maybe
          , ::boost::parameter::aux
            ::get_reference<typename TaggedArg::value_type>
          , ::boost::parameter::aux::get_reference<TaggedArg>
        >::type;

        using value_type = ::boost::mp11
        ::mp_if<_holds_maybe,reference,typename TaggedArg::value_type>;
# 219 "/usr/include/boost/parameter/aux_/arg_list.hpp" 3 4
        inline constexpr arg_list(
            TaggedArg const& head
          , Next const& tail
        ) : Next(tail), arg(head)
        {
        }





        template <typename A0>
        inline constexpr arg_list(
            ::boost::parameter::aux::value_type_is_not_void
          , A0&& a0
        ) : Next(

                ::boost::mp11::mp_if<
                    ::std::is_same<




                        typename Next::tagged_arg::value_type
                      , ::boost::parameter::void_
                    >
                  , ::boost::parameter::aux::value_type_is_void
                  , ::boost::parameter::aux::value_type_is_not_void

                >()



            )
          , arg(::std::forward<A0>(a0))
        {
        }

        template <typename ...Args>
        inline constexpr arg_list(
            ::boost::parameter::aux::value_type_is_void
          , Args&&... args
        ) : Next(

                ::boost::mp11::mp_if<
                    ::std::is_same<




                        typename Next::tagged_arg::value_type
                      , ::boost::parameter::void_
                    >
                  , ::boost::parameter::aux::value_type_is_void
                  , ::boost::parameter::aux::value_type_is_not_void

                >()



              , ::std::forward<Args>(args)...
            )
          , arg(::boost::parameter::aux::void_reference())
        {
        }

        template <typename A0, typename A1, typename ...Args>
        inline constexpr arg_list(
            ::boost::parameter::aux::value_type_is_not_void
          , A0&& a0
          , A1&& a1
          , Args&&... args
        ) : Next(

                ::boost::mp11::mp_if<
                    ::std::is_same<




                        typename Next::tagged_arg::value_type
                      , ::boost::parameter::void_
                    >
                  , ::boost::parameter::aux::value_type_is_void
                  , ::boost::parameter::aux::value_type_is_not_void

                >()



              , ::std::forward<A1>(a1)
              , ::std::forward<Args>(args)...
            )
          , arg(::std::forward<A0>(a0))
        {
        }




        struct binding
        {
            typedef typename Next::binding next_binding;

            template <typename KW, typename Default, typename Reference>
            struct apply
            {
                typedef typename ::boost::mpl::eval_if<
                    ::boost::is_same<KW,key_type>
                  , ::boost::mpl::if_<Reference,reference,value_type>
                  , ::boost::mpl
                    ::apply_wrap3<next_binding,KW,Default,Reference>
                >::type type;
            };


            template <typename KW, typename Default, typename Reference>
            using fn = ::boost::mp11::mp_if<
                ::std::is_same<KW,key_type>
              , ::boost::mp11::mp_if<Reference,reference,value_type>
              , ::boost::mp11::mp_apply_q<
                    next_binding
                  , ::boost::mp11::mp_list<KW,Default,Reference>
                >
            >;

        };



        static ::boost::parameter::aux::yes_tag has_key(key_type*);
        using Next::has_key;

     private:

        using _has_unique_key = ::boost::mp11::mp_bool<



            sizeof(
                Next::has_key(
                    static_cast<key_type*>(nullptr)
                )
            ) == sizeof(::boost::parameter::aux::no_tag)

        >;





        static_assert(
            !(EmitsErrors::value) || (_has_unique_key::value)
          , "duplicate keyword"
        );
# 388 "/usr/include/boost/parameter/aux_/arg_list.hpp" 3 4
        template <typename D>
        inline constexpr reference

            get_default(D const&, ::boost::mp11::mp_false) const



        {
            return this->arg.get_value();
        }

        template <typename D>
        inline constexpr reference

            get_default(D const& d, ::boost::mp11::mp_true) const



        {
            return (
                this->arg.get_value()
              ? this->arg.get_value().get()
              : this->arg.get_value().construct(d.value)
            );
        }

     public:
        inline constexpr reference
            operator[](::boost::parameter::keyword<key_type> const&) const
        {


            static_assert(!_holds_maybe::value, "must not hold maybe");
# 429 "/usr/include/boost/parameter/aux_/arg_list.hpp" 3 4
            return this->arg.get_value();
        }

        template <typename Default>
        inline constexpr reference
            operator[](
                ::boost::parameter::aux::default_<key_type,Default> const& d
            ) const
        {
            return this->get_default(d, _holds_maybe());
        }

        template <typename Default>
        inline constexpr reference
            operator[](
                ::boost::parameter::aux::default_r_<key_type,Default> const& d
            ) const
        {
            return this->get_default(d, _holds_maybe());
        }

        template <typename Default>
        inline constexpr reference
            operator[](
                ::boost::parameter::aux::lazy_default<key_type,Default> const&
            ) const
        {


            static_assert(!_holds_maybe::value, "must not hold maybe");
# 467 "/usr/include/boost/parameter/aux_/arg_list.hpp" 3 4
            return this->arg.get_value();
        }



        using Next::operator[];
# 482 "/usr/include/boost/parameter/aux_/arg_list.hpp" 3 4
        template <typename HasDefault, typename Predicate, typename ArgPack>
        static typename ::boost::lazy_enable_if<

            ::boost::mp11::mp_if<
                EmitsErrors
              , ::boost::mp11::mp_true
              , _has_unique_key
            >
          , ::boost::parameter::aux::augment_predicate_mp11<
# 499 "/usr/include/boost/parameter/aux_/arg_list.hpp" 3 4
                Predicate
              , reference
              , key_type
              , value_type
              , ArgPack
            >
        >::type
            satisfies(
                ::boost::parameter::aux::parameter_requirements<
                    key_type
                  , Predicate
                  , HasDefault
                >*
              , ArgPack*
            );



        using Next::satisfies;



        template <typename KW, typename T2>
        inline constexpr ::boost::parameter::aux::arg_list<
            ::boost::parameter::aux::tagged_argument<KW,T2>
          , self
        >
            operator,(
                ::boost::parameter::aux::tagged_argument<KW,T2> const& x
            ) const
        {
            return ::boost::parameter::aux::arg_list<
                ::boost::parameter::aux::tagged_argument<KW,T2>
              , self
            >(x, *this);
        }

        template <typename KW, typename T2>
        inline constexpr ::boost::parameter::aux::arg_list<
            ::boost::parameter::aux::tagged_argument_rref<KW,T2>
          , self
        >
            operator,(
                ::boost::parameter::aux::tagged_argument_rref<KW,T2> const& x
            ) const
        {
            return ::boost::parameter::aux::arg_list<
                ::boost::parameter::aux::tagged_argument_rref<KW,T2>
              , self
            >(x, *this);
        }


        typedef self type;
        typedef Next tail_type;

        typedef ::boost::parameter::aux::arg_list_tag tag;
    };
}}}
# 1032 "/usr/include/boost/parameter/aux_/arg_list.hpp" 3 4
namespace boost { namespace parameter { namespace aux {

    template <typename ...ArgTuples>
    struct arg_list_cons;

    template <>
    struct arg_list_cons<>
    {
        using type = ::boost::parameter::aux::empty_arg_list;
    };

    template <typename ArgTuple0, typename ...Tuples>
    struct arg_list_cons<ArgTuple0,Tuples...>
    {
        using type = ::boost::parameter::aux::arg_list<
            typename ArgTuple0::tagged_arg
          , typename ::boost::parameter::aux::arg_list_cons<Tuples...>::type
          , typename ArgTuple0::emits_errors
        >;
    };

    template <
        typename Keyword
      , typename TaggedArg
      , typename EmitsErrors = ::boost::mp11::mp_true
    >
    struct flat_like_arg_tuple
    {
        using tagged_arg = TaggedArg;
        using emits_errors = EmitsErrors;
    };

    template <typename ...ArgTuples>
    class flat_like_arg_list
      : public ::boost::parameter::aux::arg_list_cons<ArgTuples...>::type
    {
        using _base_type = typename ::boost::parameter::aux
        ::arg_list_cons<ArgTuples...>::type;

     public:
        inline constexpr flat_like_arg_list(
            typename _base_type::tagged_arg const& head
          , typename _base_type::tail_type const& tail
        ) : _base_type(head, tail)
        {
        }

        template <typename ...Args>
        inline constexpr flat_like_arg_list(Args&&... args)
          : _base_type(::std::forward<Args>(args)...)
        {
        }

        using _base_type::operator[];
        using _base_type::satisfies;



        template <typename TaggedArg>
        inline constexpr ::boost::parameter::aux::flat_like_arg_list<
            ::boost::parameter::aux::flat_like_arg_tuple<
                typename TaggedArg::base_type::key_type
              , typename TaggedArg::base_type
            >
          , ArgTuples...
        >
            operator,(TaggedArg const& x) const
        {
            return ::boost::parameter::aux::flat_like_arg_list<
                ::boost::parameter::aux::flat_like_arg_tuple<
                    typename TaggedArg::base_type::key_type
                  , typename TaggedArg::base_type
                >
              , ArgTuples...
            >(
                static_cast<typename TaggedArg::base_type const&>(x)
              , static_cast<_base_type const&>(*this)
            );
        }
    };

    template <>
    class flat_like_arg_list<>
      : public ::boost::parameter::aux::empty_arg_list
    {
        using _base_type = ::boost::parameter::aux::empty_arg_list;

     public:
        template <typename ...Args>
        inline constexpr flat_like_arg_list(Args&&... args)
          : _base_type(::std::forward<Args>(args)...)
        {
        }

        using _base_type::operator[];
        using _base_type::satisfies;



        template <typename TaggedArg>
        inline constexpr ::boost::parameter::aux::flat_like_arg_list<
            ::boost::parameter::aux::flat_like_arg_tuple<
                typename TaggedArg::base_type::key_type
              , typename TaggedArg::base_type
            >
        >
            operator,(TaggedArg const& x) const
        {
            return ::boost::parameter::aux::flat_like_arg_list<
                ::boost::parameter::aux::flat_like_arg_tuple<
                    typename TaggedArg::base_type::key_type
                  , typename TaggedArg::base_type
                >
            >(
                static_cast<typename TaggedArg::base_type const&>(x)
              , static_cast<_base_type const&>(*this)
            );
        }
    };
}}}



# 1 "/usr/include/boost/mpl/iterator_tags.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/iterator_tags.hpp" 3 4
namespace boost { namespace mpl {

struct forward_iterator_tag : int_<0> { typedef forward_iterator_tag type; };
struct bidirectional_iterator_tag : int_<1> { typedef bidirectional_iterator_tag type; };
struct random_access_iterator_tag : int_<2> { typedef random_access_iterator_tag type; };

}}
# 1156 "/usr/include/boost/parameter/aux_/arg_list.hpp" 2 3 4

namespace boost { namespace parameter { namespace aux {


    template <typename ArgumentPack>
    struct arg_list_iterator
    {
        typedef ::boost::mpl::forward_iterator_tag category;


        typedef ::boost::parameter::aux
        ::arg_list_iterator<typename ArgumentPack::tail_type> next;


        typedef typename ArgumentPack::key_type type;
    };

    template <>
    struct arg_list_iterator< ::boost::parameter::aux::empty_arg_list>
    {
    };
}}}

# 1 "/usr/include/boost/mpl/begin_end_fwd.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/begin_end_fwd.hpp" 3 4
namespace boost { namespace mpl {

template< typename Tag > struct begin_impl;
template< typename Tag > struct end_impl;

template< typename Sequence > struct begin;
template< typename Sequence > struct end;

}}
# 1180 "/usr/include/boost/parameter/aux_/arg_list.hpp" 2 3 4


namespace boost { namespace mpl {

    template <>
    struct begin_impl< ::boost::parameter::aux::arg_list_tag>
    {
        template <typename S>
        struct apply
        {
            typedef ::boost::parameter::aux::arg_list_iterator<S> type;
        };
    };

    template <>
    struct end_impl< ::boost::parameter::aux::arg_list_tag>
    {
        template <typename>
        struct apply
        {
            typedef ::boost::parameter::aux::arg_list_iterator<
                ::boost::parameter::aux::empty_arg_list
            > type;
        };
    };
}}

# 1 "/usr/include/boost/parameter/value_type.hpp" 1 3 4
# 27 "/usr/include/boost/parameter/value_type.hpp" 3 4
namespace boost { namespace parameter {





    template <typename Parameters, typename Keyword, typename Default>
    struct value_type0
    {

        using type = ::boost::mp11::mp_apply_q<
            typename Parameters::binding
          , ::boost::mp11::mp_list<Keyword,Default,::boost::mp11::mp_false>
        >;

        static_assert(
            ::boost::mp11::mp_if<
                ::std::is_same<Default,::boost::parameter::void_>
              , ::boost::mp11::mp_if<
                    ::std::is_same<type,::boost::parameter::void_>
                  , ::boost::mp11::mp_false
                  , ::boost::mp11::mp_true
                >
              , ::boost::mp11::mp_true
            >::value
          , "required parameters must not result in void_ type"
        );
# 74 "/usr/include/boost/parameter/value_type.hpp" 3 4
    };


    template <typename Placeholder, typename Keyword, typename Default>
    struct value_type1
    {
        using type = ::boost::mp11::mp_apply_q<
            Placeholder
          , ::boost::mp11::mp_list<Keyword,Default,::boost::mp11::mp_false>
        >;

        static_assert(
            ::boost::mp11::mp_if<
                ::std::is_same<Default,::boost::parameter::void_>
              , ::boost::mp11::mp_if<
                    ::std::is_same<type,::boost::parameter::void_>
                  , ::boost::mp11::mp_false
                  , ::boost::mp11::mp_true
                >
              , ::boost::mp11::mp_true
            >::value
          , "required parameters must not result in void_ type"
        );
    };

}}



namespace boost { namespace parameter {

    template <
        typename Parameters
      , typename Keyword
      , typename Default = ::boost::parameter::void_
    >
    struct value_type







    {

        using type = typename ::boost::mp11::mp_if<
            ::boost::parameter::aux::is_mpl_placeholder<Parameters>
          , ::boost::mp11::mp_identity<int>
          , ::boost::mp11::mp_if<
                ::boost::parameter::aux::is_mp11_placeholder<Parameters>
              , ::boost::parameter::value_type1<Parameters,Keyword,Default>
              , ::boost::parameter::value_type0<Parameters,Keyword,Default>
            >
        >::type;

    };
}}



namespace boost { namespace parameter {




    template <typename Parameters, typename Keyword, typename DefaultFn>
    struct lazy_value_type
    {

        using type = ::boost::mp11::mp_apply_q<
            typename Parameters::binding
          , ::boost::mp11::mp_list<
                Keyword
              , typename ::boost::parameter::aux::result_of0<DefaultFn>::type
              , ::boost::mp11::mp_false
            >
        >;
# 160 "/usr/include/boost/parameter/value_type.hpp" 3 4
    };
}}
# 1208 "/usr/include/boost/parameter/aux_/arg_list.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/has_key_fwd.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/has_key_fwd.hpp" 3 4
namespace boost { namespace mpl {

template< typename Tag > struct has_key_impl;
template< typename AssociativeSequence, typename Key > struct has_key;

}}
# 1209 "/usr/include/boost/parameter/aux_/arg_list.hpp" 2 3 4


namespace boost { namespace mpl {

    template <>
    struct has_key_impl< ::boost::parameter::aux::arg_list_tag>
    {
        template <typename ArgList, typename Keyword>
        struct apply
        {
            typedef typename ::boost::mpl::if_<
                ::boost::is_void<
                    typename ::boost::parameter
                    ::value_type<ArgList,Keyword,void>::type
                >
              , ::boost::mpl::false_
              , ::boost::mpl::true_
            >::type type;
        };
    };
}}

# 1 "/usr/include/boost/mpl/count_fwd.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/count_fwd.hpp" 3 4
namespace boost { namespace mpl {

template< typename Tag > struct count_impl;
template< typename Sequence, typename T > struct count;

}}
# 1232 "/usr/include/boost/parameter/aux_/arg_list.hpp" 2 3 4


namespace boost { namespace mpl {

    template <>
    struct count_impl< ::boost::parameter::aux::arg_list_tag>
    {
        template <typename ArgList, typename Keyword>
        struct apply
        {
            typedef typename ::boost::mpl::if_<
                ::boost::is_void<
                    typename ::boost::parameter
                    ::value_type<ArgList,Keyword,void>::type
                >
              , ::boost::mpl::int_<0>
              , ::boost::mpl::int_<1>
            >::type type;
        };
    };
}}

# 1 "/usr/include/boost/mpl/key_type_fwd.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/key_type_fwd.hpp" 3 4
namespace boost { namespace mpl {

template< typename Tag > struct key_type_impl;
template< typename AssociativeSequence, typename T > struct key_type;

}}
# 1255 "/usr/include/boost/parameter/aux_/arg_list.hpp" 2 3 4


namespace boost { namespace mpl {

    template <>
    struct key_type_impl< ::boost::parameter::aux::arg_list_tag>
    {
        template <typename ArgList, typename Keyword>
        struct apply
        {
            typedef typename ::boost::mpl::eval_if<
                ::boost::is_void<
                    typename ::boost::parameter
                    ::value_type<ArgList,Keyword,void>::type
                >
              , void
              , ::boost::mpl::identity<Keyword>
            >::type type;
        };
    };
}}

# 1 "/usr/include/boost/mpl/value_type_fwd.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/value_type_fwd.hpp" 3 4
namespace boost { namespace mpl {

template< typename Tag > struct value_type_impl;
template< typename AssociativeSequence, typename T > struct value_type;

}}
# 1278 "/usr/include/boost/parameter/aux_/arg_list.hpp" 2 3 4

namespace boost { namespace mpl {

    template <>
    struct value_type_impl< ::boost::parameter::aux::arg_list_tag>
      : ::boost::mpl::key_type_impl< ::boost::parameter::aux::arg_list_tag>
    {
    };
}}

# 1 "/usr/include/boost/mpl/at_fwd.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/at_fwd.hpp" 3 4
namespace boost { namespace mpl {

template< typename Tag > struct at_impl;
template< typename Sequence, typename N > struct at;

}}
# 1289 "/usr/include/boost/parameter/aux_/arg_list.hpp" 2 3 4

namespace boost { namespace mpl {

    template <>
    struct at_impl< ::boost::parameter::aux::arg_list_tag>
      : ::boost::mpl::key_type_impl< ::boost::parameter::aux::arg_list_tag>
    {
    };
}}

# 1 "/usr/include/boost/mpl/order_fwd.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/order_fwd.hpp" 3 4
namespace boost { namespace mpl {

template< typename Tag > struct order_impl;
template< typename AssociativeSequence, typename Key > struct order;

}}
# 1300 "/usr/include/boost/parameter/aux_/arg_list.hpp" 2 3 4

# 1 "/usr/include/boost/mpl/find.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/find.hpp" 3 4
# 1 "/usr/include/boost/mpl/find_if.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/find_if.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/find_if_pred.hpp" 1 3 4
# 14 "/usr/include/boost/mpl/aux_/find_if_pred.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/iter_apply.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/aux_/iter_apply.hpp" 3 4
# 1 "/usr/include/boost/mpl/apply.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/aux_/iter_apply.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/deref.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/deref.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/msvc_type.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/aux_/msvc_type.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/is_msvc_eti_arg.hpp" 1 3 4
# 21 "/usr/include/boost/mpl/aux_/is_msvc_eti_arg.hpp" 3 4
namespace boost { namespace mpl { namespace aux {
# 62 "/usr/include/boost/mpl/aux_/is_msvc_eti_arg.hpp" 3 4
}}}
# 19 "/usr/include/boost/mpl/aux_/msvc_type.hpp" 2 3 4

namespace boost { namespace mpl { namespace aux {
# 48 "/usr/include/boost/mpl/aux_/msvc_type.hpp" 3 4
template< typename T > struct msvc_type
{
    typedef typename T::type type;
};

template<> struct msvc_type<int>
{
    typedef int type;
};



}}}
# 18 "/usr/include/boost/mpl/deref.hpp" 2 3 4




namespace boost { namespace mpl {

template<
      typename Iterator = na
    >
struct deref
{

    typedef typename Iterator::type type;




};

template<> struct deref< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : deref< T1 > { }; }; template< typename Tag > struct lambda< deref< na > , Tag , int_<-1> > { typedef false_ is_le; typedef deref< na > result_; typedef deref< na > type; }; namespace aux { template< typename T1 > struct template_arity< deref< T1 > > : int_<1> { }; template<> struct template_arity< deref< na > > : int_<-1> { }; }

}}
# 19 "/usr/include/boost/mpl/aux_/iter_apply.hpp" 2 3 4

namespace boost { namespace mpl { namespace aux {

template<
      typename F
    , typename Iterator
    >
struct iter_apply1
    : apply1< F,typename deref<Iterator>::type >
{
};

template<
      typename F
    , typename Iterator1
    , typename Iterator2
    >
struct iter_apply2
    : apply2<
          F
        , typename deref<Iterator1>::type
        , typename deref<Iterator2>::type
        >
{
};

}}}
# 15 "/usr/include/boost/mpl/aux_/find_if_pred.hpp" 2 3 4


namespace boost { namespace mpl { namespace aux {

template< typename Predicate >
struct find_if_pred
{
    template< typename Iterator >
    struct apply
    {
        typedef not_< aux::iter_apply1<Predicate,Iterator> > type;
    };
};

}}}
# 18 "/usr/include/boost/mpl/find_if.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/arg.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/find_if.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/iter_fold_if.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/iter_fold_if.hpp" 3 4
# 1 "/usr/include/boost/mpl/begin_end.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/begin_end.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/begin_end_impl.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/aux_/begin_end_impl.hpp" 3 4
# 1 "/usr/include/boost/mpl/sequence_tag_fwd.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/sequence_tag_fwd.hpp" 3 4
namespace boost { namespace mpl {

struct nested_begin_end_tag;
struct non_sequence_tag;

template< typename Sequence > struct sequence_tag;

}}
# 19 "/usr/include/boost/mpl/aux_/begin_end_impl.hpp" 2 3 4


# 1 "/usr/include/boost/mpl/aux_/has_begin.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/aux_/has_begin.hpp" 3 4
namespace boost { namespace mpl { namespace aux {
template< typename T, typename fallback_ = boost::mpl::bool_<true> > struct has_begin { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<typename U::begin>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };
}}}
# 22 "/usr/include/boost/mpl/aux_/begin_end_impl.hpp" 2 3 4

# 1 "/usr/include/boost/mpl/aux_/traits_lambda_spec.hpp" 1 3 4
# 24 "/usr/include/boost/mpl/aux_/begin_end_impl.hpp" 2 3 4


namespace boost { namespace mpl {


namespace aux {

template< typename Sequence >
struct begin_type
{
    typedef typename Sequence::begin type;
};
template< typename Sequence >
struct end_type
{
    typedef typename Sequence::end type;
};

}





template< typename Tag >
struct begin_impl
{
    template< typename Sequence > struct apply
    {
        typedef typename eval_if<aux::has_begin<Sequence, true_>,
                                 aux::begin_type<Sequence>, void_>::type type;
    };
};

template< typename Tag >
struct end_impl
{
    template< typename Sequence > struct apply
    {
        typedef typename eval_if<aux::has_begin<Sequence, true_>,
                                 aux::end_type<Sequence>, void_>::type type;
    };
};
# 82 "/usr/include/boost/mpl/aux_/begin_end_impl.hpp" 3 4
template<> struct begin_impl<nested_begin_end_tag> { template< typename Sequence > struct apply { typedef typename Sequence::begin type; }; };
template<> struct end_impl<nested_begin_end_tag> { template< typename Sequence > struct apply { typedef typename Sequence::end type; }; };




template<> struct begin_impl<non_sequence_tag> { template< typename Sequence > struct apply { typedef void_ type; }; };
template<> struct end_impl<non_sequence_tag> { template< typename Sequence > struct apply { typedef void_ type; }; };
template<> struct begin_impl<na> { template< typename Sequence > struct apply { typedef void_ type; }; };
template<> struct end_impl<na> { template< typename Sequence > struct apply { typedef void_ type; }; };







}}
# 19 "/usr/include/boost/mpl/begin_end.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/sequence_tag.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/sequence_tag.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/has_tag.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/aux_/has_tag.hpp" 3 4
namespace boost { namespace mpl { namespace aux {
template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_tag { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<typename U::tag>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };
}}}
# 19 "/usr/include/boost/mpl/sequence_tag.hpp" 2 3 4







namespace boost { namespace mpl {
# 78 "/usr/include/boost/mpl/sequence_tag.hpp" 3 4
namespace aux {

template< bool has_tag_, bool has_begin_ >
struct sequence_tag_impl
{


    template< typename Sequence > struct result2_;
};
# 98 "/usr/include/boost/mpl/sequence_tag.hpp" 3 4
template<> struct sequence_tag_impl<true,true> { template< typename Sequence > struct result2_ { typedef typename Sequence::tag type; }; };
template<> struct sequence_tag_impl<true,false> { template< typename Sequence > struct result2_ { typedef typename Sequence::tag type; }; };
template<> struct sequence_tag_impl<false,true> { template< typename Sequence > struct result2_ { typedef nested_begin_end_tag type; }; };
template<> struct sequence_tag_impl<false,false> { template< typename Sequence > struct result2_ { typedef non_sequence_tag type; }; };



}

template<
      typename Sequence = na
    >
struct sequence_tag
    : aux::sequence_tag_impl<
          ::boost::mpl::aux::has_tag<Sequence>::value
        , ::boost::mpl::aux::has_begin<Sequence>::value
        >::template result2_<Sequence>
{
};



template<> struct sequence_tag< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : sequence_tag< T1 > { }; }; template< typename Tag > struct lambda< sequence_tag< na > , Tag , int_<-1> > { typedef false_ is_le; typedef sequence_tag< na > result_; typedef sequence_tag< na > type; }; namespace aux { template< typename T1 > struct template_arity< sequence_tag< T1 > > : int_<1> { }; template<> struct template_arity< sequence_tag< na > > : int_<-1> { }; }

}}
# 20 "/usr/include/boost/mpl/begin_end.hpp" 2 3 4



namespace boost { namespace mpl {




template<
      typename Sequence = na
    >
struct begin
{
    typedef typename sequence_tag<Sequence>::type tag_;
    typedef typename begin_impl< tag_ >
        ::template apply< Sequence >::type type;


};

template<
      typename Sequence = na
    >
struct end
{
    typedef typename sequence_tag<Sequence>::type tag_;
    typedef typename end_impl< tag_ >
        ::template apply< Sequence >::type type;


};

template<> struct begin< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : begin< T1 > { }; }; template< typename Tag > struct lambda< begin< na > , Tag , int_<-1> > { typedef false_ is_le; typedef begin< na > result_; typedef begin< na > type; }; namespace aux { template< typename T1 > struct template_arity< begin< T1 > > : int_<1> { }; template<> struct template_arity< begin< na > > : int_<-1> { }; }
template<> struct end< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : end< T1 > { }; }; template< typename Tag > struct lambda< end< na > , Tag , int_<-1> > { typedef false_ is_le; typedef end< na > result_; typedef end< na > type; }; namespace aux { template< typename T1 > struct template_arity< end< T1 > > : int_<1> { }; template<> struct template_arity< end< na > > : int_<-1> { }; }

}}
# 19 "/usr/include/boost/mpl/iter_fold_if.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/logical.hpp" 1 3 4
# 20 "/usr/include/boost/mpl/iter_fold_if.hpp" 2 3 4



# 1 "/usr/include/boost/mpl/pair.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/pair.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/msvc_eti_base.hpp" 1 3 4
# 22 "/usr/include/boost/mpl/aux_/msvc_eti_base.hpp" 3 4
namespace boost { namespace mpl { namespace aux {
# 55 "/usr/include/boost/mpl/aux_/msvc_eti_base.hpp" 3 4
template< typename T > struct msvc_eti_base
    : T
{

    msvc_eti_base();

    typedef T type;
};



template<> struct msvc_eti_base<int>
{
    typedef msvc_eti_base type;
    typedef msvc_eti_base first;
    typedef msvc_eti_base second;
    typedef msvc_eti_base tag;
    enum { value = 0 };
};

}}}
# 18 "/usr/include/boost/mpl/pair.hpp" 2 3 4




namespace boost { namespace mpl {

template<
      typename T1 = na
    , typename T2 = na
    >
struct pair
{
    typedef pair type;
    typedef T1 first;
    typedef T2 second;


};

template<
      typename P = na
    >
struct first
{

    typedef typename P::first type;




};

template<
      typename P = na
    >
struct second
{

    typedef typename P::second type;




};


template<> struct pair< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : pair< T1 , T2 > { }; }; template< typename Tag > struct lambda< pair< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef pair< na , na > result_; typedef pair< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< pair< T1 , T2 > > : int_<2> { }; template<> struct template_arity< pair< na , na > > : int_<-1> { }; }
template<> struct first< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : first< T1 > { }; }; template< typename Tag > struct lambda< first< na > , Tag , int_<-1> > { typedef false_ is_le; typedef first< na > result_; typedef first< na > type; }; namespace aux { template< typename T1 > struct template_arity< first< T1 > > : int_<1> { }; template<> struct template_arity< first< na > > : int_<-1> { }; }
template<> struct second< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : second< T1 > { }; }; template< typename Tag > struct lambda< second< na > , Tag , int_<-1> > { typedef false_ is_le; typedef second< na > result_; typedef second< na > type; }; namespace aux { template< typename T1 > struct template_arity< second< T1 > > : int_<1> { }; template<> struct template_arity< second< na > > : int_<-1> { }; }

}}
# 24 "/usr/include/boost/mpl/iter_fold_if.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/apply.hpp" 1 3 4
# 25 "/usr/include/boost/mpl/iter_fold_if.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/iter_fold_if_impl.hpp" 1 3 4
# 22 "/usr/include/boost/mpl/aux_/iter_fold_if_impl.hpp" 3 4
# 1 "/usr/include/boost/mpl/apply.hpp" 1 3 4
# 23 "/usr/include/boost/mpl/aux_/iter_fold_if_impl.hpp" 2 3 4
# 32 "/usr/include/boost/mpl/aux_/iter_fold_if_impl.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/iter_fold_if_impl.hpp" 1 3 4
# 13 "/usr/include/boost/mpl/aux_/preprocessed/gcc/iter_fold_if_impl.hpp" 3 4
namespace boost { namespace mpl { namespace aux {

template< typename Iterator, typename State >
struct iter_fold_if_null_step
{
    typedef State state;
    typedef Iterator iterator;
};

template< bool >
struct iter_fold_if_step_impl
{
    template<
          typename Iterator
        , typename State
        , typename StateOp
        , typename IteratorOp
        >
    struct result_
    {
        typedef typename apply2< StateOp,State,Iterator >::type state;
        typedef typename IteratorOp::type iterator;
    };
};

template<>
struct iter_fold_if_step_impl<false>
{
    template<
          typename Iterator
        , typename State
        , typename StateOp
        , typename IteratorOp
        >
    struct result_
    {
        typedef State state;
        typedef Iterator iterator;
    };
};

template<
      typename Iterator
    , typename State
    , typename ForwardOp
    , typename Predicate
    >
struct iter_fold_if_forward_step
{
    typedef typename apply2< Predicate,State,Iterator >::type not_last;
    typedef typename iter_fold_if_step_impl<
          not_last::value
        >::template result_< Iterator,State,ForwardOp, mpl::next<Iterator> > impl_;

    typedef typename impl_::state state;
    typedef typename impl_::iterator iterator;
};

template<
      typename Iterator
    , typename State
    , typename BackwardOp
    , typename Predicate
    >
struct iter_fold_if_backward_step
{
    typedef typename apply2< Predicate,State,Iterator >::type not_last;
    typedef typename iter_fold_if_step_impl<
          not_last::value
        >::template result_< Iterator,State,BackwardOp, identity<Iterator> > impl_;

    typedef typename impl_::state state;
    typedef typename impl_::iterator iterator;
};

template<
      typename Iterator
    , typename State
    , typename ForwardOp
    , typename ForwardPredicate
    , typename BackwardOp
    , typename BackwardPredicate
    >
struct iter_fold_if_impl
{
 private:
    typedef iter_fold_if_null_step< Iterator,State > forward_step0;
    typedef iter_fold_if_forward_step< typename forward_step0::iterator, typename forward_step0::state, ForwardOp, ForwardPredicate > forward_step1;
    typedef iter_fold_if_forward_step< typename forward_step1::iterator, typename forward_step1::state, ForwardOp, ForwardPredicate > forward_step2;
    typedef iter_fold_if_forward_step< typename forward_step2::iterator, typename forward_step2::state, ForwardOp, ForwardPredicate > forward_step3;
    typedef iter_fold_if_forward_step< typename forward_step3::iterator, typename forward_step3::state, ForwardOp, ForwardPredicate > forward_step4;


    typedef typename if_<
          typename forward_step4::not_last
        , iter_fold_if_impl<
              typename forward_step4::iterator
            , typename forward_step4::state
            , ForwardOp
            , ForwardPredicate
            , BackwardOp
            , BackwardPredicate
            >
        , iter_fold_if_null_step<
              typename forward_step4::iterator
            , typename forward_step4::state
            >
        >::type backward_step4;

    typedef iter_fold_if_backward_step< typename forward_step3::iterator, typename backward_step4::state, BackwardOp, BackwardPredicate > backward_step3;
    typedef iter_fold_if_backward_step< typename forward_step2::iterator, typename backward_step3::state, BackwardOp, BackwardPredicate > backward_step2;
    typedef iter_fold_if_backward_step< typename forward_step1::iterator, typename backward_step2::state, BackwardOp, BackwardPredicate > backward_step1;
    typedef iter_fold_if_backward_step< typename forward_step0::iterator, typename backward_step1::state, BackwardOp, BackwardPredicate > backward_step0;


 public:
    typedef typename backward_step0::state state;
    typedef typename backward_step4::iterator iterator;
};

}}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 33 "/usr/include/boost/mpl/aux_/iter_fold_if_impl.hpp" 2 3 4
# 26 "/usr/include/boost/mpl/iter_fold_if.hpp" 2 3 4


# 1 "/usr/include/boost/mpl/aux_/config/forwarding.hpp" 1 3 4
# 29 "/usr/include/boost/mpl/iter_fold_if.hpp" 2 3 4




namespace boost { namespace mpl {

namespace aux {

template< typename Predicate, typename LastIterator >
struct iter_fold_if_pred
{
    template< typename State, typename Iterator > struct apply

        : and_<
              not_< is_same<Iterator,LastIterator> >
            , apply1<Predicate,Iterator>
            >
    {







    };
};

}

template<
      typename Sequence = na
    , typename State = na
    , typename ForwardOp = na
    , typename ForwardPredicate = na
    , typename BackwardOp = na
    , typename BackwardPredicate = na
    >
struct iter_fold_if
{

    typedef typename begin<Sequence>::type first_;
    typedef typename end<Sequence>::type last_;

    typedef typename eval_if<
          is_na<BackwardPredicate>
        , if_< is_na<BackwardOp>, always<false_>, always<true_> >
        , identity<BackwardPredicate>
        >::type backward_pred_;



    struct result_ :



        aux::iter_fold_if_impl<
          first_
        , State
        , ForwardOp
        , protect< aux::iter_fold_if_pred< ForwardPredicate,last_ > >
        , BackwardOp
        , backward_pred_
        >

    { };




public:

    typedef pair<
          typename result_::state
        , typename result_::iterator
        > type;






};

template<> struct iter_fold_if< na , na , na , na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 > struct apply : iter_fold_if< T1 , T2 , T3 , T4 , T5 , T6 > { }; }; template< typename Tag > struct lambda< iter_fold_if< na , na , na , na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef iter_fold_if< na , na , na , na , na , na > result_; typedef iter_fold_if< na , na , na , na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 > struct template_arity< iter_fold_if< T1 , T2 , T3 , T4 , T5 , T6 > > : int_<6> { }; template<> struct template_arity< iter_fold_if< na , na , na , na , na , na > > : int_<-1> { }; }

}}
# 20 "/usr/include/boost/mpl/find_if.hpp" 2 3 4




namespace boost { namespace mpl {



template<
      typename Sequence = na
    , typename Predicate = na
    >
struct find_if
{
    typedef typename iter_fold_if<
          Sequence
        , void
        , mpl::arg<1>
        , protect< aux::find_if_pred<Predicate> >
        >::type result_;

    typedef typename second<result_>::type type;


};

template<> struct find_if< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : find_if< T1 , T2 > { }; }; template< typename Tag > struct lambda< find_if< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef find_if< na , na > result_; typedef find_if< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< find_if< T1 , T2 > > : int_<2> { }; template<> struct template_arity< find_if< na , na > > : int_<-1> { }; }

}}
# 18 "/usr/include/boost/mpl/find.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/same_as.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/same_as.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/lambda_spec.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/same_as.hpp" 2 3 4




namespace boost { namespace mpl {

template< typename T1 >
struct same_as
{
    template< typename T2 > struct apply

        : is_same<T1,T2>
    {




    };
};

template< typename T1 >
struct not_same_as
{
    template< typename T2 > struct apply

        : not_< is_same<T1,T2> >
    {




    };
};

}}
# 19 "/usr/include/boost/mpl/find.hpp" 2 3 4



namespace boost { namespace mpl {

template<
      typename Sequence = na
    , typename T = na
    >
struct find
    : find_if< Sequence,same_as<T> >
{

};

template<> struct find< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : find< T1 , T2 > { }; }; template< typename Tag > struct lambda< find< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef find< na , na > result_; typedef find< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< find< T1 , T2 > > : int_<2> { }; template<> struct template_arity< find< na , na > > : int_<-1> { }; }

}}
# 1302 "/usr/include/boost/parameter/aux_/arg_list.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/distance.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/distance.hpp" 3 4
# 1 "/usr/include/boost/mpl/distance_fwd.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/distance_fwd.hpp" 3 4
namespace boost { namespace mpl {



template< typename Tag > struct distance_impl;
template< typename First, typename Last > struct distance;

}}
# 18 "/usr/include/boost/mpl/distance.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/iter_fold.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/iter_fold.hpp" 3 4
# 1 "/usr/include/boost/mpl/O1_size.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/O1_size.hpp" 3 4
# 1 "/usr/include/boost/mpl/O1_size_fwd.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/O1_size_fwd.hpp" 3 4
namespace boost { namespace mpl {

template< typename Tag > struct O1_size_impl;
template< typename Sequence > struct O1_size;

}}
# 18 "/usr/include/boost/mpl/O1_size.hpp" 2 3 4

# 1 "/usr/include/boost/mpl/aux_/O1_size_impl.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/aux_/O1_size_impl.hpp" 3 4
# 1 "/usr/include/boost/mpl/long.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/long.hpp" 3 4
# 1 "/usr/include/boost/mpl/long_fwd.hpp" 1 3 4
# 20 "/usr/include/boost/mpl/long_fwd.hpp" 3 4
namespace mpl_ {

template< long N > struct long_;

}
namespace boost { namespace mpl { using ::mpl_::long_; } }
# 18 "/usr/include/boost/mpl/long.hpp" 2 3 4


# 1 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 1 3 4
# 40 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 3 4
namespace mpl_ {

template< long N >
struct long_
{
    static const long value = N;





    typedef long_ type;

    typedef long value_type;
    typedef integral_c_tag tag;
# 72 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 3 4
    typedef mpl_::long_< static_cast<long>((value + 1)) > next;
    typedef mpl_::long_< static_cast<long>((value - 1)) > prior;






    constexpr operator long() const { return static_cast<long>(this->value); }
};


template< long N >
long const mpl_::long_< N >::value;


}
# 21 "/usr/include/boost/mpl/long.hpp" 2 3 4
# 19 "/usr/include/boost/mpl/aux_/O1_size_impl.hpp" 2 3 4

# 1 "/usr/include/boost/mpl/aux_/has_size.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/aux_/has_size.hpp" 3 4
namespace boost { namespace mpl { namespace aux {
template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_size { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<typename U::size>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };
}}}
# 21 "/usr/include/boost/mpl/aux_/O1_size_impl.hpp" 2 3 4





namespace boost { namespace mpl {
# 35 "/usr/include/boost/mpl/aux_/O1_size_impl.hpp" 3 4
namespace aux {
template< typename Sequence > struct O1_size_impl
    : Sequence::size
{
};
}

template< typename Tag >
struct O1_size_impl
{
    template< typename Sequence > struct apply

        : if_<
              aux::has_size<Sequence>
            , aux::O1_size_impl<Sequence>
            , long_<-1>
            >::type
    {
# 69 "/usr/include/boost/mpl/aux_/O1_size_impl.hpp" 3 4
    };
};
# 85 "/usr/include/boost/mpl/aux_/O1_size_impl.hpp" 3 4
}}
# 20 "/usr/include/boost/mpl/O1_size.hpp" 2 3 4



namespace boost { namespace mpl {


template<
      typename Sequence = na
    >
struct O1_size
    : O1_size_impl< typename sequence_tag<Sequence>::type >
        ::template apply< Sequence >
{

};

template<> struct O1_size< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : O1_size< T1 > { }; }; template< typename Tag > struct lambda< O1_size< na > , Tag , int_<-1> > { typedef false_ is_le; typedef O1_size< na > result_; typedef O1_size< na > type; }; namespace aux { template< typename T1 > struct template_arity< O1_size< T1 > > : int_<1> { }; template<> struct template_arity< O1_size< na > > : int_<-1> { }; }

}}
# 20 "/usr/include/boost/mpl/iter_fold.hpp" 2 3 4

# 1 "/usr/include/boost/mpl/aux_/iter_fold_impl.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/aux_/iter_fold_impl.hpp" 3 4
# 1 "/usr/include/boost/mpl/apply.hpp" 1 3 4
# 20 "/usr/include/boost/mpl/aux_/iter_fold_impl.hpp" 2 3 4
# 33 "/usr/include/boost/mpl/aux_/iter_fold_impl.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/iter_fold_impl.hpp" 1 3 4
# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/iter_fold_impl.hpp" 3 4
namespace boost { namespace mpl { namespace aux {



template<
      int N
    , typename First
    , typename Last
    , typename State
    , typename ForwardOp
    >
struct iter_fold_impl;

template<
      typename First
    , typename Last
    , typename State
    , typename ForwardOp
    >
struct iter_fold_impl< 0,First,Last,State,ForwardOp >
{
    typedef First iter0;
    typedef State state0;
    typedef state0 state;
    typedef iter0 iterator;
};

template<
      typename First
    , typename Last
    , typename State
    , typename ForwardOp
    >
struct iter_fold_impl< 1,First,Last,State,ForwardOp >
{
    typedef First iter0;
    typedef State state0;
    typedef typename apply2< ForwardOp,state0,iter0 >::type state1;
    typedef typename mpl::next<iter0>::type iter1;


    typedef state1 state;
    typedef iter1 iterator;
};

template<
      typename First
    , typename Last
    , typename State
    , typename ForwardOp
    >
struct iter_fold_impl< 2,First,Last,State,ForwardOp >
{
    typedef First iter0;
    typedef State state0;
    typedef typename apply2< ForwardOp,state0,iter0 >::type state1;
    typedef typename mpl::next<iter0>::type iter1;
    typedef typename apply2< ForwardOp,state1,iter1 >::type state2;
    typedef typename mpl::next<iter1>::type iter2;


    typedef state2 state;
    typedef iter2 iterator;
};

template<
      typename First
    , typename Last
    , typename State
    , typename ForwardOp
    >
struct iter_fold_impl< 3,First,Last,State,ForwardOp >
{
    typedef First iter0;
    typedef State state0;
    typedef typename apply2< ForwardOp,state0,iter0 >::type state1;
    typedef typename mpl::next<iter0>::type iter1;
    typedef typename apply2< ForwardOp,state1,iter1 >::type state2;
    typedef typename mpl::next<iter1>::type iter2;
    typedef typename apply2< ForwardOp,state2,iter2 >::type state3;
    typedef typename mpl::next<iter2>::type iter3;


    typedef state3 state;
    typedef iter3 iterator;
};

template<
      typename First
    , typename Last
    , typename State
    , typename ForwardOp
    >
struct iter_fold_impl< 4,First,Last,State,ForwardOp >
{
    typedef First iter0;
    typedef State state0;
    typedef typename apply2< ForwardOp,state0,iter0 >::type state1;
    typedef typename mpl::next<iter0>::type iter1;
    typedef typename apply2< ForwardOp,state1,iter1 >::type state2;
    typedef typename mpl::next<iter1>::type iter2;
    typedef typename apply2< ForwardOp,state2,iter2 >::type state3;
    typedef typename mpl::next<iter2>::type iter3;
    typedef typename apply2< ForwardOp,state3,iter3 >::type state4;
    typedef typename mpl::next<iter3>::type iter4;


    typedef state4 state;
    typedef iter4 iterator;
};

template<
      int N
    , typename First
    , typename Last
    , typename State
    , typename ForwardOp
    >
struct iter_fold_impl
{
    typedef iter_fold_impl<
          4
        , First
        , Last
        , State
        , ForwardOp
        > chunk_;

    typedef iter_fold_impl<
          ( (N - 4) < 0 ? 0 : N - 4 )
        , typename chunk_::iterator
        , Last
        , typename chunk_::state
        , ForwardOp
        > res_;

    typedef typename res_::state state;
    typedef typename res_::iterator iterator;
};

template<
      typename First
    , typename Last
    , typename State
    , typename ForwardOp
    >
struct iter_fold_impl< -1,First,Last,State,ForwardOp >
    : iter_fold_impl<
          -1
        , typename mpl::next<First>::type
        , Last
        , typename apply2< ForwardOp,State,First >::type
        , ForwardOp
        >
{
};

template<
      typename Last
    , typename State
    , typename ForwardOp
    >
struct iter_fold_impl< -1,Last,Last,State,ForwardOp >
{
    typedef State state;
    typedef Last iterator;
};

}}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 34 "/usr/include/boost/mpl/aux_/iter_fold_impl.hpp" 2 3 4
# 22 "/usr/include/boost/mpl/iter_fold.hpp" 2 3 4



namespace boost { namespace mpl {

template<
      typename Sequence = na
    , typename State = na
    , typename ForwardOp = na
    >
struct iter_fold
{
    typedef typename aux::iter_fold_impl<
          ::boost::mpl::O1_size<Sequence>::value
        , typename begin<Sequence>::type
        , typename end<Sequence>::type
        , State
        , typename lambda<ForwardOp>::type
        >::state type;


};

template<> struct iter_fold< na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 =na , typename T5 =na > struct apply : iter_fold< T1 , T2 , T3 > { }; }; template< typename Tag > struct lambda< iter_fold< na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef iter_fold< na , na , na > result_; typedef iter_fold< na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 > struct template_arity< iter_fold< T1 , T2 , T3 > > : int_<3> { }; template<> struct template_arity< iter_fold< na , na , na > > : int_<-1> { }; }

}}
# 19 "/usr/include/boost/mpl/distance.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/iterator_range.hpp" 1 3 4
# 20 "/usr/include/boost/mpl/iterator_range.hpp" 3 4
namespace boost { namespace mpl {

struct iterator_range_tag;

template<
      typename First = na
    , typename Last = na
    >
struct iterator_range
{
    typedef iterator_range_tag tag;
    typedef iterator_range type;
    typedef First begin;
    typedef Last end;


};

template<> struct iterator_range< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : iterator_range< T1 , T2 > { }; }; template< typename Tag > struct lambda< iterator_range< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef iterator_range< na , na > result_; typedef iterator_range< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< iterator_range< T1 , T2 > > : int_<2> { }; template<> struct template_arity< iterator_range< na , na > > : int_<-1> { }; }

}}
# 20 "/usr/include/boost/mpl/distance.hpp" 2 3 4


# 1 "/usr/include/boost/mpl/tag.hpp" 1 3 4
# 22 "/usr/include/boost/mpl/tag.hpp" 3 4
namespace boost { namespace mpl {

namespace aux {
template< typename T > struct tag_impl
{
    typedef typename T::tag type;
};
}

template< typename T, typename Default = void_ > struct tag

    : if_<
          aux::has_tag<T>
        , aux::tag_impl<T>
        , Default
        >::type
{
# 48 "/usr/include/boost/mpl/tag.hpp" 3 4
};

}}
# 23 "/usr/include/boost/mpl/distance.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/apply_wrap.hpp" 1 3 4
# 24 "/usr/include/boost/mpl/distance.hpp" 2 3 4







namespace boost { namespace mpl {


template< typename Tag > struct distance_impl
{
    template< typename First, typename Last > struct apply

        : aux::msvc_eti_base< typename iter_fold<
              iterator_range<First,Last>
            , mpl::long_<0>
            , next<>
            >::type >
    {
# 60 "/usr/include/boost/mpl/distance.hpp" 3 4
    };
};

template<
      typename First = na
    , typename Last = na
    >
struct distance
    : distance_impl< typename tag<First>::type >
        ::template apply<First, Last>
{

};

template<> struct distance< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : distance< T1 , T2 > { }; }; template< typename Tag > struct lambda< distance< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef distance< na , na > result_; typedef distance< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< distance< T1 , T2 > > : int_<2> { }; template<> struct template_arity< distance< na , na > > : int_<-1> { }; }

}}
# 1303 "/usr/include/boost/parameter/aux_/arg_list.hpp" 2 3 4

namespace boost { namespace mpl {

    template <>
    struct order_impl< ::boost::parameter::aux::arg_list_tag>
    {
        template <typename ArgList, typename Keyword>
        struct apply
        {
            typedef typename ::boost::mpl::find<ArgList,Keyword>::type Itr;
            typedef typename ::boost::mpl::eval_if<
                ::boost::is_void<
                    typename ::boost::parameter
                    ::value_type<ArgList,Keyword,void>::type
                >
              , ::boost::mpl::identity< ::boost::mpl::void_>
              , ::boost::mpl::distance<
                    Itr
                  , ::boost::parameter::aux::arg_list_iterator<
                        ::boost::parameter::aux::empty_arg_list
                    >
                >
            >::type type;
        };
    };
}}
# 23 "/usr/include/boost/parameter/parameters.hpp" 2 3 4
# 33 "/usr/include/boost/parameter/parameters.hpp" 3 4
namespace boost { namespace parameter { namespace aux {


    template <typename ArgList>
    struct arg_list_factory<ArgList>
    {
        template <typename ...ReversedArgs>
        static inline constexpr ArgList
            reverse(ReversedArgs&&... reversed_args)
        {
            return ArgList(

                ::boost::mp11::mp_if<
                    ::std::is_same<




                        typename ArgList::tagged_arg::value_type
                      , ::boost::parameter::void_
                    >
                  , ::boost::parameter::aux::value_type_is_void
                  , ::boost::parameter::aux::value_type_is_not_void

                >()



              , ::std::forward<ReversedArgs>(reversed_args)...
            );
        }
    };

    template <typename ArgList, typename A0, typename ...Args>
    struct arg_list_factory<ArgList,A0,Args...>
    {
        template <typename ...ReversedArgs>
        static inline constexpr ArgList
            reverse(A0&& a0, Args&&... args, ReversedArgs&&... reversed_args)
        {
            return ::boost::parameter::aux
            ::arg_list_factory<ArgList,Args...>::reverse(
                ::std::forward<Args>(args)...
              , ::std::forward<A0>(a0)
              , ::std::forward<ReversedArgs>(reversed_args)...
            );
        }
    };
}}}


# 1 "/usr/include/boost/parameter/aux_/pack/make_arg_list.hpp" 1 3 4
# 10 "/usr/include/boost/parameter/aux_/pack/make_arg_list.hpp" 3 4
namespace boost { namespace parameter { namespace aux {

    template <
        typename List
      , typename DeducedArgs
      , typename TagFn
      , typename IsPositional
      , typename UsedArgs
      , typename ArgumentPack
      , typename Error
      , typename EmitsErrors
    >
    struct make_arg_list_aux;
}}}



# 1 "/usr/include/boost/parameter/aux_/pack/unmatched_argument.hpp" 1 3 4
# 20 "/usr/include/boost/parameter/aux_/pack/unmatched_argument.hpp" 3 4
namespace boost { namespace parameter { namespace aux {

    template <typename T>
    struct unmatched_argument
    {

        static_assert(::std::is_same<T,void>::value, "T == void");
# 36 "/usr/include/boost/parameter/aux_/pack/unmatched_argument.hpp" 3 4
        typedef int type;
    };
}}}
# 28 "/usr/include/boost/parameter/aux_/pack/make_arg_list.hpp" 2 3 4
# 1 "/usr/include/boost/parameter/aux_/pack/tag_type.hpp" 1 3 4








namespace boost { namespace parameter { namespace aux {


    template <typename T>
    struct get_tag_type0
    {
        typedef typename T::key_type type;
    };
}}}

# 1 "/usr/include/boost/parameter/deduced.hpp" 1 3 4








# 1 "/usr/include/boost/parameter/aux_/use_default.hpp" 1 3 4








namespace boost { namespace parameter { namespace aux {

    struct use_default
    {
    };
}}}
# 10 "/usr/include/boost/parameter/deduced.hpp" 2 3 4

namespace boost { namespace parameter {







    template <typename Tag>
    struct deduced
    {
        typedef Tag key_type;
    };
}}
# 34 "/usr/include/boost/parameter/deduced.hpp" 3 4
namespace boost { namespace parameter { namespace aux {

    template <typename T>
    struct is_deduced_aux

      : ::boost::mp11::mp_false



    {
    };

    template <typename Tag>
    struct is_deduced_aux< ::boost::parameter::deduced<Tag> >

      : ::boost::mp11::mp_true



    {
    };

    template <typename T>
    struct is_deduced0
      : ::boost::parameter::aux::is_deduced_aux<typename T::key_type>::type
    {
    };
}}}

# 1 "/usr/include/boost/parameter/required.hpp" 1 3 4
# 11 "/usr/include/boost/parameter/required.hpp" 3 4
namespace boost { namespace parameter {
# 23 "/usr/include/boost/parameter/required.hpp" 3 4
    template <
        typename Tag
      , typename Predicate = ::boost::parameter::aux::use_default
    >
    struct required
    {
        typedef Tag key_type;
        typedef Predicate predicate;
    };
}}
# 42 "/usr/include/boost/parameter/required.hpp" 3 4
namespace boost { namespace parameter { namespace aux {

    template <typename T>
    struct is_required

      : ::boost::mp11::mp_false



    {
    };

    template <typename Tag, typename Predicate>
    struct is_required< ::boost::parameter::required<Tag,Predicate> >

      : ::boost::mp11::mp_true



    {
    };
}}}
# 64 "/usr/include/boost/parameter/deduced.hpp" 2 3 4
# 1 "/usr/include/boost/parameter/optional.hpp" 1 3 4
# 11 "/usr/include/boost/parameter/optional.hpp" 3 4
namespace boost { namespace parameter {
# 24 "/usr/include/boost/parameter/optional.hpp" 3 4
    template <
        typename Tag
      , typename Predicate = ::boost::parameter::aux::use_default
    >
    struct optional
    {
        typedef Tag key_type;
        typedef Predicate predicate;
    };
}}
# 43 "/usr/include/boost/parameter/optional.hpp" 3 4
namespace boost { namespace parameter { namespace aux {

    template <typename T>
    struct is_optional

      : ::boost::mp11::mp_false



    {
    };

    template <typename Tag, typename Predicate>
    struct is_optional< ::boost::parameter::optional<Tag,Predicate> >

      : ::boost::mp11::mp_true



    {
    };
}}}
# 65 "/usr/include/boost/parameter/deduced.hpp" 2 3 4







namespace boost { namespace parameter { namespace aux {
# 86 "/usr/include/boost/parameter/deduced.hpp" 3 4
    template <typename T>

    using has_default = ::boost::mp11::mp_if<
        ::boost::parameter::aux::is_required<T>
      , ::boost::mp11::mp_false
      , ::boost::mp11::mp_true
    >;
# 104 "/usr/include/boost/parameter/deduced.hpp" 3 4
    template <typename T>

    using is_deduced = ::boost::mp11::mp_if<
        ::boost::mp11::mp_if<
            ::boost::parameter::aux::is_optional<T>
          , ::boost::mp11::mp_true
          , ::boost::parameter::aux::is_required<T>
        >
      , ::boost::parameter::aux::is_deduced0<T>
      , ::boost::mp11::mp_false
    >;
# 129 "/usr/include/boost/parameter/deduced.hpp" 3 4
}}}
# 20 "/usr/include/boost/parameter/aux_/pack/tag_type.hpp" 2 3 4








namespace boost { namespace parameter { namespace aux {

    template <typename T>
    struct get_tag_type

      : ::boost::mp11::mp_if<



            ::boost::parameter::aux::is_deduced0<T>
          , ::boost::parameter::aux::get_tag_type0<typename T::key_type>
          , ::boost::parameter::aux::get_tag_type0<T>
        >
    {
    };
}}}







namespace boost { namespace parameter { namespace aux {

    template <typename T>
    using tag_type = ::boost::mp11::mp_if<
        ::boost::mp11::mp_if<
            ::boost::parameter::aux::is_optional<T>
          , ::boost::mp11::mp_true
          , ::boost::parameter::aux::is_required<T>
        >
      , ::boost::parameter::aux::get_tag_type<T>
      , ::boost::mp11::mp_identity<T>
    >;
}}}
# 29 "/usr/include/boost/parameter/aux_/pack/make_arg_list.hpp" 2 3 4
# 1 "/usr/include/boost/parameter/aux_/pack/is_named_argument.hpp" 1 3 4
# 10 "/usr/include/boost/parameter/aux_/pack/is_named_argument.hpp" 3 4
# 1 "/usr/include/boost/parameter/aux_/is_tagged_argument.hpp" 1 3 4
# 10 "/usr/include/boost/parameter/aux_/is_tagged_argument.hpp" 3 4
namespace boost { namespace parameter { namespace aux {

    struct tagged_argument_base
    {
    };
}}}







# 1 "/usr/include/boost/type_traits/is_base_of.hpp" 1 3 4
# 12 "/usr/include/boost/type_traits/is_base_of.hpp" 3 4
# 1 "/usr/include/boost/type_traits/is_base_and_derived.hpp" 1 3 4
# 24 "/usr/include/boost/type_traits/is_base_and_derived.hpp" 3 4
namespace boost {

namespace detail {
# 220 "/usr/include/boost/type_traits/is_base_and_derived.hpp" 3 4
template <typename B, typename D>
struct is_base_and_derived_impl
{
    typedef typename remove_cv<B>::type ncvB;
    typedef typename remove_cv<D>::type ncvD;

    static const bool value = ((__is_base_of(B,D) && !is_same<B,D>::value) && ! ::boost::is_same<ncvB,ncvD>::value);
};

}

template <class Base, class Derived> struct is_base_and_derived
   : public integral_constant<bool, (::boost::detail::is_base_and_derived_impl<Base, Derived>::value)> {};

template <class Base, class Derived> struct is_base_and_derived<Base&, Derived> : public false_type{};
template <class Base, class Derived> struct is_base_and_derived<Base, Derived&> : public false_type{};
template <class Base, class Derived> struct is_base_and_derived<Base&, Derived&> : public false_type{};





}
# 13 "/usr/include/boost/type_traits/is_base_of.hpp" 2 3 4



namespace boost {

   namespace detail{
      template <class B, class D>
      struct is_base_of_imp
      {
          typedef typename remove_cv<B>::type ncvB;
          typedef typename remove_cv<D>::type ncvD;
          static const bool value = ( (::boost::detail::is_base_and_derived_impl<ncvB,ncvD>::value) || (::boost::is_same<ncvB,ncvD>::value && ::boost::is_class<ncvB>::value));


      };
   }

   template <class Base, class Derived> struct is_base_of
      : public integral_constant<bool, (::boost::detail::is_base_of_imp<Base, Derived>::value)> {};

   template <class Base, class Derived> struct is_base_of<Base, Derived&> : false_type{};
   template <class Base, class Derived> struct is_base_of<Base&, Derived&> : false_type{};
   template <class Base, class Derived> struct is_base_of<Base&, Derived> : false_type{};

}
# 24 "/usr/include/boost/parameter/aux_/is_tagged_argument.hpp" 2 3 4



namespace boost { namespace parameter { namespace aux {



    template <typename T>
    struct is_tagged_argument
      : ::boost::mpl::if_<


            ::boost::is_base_of<
                ::boost::parameter::aux::tagged_argument_base
              , typename ::boost::remove_const<
                    typename ::boost::remove_reference<T>::type
                >::type
            >
          , ::boost::mpl::true_
          , ::boost::mpl::false_
        >::type
    {
    };
}}}
# 82 "/usr/include/boost/parameter/aux_/is_tagged_argument.hpp" 3 4
namespace boost { namespace parameter { namespace aux {

    template <typename T>
    using is_tagged_argument_mp11 = ::std::is_base_of<
        ::boost::parameter::aux::tagged_argument_base
      , typename ::std::remove_const<
            typename ::std::remove_reference<T>::type
        >::type
    >;
}}}
# 11 "/usr/include/boost/parameter/aux_/pack/is_named_argument.hpp" 2 3 4
# 21 "/usr/include/boost/parameter/aux_/pack/is_named_argument.hpp" 3 4
namespace boost { namespace parameter { namespace aux {

    template <typename T>

    using is_named_argument = ::boost::mp11::mp_if<
        ::boost::parameter::aux::is_template_keyword<T>
      , ::boost::mp11::mp_true
      , ::boost::parameter::aux::is_tagged_argument_mp11<T>
    >;
# 40 "/usr/include/boost/parameter/aux_/pack/is_named_argument.hpp" 3 4
}}}
# 30 "/usr/include/boost/parameter/aux_/pack/make_arg_list.hpp" 2 3 4
# 1 "/usr/include/boost/parameter/aux_/pack/insert_tagged.hpp" 1 3 4








# 1 "/usr/include/boost/parameter/aux_/set.hpp" 1 3 4
# 14 "/usr/include/boost/parameter/aux_/set.hpp" 3 4
namespace boost { namespace parameter { namespace aux {

    typedef ::boost::mp11::mp_list<> set0;
}}}



namespace boost { namespace parameter { namespace aux {

    template <typename S, typename K>
    struct insert_
    {
        using type = ::boost::mp11::mp_insert_c<S,0,K>;
    };
}}}





namespace boost { namespace parameter { namespace aux {

    template <typename Set, typename K>
    struct has_key_
    {
        using type = ::boost::mp11::mp_if<
            ::boost::mp11::mp_empty<Set>
          , ::boost::mp11::mp_false
          , ::std::is_same<
                ::boost::mp11::mp_find<Set,K>
              , ::boost::mp11::mp_size<Set>
            >
        >;
    };
}}}
# 10 "/usr/include/boost/parameter/aux_/pack/insert_tagged.hpp" 2 3 4

namespace boost { namespace parameter { namespace aux {



    template <typename UsedArgs, typename Tagged>
    struct insert_tagged
      : ::boost::parameter::aux::insert_<UsedArgs,typename Tagged::key_type>
    {
    };
}}}
# 31 "/usr/include/boost/parameter/aux_/pack/make_arg_list.hpp" 2 3 4
# 1 "/usr/include/boost/parameter/aux_/pack/deduce_tag.hpp" 1 3 4








namespace boost { namespace parameter { namespace aux {

    template <
        typename Argument
      , typename ArgumentPack
      , typename DeducedArgs
      , typename UsedArgs
      , typename TagFn
      , typename EmitsErrors
    >
    struct deduce_tag;
}}}



# 1 "/usr/include/boost/mpl/apply_wrap.hpp" 1 3 4
# 25 "/usr/include/boost/parameter/aux_/pack/deduce_tag.hpp" 2 3 4




namespace boost { namespace parameter { namespace aux {

    template <typename Predicate, typename Argument, typename ArgumentPack>
    struct deduce_tag_condition_mpl
      : ::boost::mpl::apply_wrap2<
            typename ::boost::mpl::lambda<
                Predicate
              , ::boost::parameter::aux::lambda_tag
            >::type
          , Argument
          , ArgumentPack
        >
    {
    };
}}}





namespace boost { namespace parameter { namespace aux {

    template <typename Predicate, typename Argument, typename ArgumentPack>
    struct deduce_tag_condition_mp11
    {
        using type = ::boost::mp11::mp_apply_q<
            Predicate
          , ::boost::mp11::mp_list<Argument,ArgumentPack>
        >;
    };

    template <typename Predicate, typename Argument, typename ArgumentPack>
    using deduce_tag_condition = ::boost::mp11::mp_if<
        ::boost::parameter::aux::has_nested_template_fn<Predicate>
      , ::boost::parameter::aux
        ::deduce_tag_condition_mp11<Predicate,Argument,ArgumentPack>
      , ::boost::parameter::aux
        ::deduce_tag_condition_mpl<Predicate,Argument,ArgumentPack>
    >;
}}}
# 79 "/usr/include/boost/parameter/aux_/pack/deduce_tag.hpp" 3 4
# 1 "/usr/include/boost/parameter/aux_/pack/tag_deduced.hpp" 1 3 4
# 21 "/usr/include/boost/parameter/aux_/pack/tag_deduced.hpp" 3 4
namespace boost { namespace parameter { namespace aux {




    template <typename UsedArgs, typename Spec, typename Arg, typename TagFn>
    struct tag_deduced
    {

        using type = ::boost::mp11::mp_list<
            ::boost::mp11::mp_apply_q<
                TagFn
              , ::boost::mp11::mp_list<
                    typename ::boost::parameter::aux::tag_type<Spec>::type
                  , Arg
                >
            >
# 46 "/usr/include/boost/parameter/aux_/pack/tag_deduced.hpp" 3 4
          , typename ::boost::parameter::aux::insert_<
                UsedArgs
              , typename ::boost::parameter::aux::tag_type<Spec>::type
            >::type

        >;



    };
}}}
# 80 "/usr/include/boost/parameter/aux_/pack/deduce_tag.hpp" 2 3 4

namespace boost { namespace parameter { namespace aux {


    template <
        typename Argument
      , typename ArgumentPack
      , typename DeducedArgs
      , typename UsedArgs
      , typename TagFn
      , typename EmitsErrors
    >
    class deduce_tag0
    {
        typedef typename DeducedArgs::spec _spec;


        typedef typename ::boost::parameter::aux::deduce_tag_condition<
            typename _spec::predicate







          , Argument
          , ArgumentPack
        >::type _condition;
# 132 "/usr/include/boost/parameter/aux_/pack/deduce_tag.hpp" 3 4
     public:

        using type = typename ::boost::mp11::mp_if<



            _condition
          , ::boost::parameter::aux
            ::tag_deduced<UsedArgs,_spec,Argument,TagFn>
          , ::boost::parameter::aux::deduce_tag<
                Argument
              , ArgumentPack
              , typename DeducedArgs::tail
              , UsedArgs
              , TagFn
              , EmitsErrors
            >

        >::type;



    };
}}}
# 166 "/usr/include/boost/parameter/aux_/pack/deduce_tag.hpp" 3 4
namespace boost { namespace parameter { namespace aux {
# 183 "/usr/include/boost/parameter/aux_/pack/deduce_tag.hpp" 3 4
    template <
        typename Argument
      , typename ArgumentPack
      , typename DeducedArgs
      , typename UsedArgs
      , typename TagFn
      , typename EmitsErrors
    >
    struct deduce_tag

      : ::boost::mp11::mp_if<
            ::std::is_same<DeducedArgs,::boost::parameter::void_>
          , ::boost::mp11::mp_identity<
                ::boost::mp11::mp_list< ::boost::parameter::void_,UsedArgs>
            >





          , ::boost::parameter::aux::deduce_tag0<
                Argument
              , ArgumentPack
              , DeducedArgs
              , UsedArgs
              , TagFn
              , EmitsErrors
            >
        >
    {
    };
}}}
# 32 "/usr/include/boost/parameter/aux_/pack/make_arg_list.hpp" 2 3 4
# 52 "/usr/include/boost/parameter/aux_/pack/make_arg_list.hpp" 3 4
namespace boost { namespace parameter { namespace aux {


    template <typename ArgumentPack, typename TaggedArg, typename EmitsErrors>
    struct append_to_make_arg_list
    {
        using type = ::boost::mp11::mp_push_front<
            ArgumentPack
          , ::boost::parameter::aux::flat_like_arg_tuple<
                typename TaggedArg::key_type
              , TaggedArg
              , EmitsErrors
            >
        >;
    };




    template <
        typename List
      , typename DeducedArgs
      , typename TagFn
      , typename IsPositional
      , typename UsedArgs
      , typename ArgumentPack



      , typename Error
      , typename EmitsErrors
    >



    class make_arg_list0

    {

        typedef typename List::arg _argument;


        using _arg_type = typename ::std::remove_const<
            typename ::std::remove_reference<_argument>::type
        >::type;
        using _is_tagged = ::boost::parameter::aux
        ::is_named_argument<_argument>;







        typedef typename List::spec _parameter_spec;
        typedef typename ::boost::parameter::aux
        ::tag_type<_parameter_spec>::type _tag;




        using _is_positional = ::boost::mp11::mp_if<
            IsPositional
          , ::boost::mp11::mp_if<
                ::boost::parameter::aux::is_deduced<_parameter_spec>
              , ::boost::mp11::mp_false
              , ::boost::mp11::mp_if<
                    _is_tagged
                  , ::boost::mp11::mp_false
                  , ::boost::mp11::mp_true
                >
            >
          , ::boost::mp11::mp_false
        >;
# 147 "/usr/include/boost/parameter/aux_/pack/make_arg_list.hpp" 3 4
        using _used_args = typename ::boost::mp11::mp_if<
            _is_tagged
          , ::boost::parameter::aux::insert_tagged<UsedArgs,_arg_type>
          , ::boost::mp11::mp_identity<UsedArgs>
        >::type;
# 163 "/usr/include/boost/parameter/aux_/pack/make_arg_list.hpp" 3 4
        using _deduced_data = typename ::boost::mp11::mp_if<
            ::boost::mp11::mp_if<
                _is_tagged
              , ::boost::mp11::mp_true
              , _is_positional
            >
          , ::boost::mp11::mp_identity<
                ::boost::mp11::mp_list< ::boost::parameter::void_,_used_args>
            >
# 181 "/usr/include/boost/parameter/aux_/pack/make_arg_list.hpp" 3 4
          , ::boost::parameter::aux::deduce_tag<
                _argument
              , ArgumentPack
              , DeducedArgs
              , _used_args
              , TagFn
              , EmitsErrors
            >

        >::type;






        using _tagged = ::boost::mp11::mp_if<
            _is_tagged

          , _arg_type

          , ::boost::mp11::mp_if<

                _is_positional

              , ::boost::mp11::mp_apply_q<
                    TagFn
                  , ::boost::mp11::mp_list<_tag,_argument>
                >

              , ::boost::mp11::mp_at_c<_deduced_data,0>
            >
        >;
# 234 "/usr/include/boost/parameter/aux_/pack/make_arg_list.hpp" 3 4
        using _error = ::boost::mp11::mp_if<
            ::boost::mp11::mp_if<
                ::std::is_same<Error,::boost::parameter::void_>
              , ::std::is_same<_tagged,::boost::parameter::void_>
              , ::boost::mp11::mp_false
            >
# 248 "/usr/include/boost/parameter/aux_/pack/make_arg_list.hpp" 3 4
          , ::boost::parameter::aux::unmatched_argument<_argument>
          , ::boost::parameter::void_

        >;





        using _argument_pack = typename ::boost::mp11::mp_if<
            ::std::is_same<_tagged,::boost::parameter::void_>
          , ::boost::mp11::mp_identity<ArgumentPack>
          , ::boost::parameter::aux
            ::append_to_make_arg_list<ArgumentPack,_tagged,EmitsErrors>
        >::type;
# 276 "/usr/include/boost/parameter/aux_/pack/make_arg_list.hpp" 3 4
     public:
        typedef typename ::boost::parameter::aux::make_arg_list_aux<
            typename List::tail
          , DeducedArgs
          , TagFn
          , _is_positional

          , ::boost::mp11::mp_at_c<_deduced_data,1>



          , _argument_pack
          , _error
          , EmitsErrors
        >::type type;
    };
# 353 "/usr/include/boost/parameter/aux_/pack/make_arg_list.hpp" 3 4
    template <
        typename List
      , typename DeducedArgs
      , typename TagFn
      , typename IsPositional
      , typename DeducedSet
      , typename ArgumentPack
      , typename Error
      , typename EmitsErrors
    >
    struct make_arg_list_aux

      : ::boost::mp11::mp_if<
            ::std::is_same<List,::boost::parameter::void_>
          , ::boost::mp11::mp_identity<
                ::boost::mp11::mp_list<ArgumentPack,Error>
            >





          , ::boost::parameter::aux::make_arg_list0<
                List
              , DeducedArgs
              , TagFn
              , IsPositional
              , DeducedSet
              , ArgumentPack
              , Error
              , EmitsErrors
            >
        >
    {
    };
}}}



namespace boost { namespace parameter { namespace aux {



    template <
        typename List
      , typename DeducedArgs
      , typename TagFn

      , typename EmitsErrors = ::boost::mp11::mp_true



    >

    using make_arg_list = ::boost::parameter::aux::make_arg_list_aux<




            List
          , DeducedArgs
          , TagFn

          , ::boost::mp11::mp_true



          , ::boost::parameter::aux::set0

          , ::boost::parameter::aux::flat_like_arg_list<>



          , ::boost::parameter::void_
          , EmitsErrors

    >;





}}}
# 85 "/usr/include/boost/parameter/parameters.hpp" 2 3 4
# 1 "/usr/include/boost/parameter/aux_/pack/make_parameter_spec_items.hpp" 1 3 4








namespace boost { namespace parameter { namespace aux {




    template <typename SpecSeq>
    struct make_deduced_list;


    template <typename ArgumentPackAndError, typename SpecSeq>
    struct match_parameters_base_cond_helper;


    template <typename SpecSeq, typename ...Args>
    struct make_parameter_spec_items_helper;
}}}



namespace boost { namespace parameter { namespace aux {

    template <typename SpecSeq>
    struct make_parameter_spec_items_helper<SpecSeq>
    {
        typedef ::boost::parameter::void_ type;
    };
}}}

# 1 "/usr/include/boost/parameter/aux_/pack/make_deduced_items.hpp" 1 3 4
# 10 "/usr/include/boost/parameter/aux_/pack/make_deduced_items.hpp" 3 4
# 1 "/usr/include/boost/parameter/aux_/pack/deduced_item.hpp" 1 3 4
# 11 "/usr/include/boost/parameter/aux_/pack/deduced_item.hpp" 3 4
namespace boost { namespace parameter { namespace aux {


    template <
        typename ParameterSpec
      , typename Tail = ::boost::parameter::void_
    >
    struct deduced_item
    {
        typedef ParameterSpec spec;
        typedef Tail tail;
    };


    template <typename Spec, typename Tail>
    struct make_deduced_item
    {
        typedef ::boost::parameter::aux
        ::deduced_item<Spec,typename Tail::type> type;
    };
}}}
# 11 "/usr/include/boost/parameter/aux_/pack/make_deduced_items.hpp" 2 3 4
# 23 "/usr/include/boost/parameter/aux_/pack/make_deduced_items.hpp" 3 4
namespace boost { namespace parameter { namespace aux {

    template <typename Spec, typename Tail>

    using make_deduced_items = ::boost::mp11::mp_if<
        ::std::is_same<Spec,::boost::parameter::void_>
      , ::boost::mp11::mp_identity< ::boost::parameter::void_>
      , ::boost::mp11::mp_if<
            ::boost::parameter::aux::is_deduced<Spec>
          , ::boost::parameter::aux::make_deduced_item<Spec,Tail>
          , Tail
        >
    >;
# 50 "/usr/include/boost/parameter/aux_/pack/make_deduced_items.hpp" 3 4
}}}
# 38 "/usr/include/boost/parameter/aux_/pack/make_parameter_spec_items.hpp" 2 3 4








namespace boost { namespace parameter { namespace aux {

    template <typename SpecSeq>
    struct make_deduced_list_not_empty
      : ::boost::parameter::aux::make_deduced_items<

            ::boost::mp11::mp_front<SpecSeq>



          , ::boost::parameter::aux::make_deduced_list<

                ::boost::mp11::mp_pop_front<SpecSeq>



            >
        >
    {
    };
}}}
# 76 "/usr/include/boost/parameter/aux_/pack/make_parameter_spec_items.hpp" 3 4
namespace boost { namespace parameter { namespace aux {

    template <typename SpecSeq>
    struct make_deduced_list

      : ::boost::mp11::mp_if<
            ::boost::mp11::mp_empty<SpecSeq>
          , ::boost::mp11::mp_identity< ::boost::parameter::void_>





          , ::boost::parameter::aux::make_deduced_list_not_empty<SpecSeq>
        >
    {
    };
}}}
# 121 "/usr/include/boost/parameter/aux_/pack/make_parameter_spec_items.hpp" 3 4
namespace boost { namespace parameter { namespace aux {




    template <typename ArgumentPackAndError, typename SpecSeq>

    using match_parameters_base_cond = ::boost::mp11::mp_if<
        ::boost::mp11::mp_empty<SpecSeq>
      , ::std::is_same<
            ::boost::mp11::mp_at_c<ArgumentPackAndError,1>
          , ::boost::parameter::void_
        >
      , ::boost::parameter::aux::match_parameters_base_cond_helper<
            ArgumentPackAndError
          , SpecSeq
        >
    >;
# 153 "/usr/include/boost/parameter/aux_/pack/make_parameter_spec_items.hpp" 3 4
}}}

# 1 "/usr/include/boost/parameter/aux_/pack/satisfies.hpp" 1 3 4
# 28 "/usr/include/boost/parameter/aux_/pack/satisfies.hpp" 3 4
namespace boost { namespace parameter { namespace aux {
# 46 "/usr/include/boost/parameter/aux_/pack/satisfies.hpp" 3 4
    template <typename ArgList, typename ParameterRequirements>

    using satisfies = ::boost::mp11::mp_bool<
        sizeof(
            ::boost::parameter::aux::to_yesno(
                ArgList::satisfies(
                    static_cast<ParameterRequirements*>(
                        nullptr
                    )
                  , static_cast<ArgList*>(nullptr)
                )
            )
        ) == sizeof(::boost::parameter::aux::yes_tag)
    >;
# 114 "/usr/include/boost/parameter/aux_/pack/satisfies.hpp" 3 4
}}}

# 1 "/usr/include/boost/parameter/aux_/pack/as_parameter_requirements.hpp" 1 3 4
# 11 "/usr/include/boost/parameter/aux_/pack/as_parameter_requirements.hpp" 3 4
# 1 "/usr/include/boost/parameter/aux_/pack/predicate.hpp" 1 3 4








namespace boost { namespace parameter { namespace aux {


    template <typename T>
    struct get_predicate_or_default
    {
        typedef T type;
    };


    template <typename T>
    struct get_predicate
      : ::boost::parameter::aux
        ::get_predicate_or_default<typename T::predicate>
    {
    };
}}}


# 1 "/usr/include/boost/parameter/aux_/always_true_predicate.hpp" 1 3 4
# 20 "/usr/include/boost/parameter/aux_/always_true_predicate.hpp" 3 4
namespace boost { namespace parameter { namespace aux {


    struct always_true_predicate
    {
        template <typename ...>
        struct apply
        {
            typedef ::boost::mpl::true_ type;
        };


        template <typename ...>
        using fn = ::boost::mp11::mp_true;

    };



}}}
# 29 "/usr/include/boost/parameter/aux_/pack/predicate.hpp" 2 3 4

namespace boost { namespace parameter { namespace aux {

    template <>
    struct get_predicate_or_default< ::boost::parameter::aux::use_default>
    {
        typedef ::boost::parameter::aux::always_true_predicate type;
    };
}}}
# 53 "/usr/include/boost/parameter/aux_/pack/predicate.hpp" 3 4
namespace boost { namespace parameter { namespace aux {

    template <typename T>

    using predicate = ::boost::mp11::mp_if<
        ::boost::mp11::mp_if<
            ::boost::parameter::aux::is_optional<T>
          , ::boost::mp11::mp_true
          , ::boost::parameter::aux::is_required<T>
        >
      , ::boost::parameter::aux::get_predicate<T>
      , ::boost::mp11::mp_identity<
            ::boost::parameter::aux::always_true_predicate
        >
    >;
# 84 "/usr/include/boost/parameter/aux_/pack/predicate.hpp" 3 4
}}}
# 12 "/usr/include/boost/parameter/aux_/pack/as_parameter_requirements.hpp" 2 3 4


namespace boost { namespace parameter { namespace aux {





    template <typename ParameterSpec>
    struct as_parameter_requirements
    {
        typedef ::boost::parameter::aux::parameter_requirements<
            typename ::boost::parameter::aux::tag_type<ParameterSpec>::type
          , typename ::boost::parameter::aux::predicate<ParameterSpec>::type
          , ::boost::parameter::aux::has_default<ParameterSpec>
        > type;
    };
}}}
# 117 "/usr/include/boost/parameter/aux_/pack/satisfies.hpp" 2 3 4

namespace boost { namespace parameter { namespace aux {



    template <typename ArgList, typename ParameterSpec>

    using satisfies_requirements_of = ::boost::parameter::aux::satisfies<
        ArgList
      , typename ::boost::parameter::aux
        ::as_parameter_requirements<ParameterSpec>::type
    >;
# 139 "/usr/include/boost/parameter/aux_/pack/satisfies.hpp" 3 4
}}}
# 156 "/usr/include/boost/parameter/aux_/pack/make_parameter_spec_items.hpp" 2 3 4

namespace boost { namespace parameter { namespace aux {

    template <typename ArgumentPackAndError, typename SpecSeq>
    struct match_parameters_base_cond_helper

      : ::boost::mp11::mp_if<



            ::boost::parameter::aux::satisfies_requirements_of<

                ::boost::mp11::mp_at_c<ArgumentPackAndError,0>
              , ::boost::mp11::mp_front<SpecSeq>




            >
          , ::boost::parameter::aux::match_parameters_base_cond<
                ArgumentPackAndError

              , ::boost::mp11::mp_pop_front<SpecSeq>



            >

          , ::boost::mp11::mp_false



        >
    {
    };





    template <typename SpecSeq, typename ...Args>

    using make_parameter_spec_items = ::boost::mp11::mp_if<
        ::boost::mp11::mp_empty<SpecSeq>
      , ::boost::mp11::mp_identity< ::boost::parameter::void_>
      , ::boost::parameter::aux
        ::make_parameter_spec_items_helper<SpecSeq,Args...>
    >;
# 215 "/usr/include/boost/parameter/aux_/pack/make_parameter_spec_items.hpp" 3 4
}}}

# 1 "/usr/include/boost/parameter/aux_/pack/make_items.hpp" 1 3 4
# 10 "/usr/include/boost/parameter/aux_/pack/make_items.hpp" 3 4
# 1 "/usr/include/boost/parameter/aux_/pack/item.hpp" 1 3 4
# 18 "/usr/include/boost/parameter/aux_/pack/item.hpp" 3 4
namespace boost { namespace parameter { namespace aux {


    template <
        typename Spec
      , typename Arg
      , typename Tail = ::boost::parameter::void_
    >
    struct item
    {
        typedef Spec spec;





        typedef Arg arg;
        typedef Tail tail;
    };

    template <typename Spec, typename Arg, typename Tail>
    struct make_item
    {
        typedef boost::parameter::aux
        ::item<Spec,Arg,typename Tail::type> type;
    };
}}}
# 11 "/usr/include/boost/parameter/aux_/pack/make_items.hpp" 2 3 4
# 22 "/usr/include/boost/parameter/aux_/pack/make_items.hpp" 3 4
namespace boost { namespace parameter { namespace aux {


    template <typename Spec, typename Arg, typename Tail>

    using make_items = ::boost::mp11::mp_if<
        ::std::is_same<Arg,::boost::parameter::void_>
      , ::boost::mp11::mp_identity< ::boost::parameter::void_>
      , ::boost::parameter::aux::make_item<Spec,Arg,Tail>
    >;
# 42 "/usr/include/boost/parameter/aux_/pack/make_items.hpp" 3 4
}}}
# 218 "/usr/include/boost/parameter/aux_/pack/make_parameter_spec_items.hpp" 2 3 4

namespace boost { namespace parameter { namespace aux {

    template <typename SpecSeq, typename A0, typename ...Args>
    struct make_parameter_spec_items_helper<SpecSeq,A0,Args...>
      : ::boost::parameter::aux::make_items<

            ::boost::mp11::mp_front<SpecSeq>



          , A0
          , ::boost::parameter::aux::make_parameter_spec_items<

                ::boost::mp11::mp_pop_front<SpecSeq>



              , Args...
            >
        >
    {
    };
}}}
# 86 "/usr/include/boost/parameter/parameters.hpp" 2 3 4
# 1 "/usr/include/boost/parameter/aux_/pack/tag_keyword_arg.hpp" 1 3 4








# 1 "/usr/include/boost/parameter/aux_/tag.hpp" 1 3 4
# 10 "/usr/include/boost/parameter/aux_/tag.hpp" 3 4
# 1 "/usr/include/boost/parameter/aux_/unwrap_cv_reference.hpp" 1 3 4
# 10 "/usr/include/boost/parameter/aux_/unwrap_cv_reference.hpp" 3 4
namespace boost {

    template <typename T>
    class reference_wrapper;
}



namespace boost { namespace parameter { namespace aux {







    template <typename U>
    ::boost::parameter::aux::yes_tag
        is_cv_reference_wrapper_check(
            ::boost::reference_wrapper<U> const volatile*
        );

    ::boost::parameter::aux::no_tag is_cv_reference_wrapper_check(...);
}}}






namespace boost { namespace parameter { namespace aux {


    template <typename U>
    ::boost::parameter::aux::yes_tag
        is_cv_reference_wrapper_check(
            ::std::reference_wrapper<U> const volatile*
        );
}}}
# 69 "/usr/include/boost/parameter/aux_/unwrap_cv_reference.hpp" 3 4
namespace boost { namespace parameter { namespace aux {







    template <typename T>
    using is_cv_reference_wrapper = ::boost::mp11::mp_bool<
        sizeof(
            ::boost::parameter::aux::is_cv_reference_wrapper_check(
                static_cast<
                    typename ::std::remove_reference<T>::type*
                >(nullptr)
            )
        ) == sizeof(::boost::parameter::aux::yes_tag)
    >;



    template <typename T>
    using unwrap_cv_reference_impl = typename ::std::remove_reference<T>::type;




    template <typename T>
    using unwrap_cv_reference = ::boost::mp11::mp_eval_if<
        ::boost::parameter::aux::is_cv_reference_wrapper<T>
      , ::boost::parameter::aux::unwrap_cv_reference_impl<T>
      , ::std::remove_reference
      , T
    >;
# 171 "/usr/include/boost/parameter/aux_/unwrap_cv_reference.hpp" 3 4
}}}
# 11 "/usr/include/boost/parameter/aux_/tag.hpp" 2 3 4
# 1 "/usr/include/boost/parameter/aux_/tagged_argument.hpp" 1 3 4
# 10 "/usr/include/boost/parameter/aux_/tagged_argument.hpp" 3 4
namespace boost { namespace parameter { namespace aux {

    struct error_const_lvalue_bound_to_out_parameter;
    struct error_lvalue_bound_to_consume_parameter;
    struct error_rvalue_bound_to_out_parameter;
}}}
# 29 "/usr/include/boost/parameter/aux_/tagged_argument.hpp" 3 4
namespace boost { namespace parameter { namespace aux {

    template <typename Keyword, typename Arg>

    using tagged_argument_type = ::boost::mp11::mp_if<
        ::boost::mp11::mp_if<
            ::std::is_scalar<Arg>
          , ::boost::mp11::mp_false
          , ::std::is_same<
                typename Keyword::qualifier
              , ::boost::parameter::consume_reference
            >
        >
      , ::boost::parameter::aux::error_lvalue_bound_to_consume_parameter
      , ::boost::mp11::mp_if<
            ::std::is_const<Arg>
          , ::boost::mp11::mp_if<
                ::std::is_same<
                    typename Keyword::qualifier
                  , ::boost::parameter::out_reference
                >
              , ::boost::parameter::aux
                ::error_const_lvalue_bound_to_out_parameter
              , ::std::remove_const<Arg>
            >
          , ::boost::mp11::mp_identity<Arg>
        >
    >;
# 70 "/usr/include/boost/parameter/aux_/tagged_argument.hpp" 3 4
}}}
# 81 "/usr/include/boost/parameter/aux_/tagged_argument.hpp" 3 4
# 1 "/usr/include/boost/mpl/apply_wrap.hpp" 1 3 4
# 82 "/usr/include/boost/parameter/aux_/tagged_argument.hpp" 2 3 4
# 97 "/usr/include/boost/parameter/aux_/tagged_argument.hpp" 3 4
namespace boost { namespace parameter { namespace aux {



    template <typename Keyword, typename Arg>
    class tagged_argument
      : public ::boost::parameter::aux::tagged_argument_base
    {

        using arg_type = typename ::boost::parameter::aux
        ::tagged_argument_type<Keyword,Arg>::type;
# 127 "/usr/include/boost/parameter/aux_/tagged_argument.hpp" 3 4
     public:
        typedef Keyword key_type;




        using value_type = ::boost::mp11::mp_if<
            ::std::is_function<arg_type>
          , ::std::function<arg_type>
          , Arg
        >;
# 156 "/usr/include/boost/parameter/aux_/tagged_argument.hpp" 3 4
        using reference = ::boost::mp11::mp_if<
            ::std::is_function<arg_type>
          , value_type const&
          , Arg&
        >;
# 169 "/usr/include/boost/parameter/aux_/tagged_argument.hpp" 3 4
     private:



        ::boost::mp11::mp_if<
            ::std::is_function<arg_type>
          , value_type
          , reference
        > value;
# 186 "/usr/include/boost/parameter/aux_/tagged_argument.hpp" 3 4
     public:
        inline explicit constexpr tagged_argument(reference x)
          : value(x)
        {
        }

        inline constexpr tagged_argument(tagged_argument const& copy)
          : value(copy.value)
        {
        }




        struct binding
        {
            template <typename KW, typename Default, typename Reference>
            struct apply
              : ::boost::mpl::eval_if<
                    ::boost::is_same<KW,key_type>
                  , ::boost::mpl::if_<Reference,reference,value_type>
                  , ::boost::mpl::identity<Default>
                >
            {
            };


            template <typename KW, typename Default, typename Reference>
            using fn = ::boost::mp11::mp_if<
                ::std::is_same<KW,key_type>
              , ::boost::mp11::mp_if<Reference,reference,value_type>
              , Default
            >;

        };
# 278 "/usr/include/boost/parameter/aux_/tagged_argument.hpp" 3 4
        inline constexpr reference get_value() const
        {
            return this->value;
        }

        inline constexpr reference
            operator[](::boost::parameter::keyword<Keyword> const&) const
        {
            return this->get_value();
        }

        template <typename Default>
        inline constexpr reference
            operator[](
                ::boost::parameter::aux::default_<key_type,Default> const&
            ) const
        {
            return this->get_value();
        }

        template <typename Default>
        inline constexpr reference
            operator[](
                ::boost::parameter::aux::default_r_<key_type,Default> const&
            ) const
        {
            return this->get_value();
        }

        template <typename F>
        inline constexpr reference
            operator[](
                ::boost::parameter::aux::lazy_default<key_type,F> const&
            ) const
        {
            return this->get_value();
        }

        template <typename KW, typename Default>
        inline constexpr Default&
            operator[](
                ::boost::parameter::aux::default_<KW,Default> const& x
            ) const
        {
            return x.value;
        }

        template <typename KW, typename Default>
        inline constexpr Default&&
            operator[](
                ::boost::parameter::aux::default_r_<KW,Default> const& x
            ) const
        {
            return ::std::forward<Default>(x.value);
        }

        template <typename KW, typename F>
        inline constexpr
        typename ::boost::parameter::aux::result_of0<F>::type
            operator[](
                ::boost::parameter::aux::lazy_default<KW,F> const& x
            ) const
        {
            return x.compute_default();
        }

        template <typename ParameterRequirements>
        static constexpr typename ParameterRequirements::has_default
            satisfies(ParameterRequirements*);

        template <typename HasDefault, typename Predicate>
        static constexpr
        typename ::boost::mpl::apply_wrap1<Predicate,value_type>::type
            satisfies(
                ::boost::parameter::aux::parameter_requirements<
                    key_type
                  , Predicate
                  , HasDefault
                >*
            );



        typedef ::boost::parameter::aux::tagged_argument<Keyword,Arg> type;

        typedef ::boost::parameter::aux::empty_arg_list tail_type;

        typedef ::boost::parameter::aux::arg_list_tag tag;
    };


    template <typename Keyword>
    using tagged_argument_rref_key = ::boost::mp11::mp_if<
        ::std::is_same<
            typename Keyword::qualifier
          , ::boost::parameter::out_reference
        >
      , ::boost::parameter::aux::error_rvalue_bound_to_out_parameter
      , ::boost::mp11::mp_identity<Keyword>
    >;




    template <typename Keyword, typename Arg>
    struct tagged_argument_rref
      : ::boost::parameter::aux::tagged_argument_base
    {

        using key_type = typename ::boost::parameter::aux
        ::tagged_argument_rref_key<Keyword>::type;
# 399 "/usr/include/boost/parameter/aux_/tagged_argument.hpp" 3 4
        typedef Arg value_type;
        typedef Arg&& reference;

     private:
        reference value;

     public:
        inline explicit constexpr tagged_argument_rref(reference x)
          : value(::std::forward<Arg>(x))
        {
        }

        inline constexpr tagged_argument_rref(
            tagged_argument_rref const& copy
        ) : value(::std::forward<Arg>(copy.value))
        {
        }




        struct binding
        {
            template <typename KW, typename Default, typename Reference>
            struct apply
            {
                typedef typename ::boost::mpl::eval_if<
                    ::boost::is_same<KW,key_type>
                  , ::boost::mpl::if_<Reference,reference,value_type>
                  , ::boost::mpl::identity<Default>
                >::type type;
            };


            template <typename KW, typename Default, typename Reference>
            using fn = ::boost::mp11::mp_if<
                ::std::is_same<KW,key_type>
              , ::boost::mp11::mp_if<Reference,reference,value_type>
              , Default
            >;

        };
# 501 "/usr/include/boost/parameter/aux_/tagged_argument.hpp" 3 4
        inline constexpr reference get_value() const
        {
            return ::std::forward<Arg>(this->value);
        }

        inline constexpr reference
            operator[](::boost::parameter::keyword<Keyword> const&) const
        {
            return this->get_value();
        }

        template <typename Default>
        inline constexpr reference
            operator[](
                ::boost::parameter::aux::default_<key_type,Default> const&
            ) const
        {
            return this->get_value();
        }

        template <typename Default>
        inline constexpr reference
            operator[](
                ::boost::parameter::aux::default_r_<key_type,Default> const&
            ) const
        {
            return this->get_value();
        }

        template <typename F>
        inline constexpr reference
            operator[](
                ::boost::parameter::aux::lazy_default<key_type,F> const&
            ) const
        {
            return this->get_value();
        }

        template <typename KW, typename Default>
        inline constexpr Default&
            operator[](
                ::boost::parameter::aux::default_<KW,Default> const& x
            ) const
        {
            return x.value;
        }

        template <typename KW, typename Default>
        inline constexpr Default&&
            operator[](
                ::boost::parameter::aux::default_r_<KW,Default> const& x
            ) const
        {
            return ::std::forward<Default>(x.value);
        }

        template <typename KW, typename F>
        inline constexpr
        typename ::boost::parameter::aux::result_of0<F>::type
            operator[](
                ::boost::parameter::aux::lazy_default<KW,F> const& x
            ) const
        {
            return x.compute_default();
        }

        template <typename ParameterRequirements>
        static constexpr typename ParameterRequirements::has_default
            satisfies(ParameterRequirements*);

        template <typename HasDefault, typename Predicate>
        static constexpr
        typename ::boost::mpl::apply_wrap1<Predicate,value_type>::type
            satisfies(
                ::boost::parameter::aux::parameter_requirements<
                    key_type
                  , Predicate
                  , HasDefault
                >*
            );



        typedef ::boost::parameter::aux
        ::tagged_argument_rref<Keyword,Arg> type;

        typedef ::boost::parameter::aux::empty_arg_list tail_type;

        typedef ::boost::parameter::aux::arg_list_tag tag;
    };
}}}
# 850 "/usr/include/boost/parameter/aux_/tagged_argument.hpp" 3 4
namespace boost { namespace parameter { namespace aux {

    template <typename TaggedArg>
    struct tagged_argument_list_of_1 : public TaggedArg
    {
        using base_type = TaggedArg;

        inline explicit constexpr tagged_argument_list_of_1(
            typename base_type::reference x
        ) : base_type(static_cast<typename base_type::reference>(x))
        {
        }

        inline constexpr tagged_argument_list_of_1(
            tagged_argument_list_of_1 const& copy
        ) : base_type(static_cast<base_type const&>(copy))
        {
        }

        using base_type::operator[];
        using base_type::satisfies;

        template <typename TA2>
        inline constexpr ::boost::parameter::aux::flat_like_arg_list<
            ::boost::parameter::aux
            ::flat_like_arg_tuple<typename TaggedArg::key_type,TaggedArg>
          , ::boost::parameter::aux::flat_like_arg_tuple<
                typename TA2::base_type::key_type
              , typename TA2::base_type
            >
        >
            operator,(TA2 const& x) const
        {
            return boost::parameter::aux::flat_like_arg_list<
                ::boost::parameter::aux
                ::flat_like_arg_tuple<typename TaggedArg::key_type,TaggedArg>
              , ::boost::parameter::aux::flat_like_arg_tuple<
                    typename TA2::base_type::key_type
                  , typename TA2::base_type
                >
            >(
                static_cast<base_type const&>(*this)
              , ::boost::parameter::aux::arg_list<typename TA2::base_type>(
                    static_cast<typename TA2::base_type const&>(x)
                  , ::boost::parameter::aux::empty_arg_list()
                )
            );
        }
    };
}}}
# 12 "/usr/include/boost/parameter/aux_/tag.hpp" 2 3 4
# 22 "/usr/include/boost/parameter/aux_/tag.hpp" 3 4
namespace boost { namespace parameter { namespace aux {

    template <typename Keyword, typename Arg>
    struct tag_if_lvalue_reference
    {
        using type = ::boost::parameter::aux::tagged_argument_list_of_1<
            ::boost::parameter::aux::tagged_argument<
                Keyword
              , typename ::boost::parameter::aux
                ::unwrap_cv_reference<Arg>::type
            >
        >;
    };

    template <typename Keyword, typename Arg>
    struct tag_if_scalar
    {
        using type = ::boost::parameter::aux::tagged_argument_list_of_1<
            ::boost::parameter::aux
            ::tagged_argument<Keyword,typename ::std::add_const<Arg>::type>
        >;
    };

    template <typename Keyword, typename Arg>
    using tag_if_otherwise = ::boost::mp11::mp_if<
        ::std::is_scalar<typename ::std::remove_const<Arg>::type>
      , ::boost::parameter::aux::tag_if_scalar<Keyword,Arg>
      , ::boost::mp11::mp_identity<
            ::boost::parameter::aux::tagged_argument_list_of_1<
                ::boost::parameter::aux::tagged_argument_rref<Keyword,Arg>
            >
        >
    >;

    template <typename Keyword, typename Arg>
    using tag = ::boost::mp11::mp_if<
        ::boost::mp11::mp_if<
            ::std::is_lvalue_reference<Arg>
          , ::boost::mp11::mp_true
          , ::boost::parameter::aux::is_cv_reference_wrapper<Arg>
        >
      , ::boost::parameter::aux::tag_if_lvalue_reference<Keyword,Arg>
      , ::boost::parameter::aux::tag_if_otherwise<Keyword,Arg>
    >;
}}}
# 10 "/usr/include/boost/parameter/aux_/pack/tag_keyword_arg.hpp" 2 3 4


namespace boost { namespace parameter { namespace aux {

    struct tag_keyword_arg
    {
        template <typename K, typename T>
        struct apply
        {
            typedef typename ::boost::parameter::aux::tag<K,T>::type type;
        };


        template <typename K, typename T>
        using fn = typename ::boost::parameter::aux::tag<K,T>::type;

    };
}}}
# 87 "/usr/include/boost/parameter/parameters.hpp" 2 3 4
# 1 "/usr/include/boost/parameter/aux_/pack/tag_template_keyword_arg.hpp" 1 3 4
# 12 "/usr/include/boost/parameter/aux_/pack/tag_template_keyword_arg.hpp" 3 4
namespace boost { namespace parameter { namespace aux {

    struct tag_template_keyword_arg
    {
        template <typename K, typename T>
        struct apply
        {
            typedef ::boost::parameter::template_keyword<K,T> type;
        };


        template <typename K, typename T>
        using fn = ::boost::parameter::template_keyword<K,T>;

    };
}}}
# 88 "/usr/include/boost/parameter/parameters.hpp" 2 3 4
# 130 "/usr/include/boost/parameter/parameters.hpp" 3 4
namespace boost { namespace parameter {

    template <typename ...Spec>
    struct parameters
    {
        typedef ::boost::mp11::mp_list<Spec...> parameter_spec;

        typedef typename ::boost::parameter::aux
        ::make_deduced_list<parameter_spec>::type deduced_list;





        template <typename ArgumentPackAndError>
        struct match_base
# 158 "/usr/include/boost/parameter/parameters.hpp" 3 4
        {

            using type = ::boost::mp11::mp_if<
                typename ::boost::parameter::aux::match_parameters_base_cond<
                    ArgumentPackAndError
                  , parameter_spec
                >::type
              , ::boost::mp11::mp_identity<
                    ::boost::parameter::parameters<Spec...>
                >
              , ::boost::parameter::void_
            >;

        };



        template <typename ...Args>
        struct match
          : ::boost::parameter::parameters<Spec...>
            ::template match_base<
                typename ::boost::parameter::aux::make_arg_list<
                    typename ::boost::parameter::aux
                    ::make_parameter_spec_items<parameter_spec,Args...>::type
                  , deduced_list
                  , ::boost::parameter::aux::tag_keyword_arg


                  , ::boost::mp11::mp_false



                >::type
            >::type
        {
        };


        template <typename ...Args>
        struct bind
# 208 "/usr/include/boost/parameter/parameters.hpp" 3 4
        {

            using type = ::boost::mp11::mp_at_c<
                typename ::boost::parameter::aux::make_arg_list<
                    typename ::boost::parameter::aux
                    ::make_parameter_spec_items<parameter_spec,Args...>::type
                  , deduced_list
                  , ::boost::parameter::aux::tag_template_keyword_arg
                >::type
              , 0
            >;

        };




        inline ::boost::parameter::aux::empty_arg_list operator()() const
        {
            return ::boost::parameter::aux::empty_arg_list();
        }

        template <typename A0, typename ...Args>

        inline ::boost::mp11::mp_at_c<



            typename ::boost::parameter::aux::make_arg_list<
                typename ::boost::parameter::aux
                ::make_parameter_spec_items<parameter_spec,A0,Args...>::type
              , deduced_list
              , ::boost::parameter::aux::tag_keyword_arg
            >::type

          , 0
        >



            operator()(A0&& a0, Args&& ...args) const
        {
            typedef typename ::boost::parameter::aux::make_arg_list<
                typename ::boost::parameter::aux
                ::make_parameter_spec_items<parameter_spec,A0,Args...>::type
              , deduced_list
              , ::boost::parameter::aux::tag_keyword_arg
            >::type list_error_pair;


            using result_type = ::boost::mp11::mp_at_c<list_error_pair,0>;

            using error = ::boost::mp11::mp_at_c<list_error_pair,1>;
# 269 "/usr/include/boost/parameter/parameters.hpp" 3 4
            error();

            return ::boost::parameter::aux
            ::arg_list_factory<result_type,A0,Args...>::reverse(
                ::std::forward<A0>(a0)
              , ::std::forward<Args>(args)...
            );
        }
    };
}}
# 18 "/usr/include/boost/lockfree/detail/parameter.hpp" 2 3 4





namespace boost {
namespace lockfree {
namespace detail {

namespace mpl = boost::mpl;

template <typename bound_args, typename tag_type>
struct has_arg
{
    typedef typename parameter::binding<bound_args, tag_type, mpl::void_>::type type;
    static const bool value = mpl::is_not_void_<type>::type::value;
};


template <typename bound_args>
struct extract_capacity
{
    static const bool has_capacity = has_arg<bound_args, tag::capacity>::value;

    typedef typename mpl::if_c<has_capacity,
                               typename has_arg<bound_args, tag::capacity>::type,
                               mpl::size_t< 0 >
                              >::type capacity_t;

    static const std::size_t capacity = capacity_t::value;
};


template <typename bound_args, typename T>
struct extract_allocator
{
    static const bool has_allocator = has_arg<bound_args, tag::allocator>::value;

    typedef typename mpl::if_c<has_allocator,
                               typename has_arg<bound_args, tag::allocator>::type,
                               boost::alignment::aligned_allocator<T, 64>
                              >::type allocator_arg;

    typedef typename boost::allocator_rebind<allocator_arg, T>::type type;
};

template <typename bound_args, bool default_ = false>
struct extract_fixed_sized
{
    static const bool has_fixed_sized = has_arg<bound_args, tag::fixed_sized>::value;

    typedef typename mpl::if_c<has_fixed_sized,
                               typename has_arg<bound_args, tag::fixed_sized>::type,
                               mpl::bool_<default_>
                              >::type type;

    static const bool value = type::value;
};


}
}
}
# 31 "/usr/include/boost/lockfree/spsc_queue.hpp" 2 3 4


# 1 "/usr/include/boost/lockfree/lockfree_forward.hpp" 1 3 4
# 22 "/usr/include/boost/lockfree/lockfree_forward.hpp" 3 4
namespace boost {
namespace lockfree {


template <bool IsFixedSized>
struct fixed_sized;

template <size_t Size>
struct capacity;

template <class Alloc>
struct allocator;
# 44 "/usr/include/boost/lockfree/lockfree_forward.hpp" 3 4
template <typename T, typename ...Options>

class queue;







template <typename T, typename ...Options>

class stack;






template <typename T, typename ...Options>

class spsc_queue;

}
}
# 34 "/usr/include/boost/lockfree/spsc_queue.hpp" 2 3 4





namespace boost {
namespace lockfree {
namespace detail {

typedef parameter::parameters<boost::parameter::optional<tag::capacity>,
                              boost::parameter::optional<tag::allocator>
                             > ringbuffer_signature;

template <typename T>
class ringbuffer_base
{

protected:
    typedef std::size_t size_t;
    static const int padding_size = 64 - sizeof(size_t);
    atomic<size_t> write_index_;
    char padding1[padding_size];
    atomic<size_t> read_index_;

    ringbuffer_base(ringbuffer_base const&) = delete;
    ringbuffer_base& operator= (ringbuffer_base const&) = delete;

protected:
    ringbuffer_base(void):
        write_index_(0), read_index_(0)
    {}

    static size_t next_index(size_t arg, size_t max_size)
    {
        size_t ret = arg + 1;
        while (__builtin_expect(ret >= max_size, 0))
            ret -= max_size;
        return ret;
    }

    static size_t read_available(size_t write_index, size_t read_index, size_t max_size)
    {
        if (write_index >= read_index)
            return write_index - read_index;

        const size_t ret = write_index + max_size - read_index;
        return ret;
    }

    static size_t write_available(size_t write_index, size_t read_index, size_t max_size)
    {
        size_t ret = read_index - write_index - 1;
        if (write_index >= read_index)
            ret += max_size;
        return ret;
    }

    size_t read_available(size_t max_size) const
    {
        size_t write_index = write_index_.load(memory_order_acquire);
        const size_t read_index = read_index_.load(memory_order_relaxed);
        return read_available(write_index, read_index, max_size);
    }

    size_t write_available(size_t max_size) const
    {
        size_t write_index = write_index_.load(memory_order_relaxed);
        const size_t read_index = read_index_.load(memory_order_acquire);
        return write_available(write_index, read_index, max_size);
    }

    bool push(T const & t, T * buffer, size_t max_size)
    {
        const size_t write_index = write_index_.load(memory_order_relaxed);
        const size_t next = next_index(write_index, max_size);

        if (next == read_index_.load(memory_order_acquire))
            return false;

        new (buffer + write_index) T(t);

        write_index_.store(next, memory_order_release);

        return true;
    }

    size_t push(const T * input_buffer, size_t input_count, T * internal_buffer, size_t max_size)
    {
        return push(input_buffer, input_buffer + input_count, internal_buffer, max_size) - input_buffer;
    }

    template <typename ConstIterator>
    ConstIterator push(ConstIterator begin, ConstIterator end, T * internal_buffer, size_t max_size)
    {


        const size_t write_index = write_index_.load(memory_order_relaxed);
        const size_t read_index = read_index_.load(memory_order_acquire);
        const size_t avail = write_available(write_index, read_index, max_size);

        if (avail == 0)
            return begin;

        size_t input_count = std::distance(begin, end);
        input_count = (std::min)(input_count, avail);

        size_t new_write_index = write_index + input_count;

        const ConstIterator last = boost::next(begin, input_count);

        if (write_index + input_count > max_size) {

            const size_t count0 = max_size - write_index;
            const ConstIterator midpoint = boost::next(begin, count0);

            std::uninitialized_copy(begin, midpoint, internal_buffer + write_index);
            std::uninitialized_copy(midpoint, last, internal_buffer);
            new_write_index -= max_size;
        } else {
            std::uninitialized_copy(begin, last, internal_buffer + write_index);

            if (new_write_index == max_size)
                new_write_index = 0;
        }

        write_index_.store(new_write_index, memory_order_release);
        return last;
    }

    template <typename Functor>
    bool consume_one(Functor & functor, T * buffer, size_t max_size)
    {
        const size_t write_index = write_index_.load(memory_order_acquire);
        const size_t read_index = read_index_.load(memory_order_relaxed);
        if ( empty(write_index, read_index) )
            return false;

        T & object_to_consume = buffer[read_index];
        functor( object_to_consume );
        object_to_consume.~T();

        size_t next = next_index(read_index, max_size);
        read_index_.store(next, memory_order_release);
        return true;
    }

    template <typename Functor>
    bool consume_one(Functor const & functor, T * buffer, size_t max_size)
    {
        const size_t write_index = write_index_.load(memory_order_acquire);
        const size_t read_index = read_index_.load(memory_order_relaxed);
        if ( empty(write_index, read_index) )
            return false;

        T & object_to_consume = buffer[read_index];
        functor( object_to_consume );
        object_to_consume.~T();

        size_t next = next_index(read_index, max_size);
        read_index_.store(next, memory_order_release);
        return true;
    }

    template <typename Functor>
    size_t consume_all (Functor const & functor, T * internal_buffer, size_t max_size)
    {
        const size_t write_index = write_index_.load(memory_order_acquire);
        const size_t read_index = read_index_.load(memory_order_relaxed);

        const size_t avail = read_available(write_index, read_index, max_size);

        if (avail == 0)
            return 0;

        const size_t output_count = avail;

        size_t new_read_index = read_index + output_count;

        if (read_index + output_count > max_size) {

            const size_t count0 = max_size - read_index;
            const size_t count1 = output_count - count0;

            run_functor_and_delete(internal_buffer + read_index, internal_buffer + max_size, functor);
            run_functor_and_delete(internal_buffer, internal_buffer + count1, functor);

            new_read_index -= max_size;
        } else {
            run_functor_and_delete(internal_buffer + read_index, internal_buffer + read_index + output_count, functor);

            if (new_read_index == max_size)
                new_read_index = 0;
        }

        read_index_.store(new_read_index, memory_order_release);
        return output_count;
    }

    template <typename Functor>
    size_t consume_all (Functor & functor, T * internal_buffer, size_t max_size)
    {
        const size_t write_index = write_index_.load(memory_order_acquire);
        const size_t read_index = read_index_.load(memory_order_relaxed);

        const size_t avail = read_available(write_index, read_index, max_size);

        if (avail == 0)
            return 0;

        const size_t output_count = avail;

        size_t new_read_index = read_index + output_count;

        if (read_index + output_count > max_size) {

            const size_t count0 = max_size - read_index;
            const size_t count1 = output_count - count0;

            run_functor_and_delete(internal_buffer + read_index, internal_buffer + max_size, functor);
            run_functor_and_delete(internal_buffer, internal_buffer + count1, functor);

            new_read_index -= max_size;
        } else {
            run_functor_and_delete(internal_buffer + read_index, internal_buffer + read_index + output_count, functor);

            if (new_read_index == max_size)
                new_read_index = 0;
        }

        read_index_.store(new_read_index, memory_order_release);
        return output_count;
    }

    size_t pop (T * output_buffer, size_t output_count, T * internal_buffer, size_t max_size)
    {
        const size_t write_index = write_index_.load(memory_order_acquire);
        const size_t read_index = read_index_.load(memory_order_relaxed);

        const size_t avail = read_available(write_index, read_index, max_size);

        if (avail == 0)
            return 0;

        output_count = (std::min)(output_count, avail);

        size_t new_read_index = read_index + output_count;

        if (read_index + output_count > max_size) {

            const size_t count0 = max_size - read_index;
            const size_t count1 = output_count - count0;

            copy_and_delete(internal_buffer + read_index, internal_buffer + max_size, output_buffer);
            copy_and_delete(internal_buffer, internal_buffer + count1, output_buffer + count0);

            new_read_index -= max_size;
        } else {
            copy_and_delete(internal_buffer + read_index, internal_buffer + read_index + output_count, output_buffer);
            if (new_read_index == max_size)
                new_read_index = 0;
        }

        read_index_.store(new_read_index, memory_order_release);
        return output_count;
    }

    template <typename OutputIterator>
    size_t pop_to_output_iterator (OutputIterator it, T * internal_buffer, size_t max_size)
    {
        const size_t write_index = write_index_.load(memory_order_acquire);
        const size_t read_index = read_index_.load(memory_order_relaxed);

        const size_t avail = read_available(write_index, read_index, max_size);
        if (avail == 0)
            return 0;

        size_t new_read_index = read_index + avail;

        if (read_index + avail > max_size) {

            const size_t count0 = max_size - read_index;
            const size_t count1 = avail - count0;

            it = copy_and_delete(internal_buffer + read_index, internal_buffer + max_size, it);
            copy_and_delete(internal_buffer, internal_buffer + count1, it);

            new_read_index -= max_size;
        } else {
            copy_and_delete(internal_buffer + read_index, internal_buffer + read_index + avail, it);
            if (new_read_index == max_size)
                new_read_index = 0;
        }

        read_index_.store(new_read_index, memory_order_release);
        return avail;
    }

    const T& front(const T * internal_buffer) const
    {
        const size_t read_index = read_index_.load(memory_order_relaxed);
        return *(internal_buffer + read_index);
    }

    T& front(T * internal_buffer)
    {
        const size_t read_index = read_index_.load(memory_order_relaxed);
        return *(internal_buffer + read_index);
    }



public:




    void reset(void)
    {
        if ( !boost::has_trivial_destructor<T>::value ) {


            detail::consume_noop consume_functor;
            (void)consume_all( consume_functor );
        } else {
            write_index_.store(0, memory_order_relaxed);
            read_index_.store(0, memory_order_release);
        }
    }






    bool empty(void)
    {
        return empty(write_index_.load(memory_order_relaxed), read_index_.load(memory_order_relaxed));
    }





    bool is_lock_free(void) const
    {
        return write_index_.is_lock_free() && read_index_.is_lock_free();
    }

private:
    bool empty(size_t write_index, size_t read_index)
    {
        return write_index == read_index;
    }

    template< class OutputIterator >
    OutputIterator copy_and_delete( T * first, T * last, OutputIterator out )
    {
        if (boost::has_trivial_destructor<T>::value) {
            return std::copy(first, last, out);
        } else {
            for (; first != last; ++first, ++out) {
                *out = *first;
                first->~T();
            }
            return out;
        }
    }

    template< class Functor >
    void run_functor_and_delete( T * first, T * last, Functor & functor )
    {
        for (; first != last; ++first) {
            functor(*first);
            first->~T();
        }
    }

    template< class Functor >
    void run_functor_and_delete( T * first, T * last, Functor const & functor )
    {
        for (; first != last; ++first) {
            functor(*first);
            first->~T();
        }
    }
};

template <typename T, std::size_t MaxSize>
class compile_time_sized_ringbuffer:
    public ringbuffer_base<T>
{
    typedef std::size_t size_type;
    static const std::size_t max_size = MaxSize + 1;

    typedef typename boost::aligned_storage<max_size * sizeof(T),
                                            boost::alignment_of<T>::value
                                           >::type storage_type;

    storage_type storage_;

    T * data()
    {
        return static_cast<T*>(storage_.address());
    }

    const T * data() const
    {
        return static_cast<const T*>(storage_.address());
    }

protected:
    size_type max_number_of_elements() const
    {
        return max_size;
    }

    ~compile_time_sized_ringbuffer(void)
    {

        detail::consume_noop consume_functor;
        (void)consume_all(consume_functor);
    }

public:
    bool push(T const & t)
    {
        return ringbuffer_base<T>::push(t, data(), max_size);
    }

    template <typename Functor>
    bool consume_one(Functor & f)
    {
        return ringbuffer_base<T>::consume_one(f, data(), max_size);
    }

    template <typename Functor>
    bool consume_one(Functor const & f)
    {
        return ringbuffer_base<T>::consume_one(f, data(), max_size);
    }

    template <typename Functor>
    size_type consume_all(Functor & f)
    {
        return ringbuffer_base<T>::consume_all(f, data(), max_size);
    }

    template <typename Functor>
    size_type consume_all(Functor const & f)
    {
        return ringbuffer_base<T>::consume_all(f, data(), max_size);
    }

    size_type push(T const * t, size_type size)
    {
        return ringbuffer_base<T>::push(t, size, data(), max_size);
    }

    template <size_type size>
    size_type push(T const (&t)[size])
    {
        return push(t, size);
    }

    template <typename ConstIterator>
    ConstIterator push(ConstIterator begin, ConstIterator end)
    {
        return ringbuffer_base<T>::push(begin, end, data(), max_size);
    }

    size_type pop(T * ret, size_type size)
    {
        return ringbuffer_base<T>::pop(ret, size, data(), max_size);
    }

    template <typename OutputIterator>
    size_type pop_to_output_iterator(OutputIterator it)
    {
        return ringbuffer_base<T>::pop_to_output_iterator(it, data(), max_size);
    }

    const T& front(void) const
    {
        return ringbuffer_base<T>::front(data());
    }

    T& front(void)
    {
        return ringbuffer_base<T>::front(data());
    }
};

template <typename T, typename Alloc>
class runtime_sized_ringbuffer:
    public ringbuffer_base<T>,
    private Alloc
{
    typedef std::size_t size_type;
    size_type max_elements_;



    typedef std::allocator_traits<Alloc> allocator_traits;
    typedef typename allocator_traits::pointer pointer;

    pointer array_;

protected:
    size_type max_number_of_elements() const
    {
        return max_elements_;
    }

public:
    explicit runtime_sized_ringbuffer(size_type max_elements):
        max_elements_(max_elements + 1)
    {



        Alloc& alloc = *this;
        array_ = allocator_traits::allocate(alloc, max_elements_);

    }

    template <typename U>
    runtime_sized_ringbuffer(typename boost::allocator_rebind<Alloc, U>::type const & alloc, size_type max_elements):
        Alloc(alloc), max_elements_(max_elements + 1)
    {



        Alloc& allocator = *this;
        array_ = allocator_traits::allocate(allocator, max_elements_);

    }

    runtime_sized_ringbuffer(Alloc const & alloc, size_type max_elements):
        Alloc(alloc), max_elements_(max_elements + 1)
    {



        Alloc& allocator = *this;
        array_ = allocator_traits::allocate(allocator, max_elements_);

    }

    ~runtime_sized_ringbuffer(void)
    {

        detail::consume_noop consume_functor;
        (void)consume_all(consume_functor);




        Alloc& allocator = *this;
        allocator_traits::deallocate(allocator, array_, max_elements_);

    }

    bool push(T const & t)
    {
        return ringbuffer_base<T>::push(t, &*array_, max_elements_);
    }

    template <typename Functor>
    bool consume_one(Functor & f)
    {
        return ringbuffer_base<T>::consume_one(f, &*array_, max_elements_);
    }

    template <typename Functor>
    bool consume_one(Functor const & f)
    {
        return ringbuffer_base<T>::consume_one(f, &*array_, max_elements_);
    }

    template <typename Functor>
    size_type consume_all(Functor & f)
    {
        return ringbuffer_base<T>::consume_all(f, &*array_, max_elements_);
    }

    template <typename Functor>
    size_type consume_all(Functor const & f)
    {
        return ringbuffer_base<T>::consume_all(f, &*array_, max_elements_);
    }

    size_type push(T const * t, size_type size)
    {
        return ringbuffer_base<T>::push(t, size, &*array_, max_elements_);
    }

    template <size_type size>
    size_type push(T const (&t)[size])
    {
        return push(t, size);
    }

    template <typename ConstIterator>
    ConstIterator push(ConstIterator begin, ConstIterator end)
    {
        return ringbuffer_base<T>::push(begin, end, &*array_, max_elements_);
    }

    size_type pop(T * ret, size_type size)
    {
        return ringbuffer_base<T>::pop(ret, size, &*array_, max_elements_);
    }

    template <typename OutputIterator>
    size_type pop_to_output_iterator(OutputIterator it)
    {
        return ringbuffer_base<T>::pop_to_output_iterator(it, &*array_, max_elements_);
    }

    const T& front(void) const
    {
        return ringbuffer_base<T>::front(&*array_);
    }

    T& front(void)
    {
        return ringbuffer_base<T>::front(&*array_);
    }
};




template <typename T, typename ...Options>

struct make_ringbuffer
{



    typedef typename ringbuffer_signature::bind<Options...>::type bound_args;


    typedef extract_capacity<bound_args> extract_capacity_t;

    static const bool runtime_sized = !extract_capacity_t::has_capacity;
    static const size_t capacity = extract_capacity_t::capacity;

    typedef extract_allocator<bound_args, T> extract_allocator_t;
    typedef typename extract_allocator_t::type allocator;


    static_assert((mpl::if_<mpl::bool_<!runtime_sized>, mpl::bool_<!extract_allocator_t::has_allocator>, mpl::true_ >::type::value), "(mpl::if_<mpl::bool_<!runtime_sized>, mpl::bool_<!extract_allocator_t::has_allocator>, mpl::true_ >::type::value)");




    typedef typename mpl::if_c<runtime_sized,
                               runtime_sized_ringbuffer<T, allocator>,
                               compile_time_sized_ringbuffer<T, capacity>
                              >::type ringbuffer_type;
};


}
# 718 "/usr/include/boost/lockfree/spsc_queue.hpp" 3 4
template <typename T, typename ...Options>

class spsc_queue:



    public detail::make_ringbuffer<T, Options...>::ringbuffer_type

{
private:
# 736 "/usr/include/boost/lockfree/spsc_queue.hpp" 3 4
    typedef typename detail::make_ringbuffer<T, Options...>::ringbuffer_type base_type;
    static const bool runtime_sized = detail::make_ringbuffer<T, Options...>::runtime_sized;
    typedef typename detail::make_ringbuffer<T, Options...>::allocator allocator_arg;



    struct implementation_defined
    {
        typedef allocator_arg allocator;
        typedef std::size_t size_type;
    };


public:
    typedef T value_type;
    typedef typename implementation_defined::allocator allocator;
    typedef typename implementation_defined::size_type size_type;





    spsc_queue(void)
    {


        (static_cast <bool> (!runtime_sized) ? void (0) : __assert_fail ("!runtime_sized", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
    }







    template <typename U>
    explicit spsc_queue(typename boost::allocator_rebind<allocator, U>::type const &)
    {
        static_assert(!runtime_sized, "!runtime_sized");
    }







    explicit spsc_queue(allocator const &)
    {


        (static_cast <bool> (!runtime_sized) ? void (0) : __assert_fail ("!runtime_sized", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
    }





    explicit spsc_queue(size_type element_count):
        base_type(element_count)
    {


        (static_cast <bool> (runtime_sized) ? void (0) : __assert_fail ("runtime_sized", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
    }





    template <typename U>
    spsc_queue(size_type element_count, typename boost::allocator_rebind<allocator, U>::type const & alloc):
        base_type(alloc, element_count)
    {
        static_assert(runtime_sized, "runtime_sized");
    }





    spsc_queue(size_type element_count, allocator_arg const & alloc):
        base_type(alloc, element_count)
    {


        (static_cast <bool> (runtime_sized) ? void (0) : __assert_fail ("runtime_sized", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
    }
# 833 "/usr/include/boost/lockfree/spsc_queue.hpp" 3 4
    bool push(T const & t)
    {
        return base_type::push(t);
    }
# 846 "/usr/include/boost/lockfree/spsc_queue.hpp" 3 4
    bool pop ()
    {
        detail::consume_noop consume_functor;
        return consume_one( consume_functor );
    }
# 860 "/usr/include/boost/lockfree/spsc_queue.hpp" 3 4
    template <typename U>
    typename boost::enable_if<typename is_convertible<T, U>::type, bool>::type
    pop (U & ret)
    {
        detail::consume_via_copy<U> consume_functor(ret);
        return consume_one( consume_functor );
    }
# 875 "/usr/include/boost/lockfree/spsc_queue.hpp" 3 4
    size_type push(T const * t, size_type size)
    {
        return base_type::push(t, size);
    }
# 887 "/usr/include/boost/lockfree/spsc_queue.hpp" 3 4
    template <size_type size>
    size_type push(T const (&t)[size])
    {
        return push(t, size);
    }
# 900 "/usr/include/boost/lockfree/spsc_queue.hpp" 3 4
    template <typename ConstIterator>
    ConstIterator push(ConstIterator begin, ConstIterator end)
    {
        return base_type::push(begin, end);
    }
# 913 "/usr/include/boost/lockfree/spsc_queue.hpp" 3 4
    size_type pop(T * ret, size_type size)
    {
        return base_type::pop(ret, size);
    }
# 925 "/usr/include/boost/lockfree/spsc_queue.hpp" 3 4
    template <size_type size>
    size_type pop(T (&ret)[size])
    {
        return pop(ret, size);
    }
# 938 "/usr/include/boost/lockfree/spsc_queue.hpp" 3 4
    template <typename OutputIterator>
    typename boost::disable_if<typename is_convertible<T, OutputIterator>::type, size_type>::type
    pop(OutputIterator it)
    {
        return base_type::pop_to_output_iterator(it);
    }
# 953 "/usr/include/boost/lockfree/spsc_queue.hpp" 3 4
    template <typename Functor>
    bool consume_one(Functor & f)
    {
        return base_type::consume_one(f);
    }


    template <typename Functor>
    bool consume_one(Functor const & f)
    {
        return base_type::consume_one(f);
    }
# 974 "/usr/include/boost/lockfree/spsc_queue.hpp" 3 4
    template <typename Functor>
    size_type consume_all(Functor & f)
    {
        return base_type::consume_all(f);
    }


    template <typename Functor>
    size_type consume_all(Functor const & f)
    {
        return base_type::consume_all(f);
    }







    size_type read_available() const
    {
        return base_type::read_available(base_type::max_number_of_elements());
    }







    size_type write_available() const
    {
        return base_type::write_available(base_type::max_number_of_elements());
    }
# 1019 "/usr/include/boost/lockfree/spsc_queue.hpp" 3 4
    const T& front() const
    {
        (static_cast <bool> (read_available() > 0) ? void (0) : __assert_fail ("read_available() > 0", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        return base_type::front();
    }


    T& front()
    {
        (static_cast <bool> (read_available() > 0) ? void (0) : __assert_fail ("read_available() > 0", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        return base_type::front();
    }





    void reset(void)
    {
        if ( !boost::has_trivial_destructor<T>::value ) {


            detail::consume_noop consume_functor;
            (void)consume_all(consume_functor);
        } else {
            base_type::write_index_.store(0, memory_order_relaxed);
            base_type::read_index_.store(0, memory_order_release);
        }
   }
};

}
}
# 36 "/home/avi/scylla-maint/seastar/include/seastar/core/smp.hh" 2
# 1 "/usr/include/boost/thread/barrier.hpp" 1 3 4
# 12 "/usr/include/boost/thread/barrier.hpp" 3 4
# 1 "/usr/include/boost/thread/detail/config.hpp" 1 3 4
# 13 "/usr/include/boost/thread/detail/config.hpp" 3 4
# 1 "/usr/include/boost/thread/detail/platform.hpp" 1 3 4
# 17 "/usr/include/boost/thread/detail/platform.hpp" 3 4
# 1 "/usr/include/boost/config/requires_threads.hpp" 1 3 4
# 18 "/usr/include/boost/thread/detail/platform.hpp" 2 3 4
# 14 "/usr/include/boost/thread/detail/config.hpp" 2 3 4
# 1 "/usr/include/boost/thread/detail/thread_safety.hpp" 1 3 4
# 15 "/usr/include/boost/thread/detail/config.hpp" 2 3 4
# 531 "/usr/include/boost/thread/detail/config.hpp" 3 4
# 1 "/usr/include/boost/config/auto_link.hpp" 1 3 4
# 532 "/usr/include/boost/thread/detail/config.hpp" 2 3 4
# 13 "/usr/include/boost/thread/barrier.hpp" 2 3 4
# 1 "/usr/include/boost/thread/detail/delete.hpp" 1 3 4
# 14 "/usr/include/boost/thread/barrier.hpp" 2 3 4


# 1 "/usr/include/boost/thread/mutex.hpp" 1 3 4
# 16 "/usr/include/boost/thread/mutex.hpp" 3 4
# 1 "/usr/include/boost/thread/pthread/mutex.hpp" 1 3 4
# 10 "/usr/include/boost/thread/pthread/mutex.hpp" 3 4
# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 58 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 59 "/usr/include/boost/assert.hpp" 2 3 4
# 11 "/usr/include/boost/thread/pthread/mutex.hpp" 2 3 4


# 1 "/usr/include/boost/core/ignore_unused.hpp" 1 3 4
# 12 "/usr/include/boost/core/ignore_unused.hpp" 3 4
namespace boost {





template <typename... Ts>
inline __attribute__ ((__always_inline__)) constexpr void ignore_unused(Ts&& ...)
{}
# 30 "/usr/include/boost/core/ignore_unused.hpp" 3 4
template <typename... Ts>
inline __attribute__ ((__always_inline__)) constexpr void ignore_unused()
{}
# 98 "/usr/include/boost/core/ignore_unused.hpp" 3 4
}
# 14 "/usr/include/boost/thread/pthread/mutex.hpp" 2 3 4
# 1 "/usr/include/boost/thread/exceptions.hpp" 1 3 4
# 22 "/usr/include/boost/thread/exceptions.hpp" 3 4
# 1 "/usr/include/boost/system/system_error.hpp" 1 3 4








# 1 "/usr/include/boost/system/errc.hpp" 1 3 4
# 13 "/usr/include/boost/system/errc.hpp" 3 4
# 1 "/usr/include/boost/system/detail/errc.hpp" 1 3 4
# 13 "/usr/include/boost/system/detail/errc.hpp" 3 4
# 1 "/usr/include/boost/system/is_error_condition_enum.hpp" 1 3 4
# 13 "/usr/include/boost/system/is_error_condition_enum.hpp" 3 4
namespace boost
{

namespace system
{

class error_condition;

template<class T> struct is_error_condition_enum
{
    static const bool value = false;
};

}

}
# 14 "/usr/include/boost/system/detail/errc.hpp" 2 3 4
# 1 "/usr/include/boost/system/detail/cerrno.hpp" 1 3 4
# 11 "/usr/include/boost/system/detail/cerrno.hpp" 3 4
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cerrno" 1 3 4
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cerrno" 3
# 12 "/usr/include/boost/system/detail/cerrno.hpp" 2 3 4
# 15 "/usr/include/boost/system/detail/errc.hpp" 2 3 4

namespace boost
{

namespace system
{

namespace errc
{

enum errc_t
{
    success = 0,
    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
};

}
# 117 "/usr/include/boost/system/detail/errc.hpp" 3 4
template<> struct is_error_condition_enum<errc::errc_t>
{
    static const bool value = true;
};

}

}
# 14 "/usr/include/boost/system/errc.hpp" 2 3 4
# 1 "/usr/include/boost/system/detail/error_code.hpp" 1 3 4
# 13 "/usr/include/boost/system/detail/error_code.hpp" 3 4
# 1 "/usr/include/boost/system/is_error_code_enum.hpp" 1 3 4
# 13 "/usr/include/boost/system/is_error_code_enum.hpp" 3 4
namespace boost
{

namespace system
{

class error_code;

template<class T> struct is_error_code_enum
{
    static const bool value = false;
};

}

}
# 14 "/usr/include/boost/system/detail/error_code.hpp" 2 3 4
# 1 "/usr/include/boost/system/detail/error_category.hpp" 1 3 4
# 13 "/usr/include/boost/system/detail/error_category.hpp" 3 4
# 1 "/usr/include/boost/system/detail/config.hpp" 1 3 4
# 11 "/usr/include/boost/system/detail/config.hpp" 3 4
# 1 "/usr/include/boost/system/detail/requires_cxx11.hpp" 1 3 4
# 12 "/usr/include/boost/system/detail/config.hpp" 2 3 4
# 14 "/usr/include/boost/system/detail/error_category.hpp" 2 3 4
# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 15 "/usr/include/boost/system/detail/error_category.hpp" 2 3 4
# 26 "/usr/include/boost/system/detail/error_category.hpp" 3 4
namespace boost
{

namespace system
{

class error_category;
class error_code;
class error_condition;

std::size_t hash_value( error_code const & ec );

namespace detail
{

constexpr bool failed_impl( int ev, error_category const & cat );

class std_category;

}


#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wnon-virtual-dtor"







class __attribute__((__visibility__("default"))) error_category
{
private:

    friend std::size_t hash_value( error_code const & ec );
    friend constexpr bool detail::failed_impl( int ev, error_category const & cat );

    friend class error_code;
    friend class error_condition;


public:

    error_category( error_category const & ) = delete;
    error_category& operator=( error_category const & ) = delete;
# 81 "/usr/include/boost/system/detail/error_category.hpp" 3 4
private:

    boost::ulong_long_type id_;

    static std::size_t const stdcat_size_ = 4 * sizeof( void const* );

    union
    {
        mutable unsigned char stdcat_[ stdcat_size_ ];
        void const* stdcat_align_;
    };



    mutable std::atomic< unsigned > sc_init_;







protected:



    ~error_category() = default;
# 121 "/usr/include/boost/system/detail/error_category.hpp" 3 4
    constexpr

    error_category() noexcept: id_( 0 ), stdcat_(), sc_init_()
    {
    }

    explicit

    constexpr

    error_category( boost::ulong_long_type id ) noexcept: id_( id ), stdcat_(), sc_init_()
    {
    }

public:

    virtual const char * name() const noexcept = 0;

    virtual error_condition default_error_condition( int ev ) const noexcept;
    virtual bool equivalent( int code, const error_condition & condition ) const noexcept;
    virtual bool equivalent( const error_code & code, int condition ) const noexcept;

    virtual std::string message( int ev ) const = 0;
    virtual char const * message( int ev, char * buffer, std::size_t len ) const noexcept;

    virtual bool failed( int ev ) const noexcept
    {
        return ev != 0;
    }

    friend constexpr bool operator==( error_category const & lhs, error_category const & rhs ) noexcept
    {
        return rhs.id_ == 0? &lhs == &rhs: lhs.id_ == rhs.id_;
    }

    friend constexpr bool operator!=( error_category const & lhs, error_category const & rhs ) noexcept
    {
        return !( lhs == rhs );
    }

    friend constexpr bool operator<( error_category const & lhs, error_category const & rhs ) noexcept
    {
        if( lhs.id_ < rhs.id_ )
        {
            return true;
        }

        if( lhs.id_ > rhs.id_ )
        {
            return false;
        }

        if( rhs.id_ != 0 )
        {
            return false;
        }

        return std::less<error_category const *>()( &lhs, &rhs );
    }



    void init_stdcat() const;




    operator std::error_category const & () const __attribute__((__visibility__("default")));



};






#pragma GCC diagnostic pop


namespace detail
{

static const boost::ulong_long_type generic_category_id = ( boost::ulong_long_type( 0xB2AB117A ) << 32 ) + 0x257EDFD0;
static const boost::ulong_long_type system_category_id = generic_category_id + 1;
static const boost::ulong_long_type interop_category_id = generic_category_id + 2;

constexpr inline bool failed_impl( int ev, error_category const & cat )
{
    if( cat.id_ == system_category_id || cat.id_ == generic_category_id )
    {
        return ev != 0;
    }
    else
    {
        return cat.failed( ev );
    }
}

}

}

}
# 15 "/usr/include/boost/system/detail/error_code.hpp" 2 3 4
# 1 "/usr/include/boost/system/detail/error_condition.hpp" 1 3 4
# 14 "/usr/include/boost/system/detail/error_condition.hpp" 3 4
# 1 "/usr/include/boost/system/detail/generic_category.hpp" 1 3 4
# 14 "/usr/include/boost/system/detail/generic_category.hpp" 3 4
# 1 "/usr/include/boost/system/detail/generic_category_message.hpp" 1 3 4
# 15 "/usr/include/boost/system/detail/generic_category_message.hpp" 3 4
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 1 3 4
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 3


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 43 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 2 3
# 16 "/usr/include/boost/system/detail/generic_category_message.hpp" 2 3 4

namespace boost
{

namespace system
{

namespace detail
{





inline char const * strerror_r_helper( char const * r, char const * ) noexcept
{
    return r;
}

inline char const * strerror_r_helper( int r, char const * buffer ) noexcept
{
    return r == 0? buffer: "Unknown error";
}

inline char const * generic_error_category_message( int ev, char * buffer, std::size_t len ) noexcept
{
    return strerror_r_helper( strerror_r( ev, buffer, len ), buffer );
}

inline std::string generic_error_category_message( int ev )
{
    char buffer[ 128 ];
    return generic_error_category_message( ev, buffer, sizeof( buffer ) );
}
# 102 "/usr/include/boost/system/detail/generic_category_message.hpp" 3 4
}

}

}
# 15 "/usr/include/boost/system/detail/generic_category.hpp" 2 3 4



namespace boost
{

namespace system
{

namespace detail
{




#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wnon-virtual-dtor"


class __attribute__((__visibility__("default"))) generic_error_category: public error_category
{
public:

    constexpr generic_error_category() noexcept:
        error_category( detail::generic_category_id )
    {
    }

    const char * name() const noexcept override
    {
        return "generic";
    }

    std::string message( int ev ) const override;
    char const * message( int ev, char * buffer, std::size_t len ) const noexcept override;
};


#pragma GCC diagnostic pop




inline char const * generic_error_category::message( int ev, char * buffer, std::size_t len ) const noexcept
{
    return generic_error_category_message( ev, buffer, len );
}

inline std::string generic_error_category::message( int ev ) const
{
    return generic_error_category_message( ev );
}

}





namespace detail
{

template<class T> struct __attribute__((__visibility__("default"))) generic_cat_holder
{
    static constexpr generic_error_category instance{};
};






}

constexpr error_category const & generic_category() noexcept
{
    return detail::generic_cat_holder<void>::instance;
}
# 119 "/usr/include/boost/system/detail/generic_category.hpp" 3 4
}

}
# 15 "/usr/include/boost/system/detail/error_condition.hpp" 2 3 4
# 1 "/usr/include/boost/system/detail/enable_if.hpp" 1 3 4







namespace boost
{

namespace system
{

namespace detail
{

template<bool C, class T = void> struct enable_if
{
    typedef T type;
};

template<class T> struct enable_if<false, T>
{
};

}

}

}
# 16 "/usr/include/boost/system/detail/error_condition.hpp" 2 3 4
# 1 "/usr/include/boost/system/detail/is_same.hpp" 1 3 4







namespace boost
{

namespace system
{

namespace detail
{

template<class T1, class T2> struct is_same
{
    enum _vt { value = 0 };
};

template<class T> struct is_same<T, T>
{
    enum _vt { value = 1 };
};

}

}

}
# 17 "/usr/include/boost/system/detail/error_condition.hpp" 2 3 4

# 1 "/usr/include/boost/system/detail/append_int.hpp" 1 3 4







# 1 "/usr/include/boost/system/detail/snprintf.hpp" 1 3 4
# 12 "/usr/include/boost/system/detail/snprintf.hpp" 3 4
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdio" 1 3 4
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdio" 3
# 13 "/usr/include/boost/system/detail/snprintf.hpp" 2 3 4
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdarg" 1 3 4
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdarg" 3



# 1 "/usr/bin/../lib/clang/18/include/stdarg.h" 1 3
# 60 "/usr/bin/../lib/clang/18/include/stdarg.h" 3
# 1 "/usr/bin/../lib/clang/18/include/__stdarg_va_list.h" 1 3
# 12 "/usr/bin/../lib/clang/18/include/__stdarg_va_list.h" 3
typedef __builtin_va_list va_list;
# 61 "/usr/bin/../lib/clang/18/include/stdarg.h" 2 3




# 1 "/usr/bin/../lib/clang/18/include/__stdarg_va_arg.h" 1 3
# 66 "/usr/bin/../lib/clang/18/include/stdarg.h" 2 3




# 1 "/usr/bin/../lib/clang/18/include/__stdarg___va_copy.h" 1 3
# 71 "/usr/bin/../lib/clang/18/include/stdarg.h" 2 3




# 1 "/usr/bin/../lib/clang/18/include/__stdarg_va_copy.h" 1 3
# 76 "/usr/bin/../lib/clang/18/include/stdarg.h" 2 3
# 44 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdarg" 2 3
# 53 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdarg" 3
namespace std
{
  using ::va_list;
}
# 14 "/usr/include/boost/system/detail/snprintf.hpp" 2 3 4



namespace boost
{

namespace system
{

namespace detail
{
# 53 "/usr/include/boost/system/detail/snprintf.hpp" 3 4
__attribute__((__format__ (__printf__, 3, 4)))

inline void snprintf( char * buffer, std::size_t len, char const * format, ... )
{
    va_list args;
    __builtin_va_start(args, format);

    std::vsnprintf( buffer, len, format, args );

    __builtin_va_end(args);
}



}

}

}
# 9 "/usr/include/boost/system/detail/append_int.hpp" 2 3 4




namespace boost
{
namespace system
{
namespace detail
{

inline void append_int( std::string& s, int v )
{
    char buffer[ 32 ];
    detail::snprintf( buffer, sizeof( buffer ), ":%d", v );

    s += buffer;
}

}
}
}
# 19 "/usr/include/boost/system/detail/error_condition.hpp" 2 3 4




namespace boost
{

namespace system
{





namespace detail
{

struct generic_value_tag
{
    int value;
    constexpr explicit generic_value_tag( int v ): value( v ) {}
};

}

class error_condition
{
private:

    int val_;
    error_category const * cat_;

private:

    boost::ulong_long_type cat_id() const noexcept
    {
        return cat_? cat_->id_: detail::generic_category_id;
    }

public:



    constexpr error_condition() noexcept:
        val_( 0 ), cat_( 0 )
    {
    }

    constexpr error_condition( int val, const error_category & cat ) noexcept:
        val_( val ), cat_( &cat )
    {
    }

    constexpr explicit error_condition( boost::system::detail::generic_value_tag vt ) noexcept:
        val_( vt.value ), cat_( 0 )
    {
    }

    template<class ErrorConditionEnum> constexpr error_condition( ErrorConditionEnum e,
      typename detail::enable_if<
        is_error_condition_enum<ErrorConditionEnum>::value && !boost::system::detail::is_same<ErrorConditionEnum, errc::errc_t>::value
      >::type* = 0) noexcept
    {
        *this = make_error_condition( e );
    }

    template<class ErrorConditionEnum> constexpr error_condition( ErrorConditionEnum e,
      typename detail::enable_if<boost::system::detail::is_same<ErrorConditionEnum, errc::errc_t>::value>::type* = 0) noexcept:
        val_( e ), cat_( 0 )
    {
    }



    constexpr void assign( int val, const error_category & cat ) noexcept
    {
        val_ = val;
        cat_ = &cat;
    }

    template<typename ErrorConditionEnum>
        constexpr typename detail::enable_if<is_error_condition_enum<ErrorConditionEnum>::value, error_condition>::type &
        operator=( ErrorConditionEnum val ) noexcept
    {
        *this = error_condition( val );
        return *this;
    }

    constexpr void clear() noexcept
    {
        val_ = 0;
        cat_ = 0;
    }



    constexpr int value() const noexcept
    {
        return val_;
    }

    constexpr const error_category & category() const noexcept
    {
        return cat_? *cat_: generic_category();
    }

    std::string message() const
    {
        if( cat_ )
        {
            return cat_->message( value() );
        }
        else
        {
            return detail::generic_error_category_message( value() );
        }
    }

    char const * message( char * buffer, std::size_t len ) const noexcept
    {
        if( cat_ )
        {
            return cat_->message( value(), buffer, len );
        }
        else
        {
            return detail::generic_error_category_message( value(), buffer, len );
        }
    }

    constexpr bool failed() const noexcept
    {
        if( cat_ )
        {
            return detail::failed_impl( val_, *cat_ );
        }
        else
        {
            return val_ != 0;
        }
    }



    constexpr explicit operator bool() const noexcept
    {
        return failed();
    }
# 189 "/usr/include/boost/system/detail/error_condition.hpp" 3 4
    constexpr inline friend bool operator==( const error_condition & lhs, const error_condition & rhs ) noexcept
    {
        if( lhs.val_ != rhs.val_ )
        {
            return false;
        }
        else if( lhs.cat_ == 0 )
        {
            return rhs.cat_id() == detail::generic_category_id;
        }
        else if( rhs.cat_ == 0 )
        {
            return lhs.cat_id() == detail::generic_category_id;
        }
        else
        {
            return *lhs.cat_ == *rhs.cat_;
        }
    }

    constexpr inline friend bool operator<( const error_condition & lhs, const error_condition & rhs ) noexcept
    {
        error_category const& lcat = lhs.category();
        error_category const& rcat = rhs.category();
        return lcat < rcat || ( lcat == rcat && lhs.val_ < rhs.val_ );
    }

    constexpr inline friend bool operator!=( const error_condition & lhs, const error_condition & rhs ) noexcept
    {
        return !( lhs == rhs );
    }



    operator std::error_condition () const
    {







        if( cat_ )
        {
            return std::error_condition( val_, *cat_ );
        }
        else
        {
            return std::error_condition( val_, std::generic_category() );
        }


    }

    inline friend bool operator==( std::error_code const & lhs, error_condition const & rhs ) noexcept
    {
        return lhs == static_cast< std::error_condition >( rhs );
    }

    inline friend bool operator==( error_condition const & lhs, std::error_code const & rhs ) noexcept
    {
        return static_cast< std::error_condition >( lhs ) == rhs;
    }

    inline friend bool operator!=( std::error_code const & lhs, error_condition const & rhs ) noexcept
    {
        return !( lhs == rhs );
    }

    inline friend bool operator!=( error_condition const & lhs, std::error_code const & rhs ) noexcept
    {
        return !( lhs == rhs );
    }



    template<class E, class N = typename detail::enable_if<std::is_error_condition_enum<E>::value>::type>
    constexpr inline friend bool operator==( error_condition const & lhs, E rhs ) noexcept
    {
        return lhs == make_error_condition( rhs );
    }

    template<class E, class N = typename detail::enable_if<std::is_error_condition_enum<E>::value>::type>
    constexpr inline friend bool operator==( E lhs, error_condition const & rhs ) noexcept
    {
        return make_error_condition( lhs ) == rhs;
    }

    template<class E, class N = typename detail::enable_if<std::is_error_condition_enum<E>::value>::type>
    constexpr inline friend bool operator!=( error_condition const & lhs, E rhs ) noexcept
    {
        return !( lhs == rhs );
    }

    template<class E, class N = typename detail::enable_if<std::is_error_condition_enum<E>::value>::type>
    constexpr inline friend bool operator!=( E lhs, error_condition const & rhs ) noexcept
    {
        return !( lhs == rhs );
    }



    template<class E, class N1 = void, class N2 = typename detail::enable_if<std::is_error_code_enum<E>::value>::type>
    inline friend bool operator==( error_condition const & lhs, E rhs ) noexcept
    {
        return lhs == make_error_code( rhs );
    }

    template<class E, class N1 = void, class N2 = typename detail::enable_if<std::is_error_code_enum<E>::value>::type>
    inline friend bool operator==( E lhs, error_condition const & rhs ) noexcept
    {
        return make_error_code( lhs ) == rhs;
    }

    template<class E, class N1 = void, class N2 = typename detail::enable_if<std::is_error_code_enum<E>::value>::type>
    inline friend bool operator!=( error_condition const & lhs, E rhs ) noexcept
    {
        return !( lhs == rhs );
    }

    template<class E, class N1 = void, class N2 = typename detail::enable_if<std::is_error_code_enum<E>::value>::type>
    inline friend bool operator!=( E lhs, error_condition const & rhs ) noexcept
    {
        return !( lhs == rhs );
    }



    std::string to_string() const
    {
        std::string r( "cond:" );

        if( cat_ )
        {
            r += cat_->name();
        }
        else
        {
            r += "generic";
        }

        detail::append_int( r, value() );

        return r;
    }

    template<class Ch, class Tr>
        inline friend std::basic_ostream<Ch, Tr>&
        operator<< (std::basic_ostream<Ch, Tr>& os, error_condition const & en)
    {
        os << en.to_string();
        return os;
    }
};

}

}
# 16 "/usr/include/boost/system/detail/error_code.hpp" 2 3 4
# 1 "/usr/include/boost/system/detail/system_category.hpp" 1 3 4
# 17 "/usr/include/boost/system/detail/system_category.hpp" 3 4
namespace boost
{

namespace system
{

namespace detail
{




#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wnon-virtual-dtor"


class __attribute__((__visibility__("default"))) system_error_category: public error_category
{
public:

    constexpr system_error_category() noexcept:
        error_category( detail::system_category_id )
    {
    }

    const char * name() const noexcept override
    {
        return "system";
    }

    error_condition default_error_condition( int ev ) const noexcept override;

    std::string message( int ev ) const override;
    char const * message( int ev, char * buffer, std::size_t len ) const noexcept override;
};


#pragma GCC diagnostic pop


}





namespace detail
{

template<class T> struct __attribute__((__visibility__("default"))) system_cat_holder
{
    static constexpr system_error_category instance{};
};






}

constexpr error_category const & system_category() noexcept
{
    return detail::system_cat_holder<void>::instance;
}
# 106 "/usr/include/boost/system/detail/system_category.hpp" 3 4
}

}
# 17 "/usr/include/boost/system/detail/error_code.hpp" 2 3 4
# 1 "/usr/include/boost/system/detail/system_category_impl.hpp" 1 3 4
# 14 "/usr/include/boost/system/detail/system_category_impl.hpp" 3 4
# 1 "/usr/include/boost/system/detail/system_category_message.hpp" 1 3 4
# 13 "/usr/include/boost/system/detail/system_category_message.hpp" 3 4
# 1 "/usr/include/boost/system/api_config.hpp" 1 3 4
# 14 "/usr/include/boost/system/detail/system_category_message.hpp" 2 3 4
# 48 "/usr/include/boost/system/detail/system_category_message.hpp" 3 4
namespace boost
{
namespace system
{
namespace detail
{

inline std::string system_error_category_message( int ev )
{
    return generic_error_category_message( ev );
}

inline char const * system_error_category_message( int ev, char * buffer, std::size_t len ) noexcept
{
    return generic_error_category_message( ev, buffer, len );
}

}
}
}
# 15 "/usr/include/boost/system/detail/system_category_impl.hpp" 2 3 4
# 44 "/usr/include/boost/system/detail/system_category_impl.hpp" 3 4
inline boost::system::error_condition boost::system::detail::system_error_category::default_error_condition( int ev ) const noexcept
{
    return error_condition( boost::system::detail::generic_value_tag( ev ) );
}



inline std::string boost::system::detail::system_error_category::message( int ev ) const
{
    return system_error_category_message( ev );
}

inline char const * boost::system::detail::system_error_category::message( int ev, char * buffer, std::size_t len ) const noexcept
{
    return system_error_category_message( ev, buffer, len );
}
# 18 "/usr/include/boost/system/detail/error_code.hpp" 2 3 4
# 1 "/usr/include/boost/system/detail/interop_category.hpp" 1 3 4
# 18 "/usr/include/boost/system/detail/interop_category.hpp" 3 4
namespace boost
{

namespace system
{

namespace detail
{




#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wnon-virtual-dtor"


class __attribute__((__visibility__("default"))) interop_error_category: public error_category
{
public:

    constexpr interop_error_category() noexcept:
        error_category( detail::interop_category_id )
    {
    }

    const char * name() const noexcept override
    {
        return "std:unknown";
    }

    std::string message( int ev ) const override;
    char const * message( int ev, char * buffer, std::size_t len ) const noexcept override;
};


#pragma GCC diagnostic pop


inline char const * interop_error_category::message( int ev, char * buffer, std::size_t len ) const noexcept
{
    detail::snprintf( buffer, len, "Unknown interop error %d", ev );
    return buffer;
}

inline std::string interop_error_category::message( int ev ) const
{
    char buffer[ 48 ];
    return message( ev, buffer, sizeof( buffer ) );
}





template<class T> struct __attribute__((__visibility__("default"))) interop_cat_holder
{
    static constexpr interop_error_category instance{};
};






constexpr error_category const & interop_category() noexcept
{
    return interop_cat_holder<void>::instance;
}
# 101 "/usr/include/boost/system/detail/interop_category.hpp" 3 4
}

}

}
# 19 "/usr/include/boost/system/detail/error_code.hpp" 2 3 4







# 1 "/usr/include/boost/system/detail/std_category.hpp" 1 3 4
# 19 "/usr/include/boost/system/detail/std_category.hpp" 3 4
namespace boost
{

namespace system
{

namespace detail
{

template<unsigned Id> struct id_wrapper {};

class __attribute__((__visibility__("default"))) std_category: public std::error_category
{
private:

    boost::system::error_category const * pc_;

public:

    boost::system::error_category const & original_category() const noexcept
    {
        return *pc_;
    }

public:

    template<unsigned Id>
    explicit std_category( boost::system::error_category const * pc, id_wrapper<Id> ): pc_( pc )
    {
# 61 "/usr/include/boost/system/detail/std_category.hpp" 3 4
    }

    const char * name() const noexcept override
    {
        return pc_->name();
    }

    std::string message( int ev ) const override
    {
        return pc_->message( ev );
    }

    std::error_condition default_error_condition( int ev ) const noexcept override
    {
        return pc_->default_error_condition( ev );
    }

    inline bool equivalent( int code, const std::error_condition & condition ) const noexcept override;
    inline bool equivalent( const std::error_code & code, int condition ) const noexcept override;
};

}

}

}
# 27 "/usr/include/boost/system/detail/error_code.hpp" 2 3 4



# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 31 "/usr/include/boost/system/detail/error_code.hpp" 2 3 4




# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdio" 1 3 4
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdio" 3
# 36 "/usr/include/boost/system/detail/error_code.hpp" 2 3 4
# 46 "/usr/include/boost/system/detail/error_code.hpp" 3 4
namespace boost
{

namespace system
{
# 61 "/usr/include/boost/system/detail/error_code.hpp" 3 4
bool operator==( const error_code & code, const error_condition & condition ) noexcept;
std::size_t hash_value( error_code const & ec );

class error_code
{
private:

    friend bool operator==( const error_code & code, const error_condition & condition ) noexcept;
    friend std::size_t hash_value( error_code const & ec );

private:

    struct data
    {
        int val_;
        const error_category * cat_;
    };

    union
    {
        data d1_;

        unsigned char d2_[ sizeof(std::error_code) ];

    };






    boost::uintptr_t lc_flags_;

private:

    char const* category_name() const noexcept
    {


        if( lc_flags_ == 0 )
        {

            return "system";
        }
        else if( lc_flags_ == 1 )
        {

            return "std:unknown";
        }
        else
        {
            return d1_.cat_->name();
        }
    }

public:




    constexpr

    error_code() noexcept:
        d1_(), lc_flags_( 0 )
    {
    }

    constexpr error_code( int val, const error_category & cat ) noexcept:
        d1_(), lc_flags_( 2 + detail::failed_impl( val, cat ) )
    {
        d1_.val_ = val;
        d1_.cat_ = &cat;
    }

    error_code( int val, const error_category & cat, source_location const * loc ) noexcept:
        d1_(), lc_flags_( ( loc? reinterpret_cast<boost::uintptr_t>( loc ): 2 ) | +detail::failed_impl( val, cat ) )
    {
        d1_.val_ = val;
        d1_.cat_ = &cat;
    }

    template<class ErrorCodeEnum> constexpr error_code( ErrorCodeEnum e,
        typename detail::enable_if<
            is_error_code_enum<ErrorCodeEnum>::value

            || std::is_error_code_enum<ErrorCodeEnum>::value

        >::type* = 0 ) noexcept: d1_(), lc_flags_( 0 )
    {
        *this = make_error_code( e );
    }

    error_code( error_code const& ec, source_location const * loc ) noexcept:
        d1_(), lc_flags_( 0 )
    {
        *this = ec;

        if( ec.lc_flags_ != 0 && ec.lc_flags_ != 1 )
        {
            lc_flags_ = ( loc? reinterpret_cast<boost::uintptr_t>( loc ): 2 ) | ( ec.lc_flags_ & 1 );
        }
    }



    error_code( std::error_code const& ec ) noexcept:
        d1_(), lc_flags_( 0 )
    {


        if( detail::std_category const* pc2 = dynamic_cast< detail::std_category const* >( &ec.category() ) )
        {
            *this = boost::system::error_code( ec.value(), pc2->original_category() );
        }
        else


        {
            ::new( d2_ ) std::error_code( ec );
            lc_flags_ = 1;
        }
    }





    constexpr void assign( int val, const error_category & cat ) noexcept
    {
        *this = error_code( val, cat );
    }

    void assign( int val, const error_category & cat, source_location const * loc ) noexcept
    {
        *this = error_code( val, cat, loc );
    }

    void assign( error_code const& ec, source_location const * loc ) noexcept
    {
        *this = error_code( ec, loc );
    }

    template<typename ErrorCodeEnum>
        constexpr typename detail::enable_if<is_error_code_enum<ErrorCodeEnum>::value, error_code>::type &
        operator=( ErrorCodeEnum val ) noexcept
    {
        *this = make_error_code( val );
        return *this;
    }

    constexpr void clear() noexcept
    {
        *this = error_code();
    }



    constexpr int value() const noexcept
    {
        if( lc_flags_ != 1 )
        {
            return d1_.val_;
        }
        else
        {


            std::error_code const& ec = *reinterpret_cast<std::error_code const*>( d2_ );

            unsigned cv = static_cast<unsigned>( ec.value() );
            unsigned ch = static_cast<unsigned>( reinterpret_cast<boost::uintptr_t>( &ec.category() ) % 2097143 );

            return static_cast<int>( cv + 1000 * ch );




        }
    }

    constexpr const error_category & category() const noexcept
    {
        if( lc_flags_ == 0 )
        {
            return system_category();
        }
        else if( lc_flags_ == 1 )
        {
            return detail::interop_category();
        }
        else
        {
            return *d1_.cat_;
        }
    }


    error_condition default_error_condition() const noexcept
    {
        return category().default_error_condition( value() );
    }

    std::string message() const
    {


        if( lc_flags_ == 1 )
        {
            std::error_code const& ec = *reinterpret_cast<std::error_code const*>( d2_ );
            return ec.message();
        }



        if( lc_flags_ == 0 )
        {
            return detail::system_error_category_message( value() );
        }
        else
        {
            return category().message( value() );
        }
    }

    char const * message( char * buffer, std::size_t len ) const noexcept
    {

        if( lc_flags_ == 1 )
        {
            std::error_code const& ec = *reinterpret_cast<std::error_code const*>( d2_ );


            try

            {
                detail::snprintf( buffer, len, "%s", ec.message().c_str() );
                return buffer;
            }

            catch( ... )
            {
                detail::snprintf( buffer, len, "No message text available for error std:%s:%d", ec.category().name(), ec.value() );
                return buffer;
            }

        }


        if( lc_flags_ == 0 )
        {
            return detail::system_error_category_message( value(), buffer, len );
        }
        else
        {
            return category().message( value(), buffer, len );
        }
    }

    constexpr bool failed() const noexcept
    {
        if( lc_flags_ & 1 )
        {

            if( lc_flags_ == 1 )
            {
                std::error_code const& ec = *reinterpret_cast<std::error_code const*>( d2_ );
                return ec.value() != 0;
            }

            return true;
        }
        else
        {
            return false;
        }
    }



    constexpr explicit operator bool() const noexcept
    {
        return failed();
    }
# 362 "/usr/include/boost/system/detail/error_code.hpp" 3 4
    bool has_location() const noexcept
    {
        return lc_flags_ >= 4;
    }

    source_location const & location() const noexcept
    {
        static constexpr source_location loc;
        return lc_flags_ >= 4? *reinterpret_cast<source_location const*>( lc_flags_ &~ static_cast<boost::uintptr_t>( 1 ) ): loc;
    }



private:



    friend class error_category;

    constexpr bool equals( int val, error_category const& cat ) const noexcept
    {
        if( lc_flags_ == 0 )
        {
            return val == 0 && cat.id_ == detail::system_category_id;
        }
        else if( lc_flags_ == 1 )
        {
            return cat.id_ == detail::interop_category_id && val == value();
        }
        else
        {
            return val == d1_.val_ && cat == *d1_.cat_;
        }
    }

public:




    constexpr inline friend bool operator==( const error_code & lhs, const error_code & rhs ) noexcept
    {


        bool s1 = lhs.lc_flags_ == 1;
        bool s2 = rhs.lc_flags_ == 1;

        if( s1 != s2 ) return false;

        if( s1 && s2 )
        {
            std::error_code const& e1 = *reinterpret_cast<std::error_code const*>( lhs.d2_ );
            std::error_code const& e2 = *reinterpret_cast<std::error_code const*>( rhs.d2_ );

            return e1 == e2;
        }
        else

        {
            return lhs.value() == rhs.value() && lhs.category() == rhs.category();
        }
    }

    constexpr inline friend bool operator<( const error_code & lhs, const error_code & rhs ) noexcept
    {


        bool s1 = lhs.lc_flags_ == 1;
        bool s2 = rhs.lc_flags_ == 1;

        if( s1 < s2 ) return true;
        if( s2 < s1 ) return false;

        if( s1 && s2 )
        {
            std::error_code const& e1 = *reinterpret_cast<std::error_code const*>( lhs.d2_ );
            std::error_code const& e2 = *reinterpret_cast<std::error_code const*>( rhs.d2_ );

            return e1 < e2;
        }
        else

        {
            return lhs.category() < rhs.category() || (lhs.category() == rhs.category() && lhs.value() < rhs.value());
        }
    }

    constexpr inline friend bool operator!=( const error_code & lhs, const error_code & rhs ) noexcept
    {
        return !( lhs == rhs );
    }



    inline friend bool operator==( std::error_code const & lhs, error_code const & rhs ) noexcept
    {
        return lhs == static_cast< std::error_code >( rhs );
    }

    inline friend bool operator==( error_code const & lhs, std::error_code const & rhs ) noexcept
    {
        return static_cast< std::error_code >( lhs ) == rhs;
    }

    inline friend bool operator!=( std::error_code const & lhs, error_code const & rhs ) noexcept
    {
        return !( lhs == rhs );
    }

    inline friend bool operator!=( error_code const & lhs, std::error_code const & rhs ) noexcept
    {
        return !( lhs == rhs );
    }



    template<class E, class N = typename detail::enable_if<std::is_error_condition_enum<E>::value>::type>
    inline friend bool operator==( error_code const & lhs, E rhs ) noexcept
    {
        return lhs == make_error_condition( rhs );
    }

    template<class E, class N = typename detail::enable_if<std::is_error_condition_enum<E>::value>::type>
    inline friend bool operator==( E lhs, error_code const & rhs ) noexcept
    {
        return make_error_condition( lhs ) == rhs;
    }

    template<class E, class N = typename detail::enable_if<std::is_error_condition_enum<E>::value>::type>
    inline friend bool operator!=( error_code const & lhs, E rhs ) noexcept
    {
        return !( lhs == rhs );
    }

    template<class E, class N = typename detail::enable_if<std::is_error_condition_enum<E>::value>::type>
    inline friend bool operator!=( E lhs, error_code const & rhs ) noexcept
    {
        return !( lhs == rhs );
    }



    template<class E, class N1 = void, class N2 = typename detail::enable_if<std::is_error_code_enum<E>::value>::type>
    constexpr inline friend bool operator==( error_code const & lhs, E rhs ) noexcept
    {
        return lhs == make_error_code( rhs );
    }

    template<class E, class N1 = void, class N2 = typename detail::enable_if<std::is_error_code_enum<E>::value>::type>
    constexpr inline friend bool operator==( E lhs, error_code const & rhs ) noexcept
    {
        return make_error_code( lhs ) == rhs;
    }

    template<class E, class N1 = void, class N2 = typename detail::enable_if<std::is_error_code_enum<E>::value>::type>
    constexpr inline friend bool operator!=( error_code const & lhs, E rhs ) noexcept
    {
        return !( lhs == rhs );
    }

    template<class E, class N1 = void, class N2 = typename detail::enable_if<std::is_error_code_enum<E>::value>::type>
    constexpr inline friend bool operator!=( E lhs, error_code const & rhs ) noexcept
    {
        return !( lhs == rhs );
    }
# 554 "/usr/include/boost/system/detail/error_code.hpp" 3 4
    operator std::error_code () const
    {
        if( lc_flags_ == 1 )
        {
            return *reinterpret_cast<std::error_code const*>( d2_ );
        }
        else if( lc_flags_ == 0 )
        {







            return std::error_code();


        }
        else
        {
            return std::error_code( d1_.val_, *d1_.cat_ );
        }
    }

    operator std::error_code ()
    {
        return const_cast<error_code const&>( *this );
    }

    template<class T,
      class E = typename detail::enable_if<detail::is_same<T, std::error_code>::value>::type>
      operator T& ()
    {
        if( lc_flags_ != 1 )
        {
            std::error_code e2( *this );
            ::new( d2_ ) std::error_code( e2 );
            lc_flags_ = 1;
        }

        return *reinterpret_cast<std::error_code*>( d2_ );
    }
# 608 "/usr/include/boost/system/detail/error_code.hpp" 3 4
    std::string to_string() const
    {


        if( lc_flags_ == 1 )
        {
            std::error_code const& e2 = *reinterpret_cast<std::error_code const*>( d2_ );

            std::string r( "std:" );
            r += e2.category().name();
            detail::append_int( r, e2.value() );

            return r;
        }
        else

        {
            std::string r = category_name();
            detail::append_int( r, value() );
            return r;
        }
    }

    template<class Ch, class Tr>
        inline friend std::basic_ostream<Ch, Tr>&
        operator<< (std::basic_ostream<Ch, Tr>& os, error_code const & ec)
    {
        return os << ec.to_string().c_str();
    }

    std::string what() const
    {
        std::string r = message();

        r += " [";
        r += to_string();

        if( has_location() )
        {
            r += " at ";
            r += location().to_string();
        }

        r += "]";
        return r;
    }
};

inline bool operator==( const error_code & code, const error_condition & condition ) noexcept
{


    if( code.lc_flags_ == 1 )
    {
        return static_cast<std::error_code>( code ) == static_cast<std::error_condition>( condition );
    }
    else


    {
        return code.category().equivalent( code.value(), condition ) || condition.category().equivalent( code, condition.value() );
    }
}

inline bool operator==( const error_condition & condition, const error_code & code ) noexcept
{
    return code == condition;
}

inline bool operator!=( const error_code & lhs, const error_condition & rhs ) noexcept
{
    return !( lhs == rhs );
}

inline bool operator!=( const error_condition & lhs, const error_code & rhs ) noexcept
{
    return !( lhs == rhs );
}

inline std::size_t hash_value( error_code const & ec )
{


    if( ec.lc_flags_ == 1 )
    {
        std::error_code const& e2 = *reinterpret_cast<std::error_code const*>( ec.d2_ );
        return std::hash<std::error_code>()( e2 );
    }



    error_category const & cat = ec.category();

    boost::ulong_long_type id_ = cat.id_;

    if( id_ == 0 )
    {
        id_ = reinterpret_cast<boost::uintptr_t>( &cat );
    }

    boost::ulong_long_type hv = ( boost::ulong_long_type( 0xCBF29CE4 ) << 32 ) + 0x84222325;
    boost::ulong_long_type const prime = ( boost::ulong_long_type( 0x00000100 ) << 32 ) + 0x000001B3;



    hv ^= id_;
    hv *= prime;



    hv ^= static_cast<unsigned>( ec.value() );
    hv *= prime;

    return static_cast<std::size_t>( hv );
}

}

}
# 15 "/usr/include/boost/system/errc.hpp" 2 3 4


# 1 "/usr/include/boost/system/detail/error_category_impl.hpp" 1 3 4
# 20 "/usr/include/boost/system/detail/error_category_impl.hpp" 3 4
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 1 3 4
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 3


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 43 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 2 3
# 21 "/usr/include/boost/system/detail/error_category_impl.hpp" 2 3 4

namespace boost
{
namespace system
{



inline error_condition error_category::default_error_condition( int ev ) const noexcept
{
    return error_condition( ev, *this );
}

inline bool error_category::equivalent( int code, const error_condition & condition ) const noexcept
{
    return default_error_condition( code ) == condition;
}

inline bool error_category::equivalent( const error_code & code, int condition ) const noexcept
{
    return code.equals( condition, *this );
}

inline char const * error_category::message( int ev, char * buffer, std::size_t len ) const noexcept
{
    if( len == 0 )
    {
        return buffer;
    }

    if( len == 1 )
    {
        buffer[0] = 0;
        return buffer;
    }


    try

    {
        std::string m = this->message( ev );





#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Wdeprecated-declarations"



        std::strncpy( buffer, m.c_str(), len - 1 );
        buffer[ len-1 ] = 0;




#pragma clang diagnostic pop


        return buffer;
    }

    catch( ... )
    {
        detail::snprintf( buffer, len, "No message text available for error %d", ev );
        return buffer;
    }

}

}
}





# 1 "/usr/include/boost/system/detail/std_category_impl.hpp" 1 3 4
# 20 "/usr/include/boost/system/detail/std_category_impl.hpp" 3 4
namespace boost
{

namespace system
{

namespace detail
{

inline bool std_category::equivalent( int code, const std::error_condition & condition ) const noexcept
{
    if( condition.category() == *this )
    {
        boost::system::error_condition bn( condition.value(), *pc_ );
        return pc_->equivalent( code, bn );
    }
    else if( condition.category() == std::generic_category() || condition.category() == boost::system::generic_category() )
    {
        boost::system::error_condition bn( condition.value(), boost::system::generic_category() );
        return pc_->equivalent( code, bn );
    }



    else if( std_category const* pc2 = dynamic_cast< std_category const* >( &condition.category() ) )
    {
        boost::system::error_condition bn( condition.value(), *pc2->pc_ );
        return pc_->equivalent( code, bn );
    }



    else
    {
        return default_error_condition( code ) == condition;
    }
}

inline bool std_category::equivalent( const std::error_code & code, int condition ) const noexcept
{
    if( code.category() == *this )
    {
        boost::system::error_code bc( code.value(), *pc_ );
        return pc_->equivalent( bc, condition );
    }
    else if( code.category() == std::generic_category() || code.category() == boost::system::generic_category() )
    {
        boost::system::error_code bc( code.value(), boost::system::generic_category() );
        return pc_->equivalent( bc, condition );
    }



    else if( std_category const* pc2 = dynamic_cast< std_category const* >( &code.category() ) )
    {
        boost::system::error_code bc( code.value(), *pc2->pc_ );
        return pc_->equivalent( bc, condition );
    }



    else if( *pc_ == boost::system::generic_category() )
    {
        return std::generic_category().equivalent( code, condition );
    }
    else
    {
        return false;
    }
}

}

}

}
# 101 "/usr/include/boost/system/detail/error_category_impl.hpp" 2 3 4
# 1 "/usr/include/boost/system/detail/mutex.hpp" 1 3 4
# 68 "/usr/include/boost/system/detail/mutex.hpp" 3 4
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/mutex" 1 3 4
# 33 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/mutex" 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/mutex" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unique_lock.h" 1 3
# 34 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unique_lock.h" 3
# 44 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unique_lock.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 59 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/unique_lock.h" 3
  template<typename _Mutex>
    class unique_lock
    {
    public:
      typedef _Mutex mutex_type;

      unique_lock() noexcept
      : _M_device(0), _M_owns(false)
      { }

      [[__nodiscard__]]
      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)
      { }

      [[__nodiscard__]]
      unique_lock(mutex_type& __m, try_to_lock_t)
      : _M_device(std::__addressof(__m)), _M_owns(_M_device->try_lock())
      { }

      [[__nodiscard__]]
      unique_lock(mutex_type& __m, adopt_lock_t) noexcept
      : _M_device(std::__addressof(__m)), _M_owns(true)
      {

      }

      template<typename _Clock, typename _Duration>
 [[__nodiscard__]]
 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<typename _Rep, typename _Period>
 [[__nodiscard__]]
 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;
   }
      }

      [[__nodiscard__]]
      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<typename _Clock, typename _Duration>
 [[__nodiscard__]]
 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<typename _Rep, typename _Period>
 [[__nodiscard__]]
 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;
      }

      [[__nodiscard__]]
      bool
      owns_lock() const noexcept
      { return _M_owns; }

      explicit operator bool() const noexcept
      { return owns_lock(); }

      [[__nodiscard__]]
      mutex_type*
      mutex() const noexcept
      { return _M_device; }

    private:
      mutex_type* _M_device;
      bool _M_owns;
    };



  template<typename _Mutex>
    inline void
    swap(unique_lock<_Mutex>& __x, unique_lock<_Mutex>& __y) noexcept
    { __x.swap(__y); }


}
# 49 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/mutex" 2 3
# 60 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/mutex" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 61 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/mutex" 2 3

namespace std __attribute__ ((__visibility__ ("default")))
{
# 75 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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;
# 99 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/mutex" 3
  };
# 111 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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);
    }

    [[__nodiscard__]]
    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<typename _Derived>
    class __timed_mutex_impl
    {
    protected:
      template<typename _Rep, typename _Period>
 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<typename _Duration>
 bool
 _M_try_lock_until(const chrono::time_point<chrono::system_clock,
         _Duration>& __atime)
 {
   auto __s = chrono::time_point_cast<chrono::seconds>(__atime);
   auto __ns = chrono::duration_cast<chrono::nanoseconds>(__atime - __s);

   __gthread_time_t __ts = {
     static_cast<std::time_t>(__s.time_since_epoch().count()),
     static_cast<long>(__ns.count())
   };

   return static_cast<_Derived*>(this)->_M_timedlock(__ts);
 }


      template<typename _Duration>
 bool
 _M_try_lock_until(const chrono::time_point<chrono::steady_clock,
         _Duration>& __atime)
 {
   auto __s = chrono::time_point_cast<chrono::seconds>(__atime);
   auto __ns = chrono::duration_cast<chrono::nanoseconds>(__atime - __s);

   __gthread_time_t __ts = {
     static_cast<std::time_t>(__s.time_since_epoch().count()),
     static_cast<long>(__ns.count())
   };

   return static_cast<_Derived*>(this)->_M_clocklock(1,
           __ts);
 }


      template<typename _Clock, typename _Duration>
 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;
 }
    };
# 240 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/mutex" 3
  class timed_mutex
  : private __mutex_base, public __timed_mutex_impl<timed_mutex>
  {
  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);
    }

    [[__nodiscard__]]
    bool
    try_lock() noexcept
    {

      return !__gthread_mutex_trylock(&_M_mutex);
    }

    template <class _Rep, class _Period>
      [[__nodiscard__]]
      bool
      try_lock_for(const chrono::duration<_Rep, _Period>& __rtime)
      { return _M_try_lock_for(__rtime); }

    template <class _Clock, class _Duration>
      [[__nodiscard__]]
      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<timed_mutex>;

      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); }

  };
# 317 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/mutex" 3
  class recursive_timed_mutex
  : private __recursive_mutex_base,
    public __timed_mutex_impl<recursive_timed_mutex>
  {
  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);
    }

    [[__nodiscard__]]
    bool
    try_lock() noexcept
    {

      return !__gthread_recursive_mutex_trylock(&_M_mutex);
    }

    template <class _Rep, class _Period>
      [[__nodiscard__]]
      bool
      try_lock_for(const chrono::duration<_Rep, _Period>& __rtime)
      { return _M_try_lock_for(__rtime); }

    template <class _Clock, class _Duration>
      [[__nodiscard__]]
      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<recursive_timed_mutex>;

      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); }

  };
# 564 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/mutex" 3
  namespace __detail
  {

    template<typename _Lockable>
      inline int
      __try_lock_impl(_Lockable& __l)
      {
 if (unique_lock<_Lockable> __lock{__l, try_to_lock})
   {
     __lock.release();
     return -1;
   }
 else
   return 0;
      }



    template<typename _L0, typename... _Lockables>
      inline int
      __try_lock_impl(_L0& __l0, _Lockables&... __lockables)
      {

 if constexpr ((is_same_v<_L0, _Lockables> && ...))
   {
     constexpr int _Np = 1 + sizeof...(_Lockables);
     unique_lock<_L0> __locks[_Np] = {
  {__l0, defer_lock}, {__lockables, defer_lock}...
     };
     for (int __i = 0; __i < _Np; ++__i)
       {
  if (!__locks[__i].try_lock())
    {
      const int __failed = __i;
      while (__i--)
        __locks[__i].unlock();
      return __failed;
    }
       }
     for (auto& __l : __locks)
       __l.release();
     return -1;
   }
 else

 if (unique_lock<_L0> __lock{__l0, try_to_lock})
   {
     int __idx = __detail::__try_lock_impl(__lockables...);
     if (__idx == -1)
       {
  __lock.release();
  return -1;
       }
     return __idx + 1;
   }
 else
   return 0;
      }

  }
# 636 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/mutex" 3
  template<typename _L1, typename _L2, typename... _L3>
    [[__nodiscard__]]
    inline int
    try_lock(_L1& __l1, _L2& __l2, _L3&... __l3)
    {
      return __detail::__try_lock_impl(__l1, __l2, __l3...);
    }


  namespace __detail
  {





    template<typename _L0, typename... _L1>
      void
      __lock_impl(int& __i, int __depth, _L0& __l0, _L1&... __l1)
      {
 while (__i >= __depth)
   {
     if (__i == __depth)
       {
  int __failed = 1;
  {
    unique_lock<_L0> __first(__l0);
    __failed += __detail::__try_lock_impl(__l1...);
    if (!__failed)
      {
        __i = -1;
        __first.release();
        return;
      }
  }

  __gthread_yield();

  constexpr auto __n = 1 + sizeof...(_L1);
  __i = (__depth + __failed) % __n;
       }
     else
       __detail::__lock_impl(__i, __depth + 1, __l1..., __l0);
   }
      }

  }
# 696 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/mutex" 3
  template<typename _L1, typename _L2, typename... _L3>
    void
    lock(_L1& __l1, _L2& __l2, _L3&... __l3)
    {

      if constexpr (is_same_v<_L1, _L2> && (is_same_v<_L1, _L3> && ...))
 {
   constexpr int _Np = 2 + sizeof...(_L3);
   unique_lock<_L1> __locks[] = {
       {__l1, defer_lock}, {__l2, defer_lock}, {__l3, defer_lock}...
   };
   int __first = 0;
   do {
     __locks[__first].lock();
     for (int __j = 1; __j < _Np; ++__j)
       {
  const int __idx = (__first + __j) % _Np;
  if (!__locks[__idx].try_lock())
    {
      for (int __k = __j; __k != 0; --__k)
        __locks[(__first + __k - 1) % _Np].unlock();
      __first = __idx;
      break;
    }
       }
   } while (!__locks[__first].owns_lock());

   for (auto& __l : __locks)
     __l.release();
 }
      else

 {
   int __i = 0;
   __detail::__lock_impl(__i, 0, __l1, __l2, __l3...);
 }
    }
# 743 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/mutex" 3
  template<typename... _MutexTypes>
    class scoped_lock
    {
    public:

      [[nodiscard]]
      explicit scoped_lock(_MutexTypes&... __m) : _M_devices(std::tie(__m...))
      { std::lock(__m...); }

      [[nodiscard]]
      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<typename _Mutex>
    class scoped_lock<_Mutex>
    {
    public:
      using mutex_type = _Mutex;

      [[nodiscard]]
      explicit scoped_lock(mutex_type& __m) : _M_device(__m)
      { _M_device.lock(); }

      [[nodiscard]]
      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
  {
    constexpr once_flag() noexcept = default;


    once_flag(const once_flag&) = delete;

    once_flag& operator=(const once_flag&) = delete;

  private:


    __gthread_once_t _M_once = 0;

    struct _Prepare_execution;

    template<typename _Callable, typename... _Args>
      friend void
      call_once(once_flag& __once, _Callable&& __f, _Args&&... __args);
  };





  extern __thread void* __once_callable;
  extern __thread void (*__once_call)();


  struct once_flag::_Prepare_execution
  {
    template<typename _Callable>
      explicit
      _Prepare_execution(_Callable& __c)
      {

 __once_callable = std::__addressof(__c);

 __once_call = [] { (*static_cast<_Callable*>(__once_callable))(); };
      }

    ~_Prepare_execution()
    {

      __once_callable = nullptr;
      __once_call = nullptr;
    }

    _Prepare_execution(const _Prepare_execution&) = delete;
    _Prepare_execution& operator=(const _Prepare_execution&) = delete;
  };
# 900 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/mutex" 3
  extern "C" void __once_proxy(void);


  template<typename _Callable, typename... _Args>
    void
    call_once(once_flag& __once, _Callable&& __f, _Args&&... __args)
    {

      auto __callable = [&] {
   std::__invoke(std::forward<_Callable>(__f),
   std::forward<_Args>(__args)...);
      };

      once_flag::_Prepare_execution __exec(__callable);


      if (int __e = __gthread_once(&__once._M_once, &__once_proxy))
 __throw_system_error(__e);
    }
# 1022 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/mutex" 3
}
# 69 "/usr/include/boost/system/detail/mutex.hpp" 2 3 4

namespace boost
{
namespace system
{
namespace detail
{

using std::mutex;

}
}
}




namespace boost
{
namespace system
{
namespace detail
{

template<class Mtx> class lock_guard
{
private:

    Mtx& mtx_;

private:

    lock_guard( lock_guard const& );
    lock_guard& operator=( lock_guard const& );

public:

    explicit lock_guard( Mtx& mtx ): mtx_( mtx )
    {
        mtx_.lock();
    }

    ~lock_guard()
    {
        mtx_.unlock();
    }
};

}
}
}
# 102 "/usr/include/boost/system/detail/error_category_impl.hpp" 2 3 4


namespace boost
{
namespace system
{

inline void error_category::init_stdcat() const
{
    static_assert( sizeof( stdcat_ ) >= sizeof( boost::system::detail::std_category ), "sizeof(stdcat_) is not enough for std_category" );





    static_assert( alignof( decltype(stdcat_align_) ) >= alignof( boost::system::detail::std_category ), "alignof(stdcat_) is not enough for std_category" );







    static system::detail::mutex mx_;

    system::detail::lock_guard<system::detail::mutex> lk( mx_ );

    if( sc_init_.load( std::memory_order_acquire ) == 0 )
    {
        ::new( static_cast<void*>( stdcat_ ) ) boost::system::detail::std_category( this, system::detail::id_wrapper<0>() );
        sc_init_.store( 1, std::memory_order_release );
    }
}






inline __attribute__ ((__noinline__)) error_category::operator std::error_category const & () const
{
    if( id_ == detail::generic_category_id )
    {
# 153 "/usr/include/boost/system/detail/error_category_impl.hpp" 3 4
        return std::generic_category();


    }

    if( id_ == detail::system_category_id )
    {
# 168 "/usr/include/boost/system/detail/error_category_impl.hpp" 3 4
        return std::system_category();


    }

    if( sc_init_.load( std::memory_order_acquire ) == 0 )
    {
        init_stdcat();
    }

    return *static_cast<boost::system::detail::std_category const*>( static_cast<void const*>( stdcat_ ) );
}





}
}
# 18 "/usr/include/boost/system/errc.hpp" 2 3 4




namespace boost
{

namespace system
{



namespace errc
{


constexpr inline error_code make_error_code( errc_t e ) noexcept
{
    return error_code( e, generic_category() );
}


inline error_code make_error_code( errc_t e, boost::source_location const * loc ) noexcept
{
    return error_code( e, generic_category(), loc );
}


constexpr inline error_condition make_error_condition( errc_t e ) noexcept
{
    return error_condition( e, generic_category() );
}

}

}

}
# 10 "/usr/include/boost/system/system_error.hpp" 2 3 4



# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 1 3 4
# 42 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 3


# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 45 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cassert" 2 3
# 14 "/usr/include/boost/system/system_error.hpp" 2 3 4

namespace boost
{
namespace system
{

class __attribute__((__visibility__("default"))) system_error: public std::runtime_error
{
private:

    error_code code_;

public:

    explicit system_error( error_code const & ec ):
        std::runtime_error( ec.what() ), code_( ec ) {}

    system_error( error_code const & ec, std::string const & prefix ):
        std::runtime_error( prefix + ": " + ec.what() ), code_( ec ) {}

    system_error( error_code const & ec, char const * prefix ):
        std::runtime_error( std::string( prefix ) + ": " + ec.what() ), code_( ec ) {}

    system_error( int ev, error_category const & ecat ):
        std::runtime_error( error_code( ev, ecat ).what() ), code_( ev, ecat ) {}

    system_error( int ev, error_category const & ecat, std::string const & prefix ):
        std::runtime_error( prefix + ": " + error_code( ev, ecat ).what() ), code_( ev, ecat ) {}

    system_error( int ev, error_category const & ecat, char const * prefix ):
        std::runtime_error( std::string( prefix ) + ": " + error_code( ev, ecat ).what() ), code_( ev, ecat ) {}

    error_code code() const noexcept
    {
        return code_;
    }
};

}
}
# 23 "/usr/include/boost/thread/exceptions.hpp" 2 3 4
# 1 "/usr/include/boost/system/error_code.hpp" 1 3 4
# 14 "/usr/include/boost/system/error_code.hpp" 3 4
# 1 "/usr/include/boost/system/error_category.hpp" 1 3 4
# 15 "/usr/include/boost/system/error_code.hpp" 2 3 4
# 1 "/usr/include/boost/system/error_condition.hpp" 1 3 4
# 16 "/usr/include/boost/system/error_code.hpp" 2 3 4

# 1 "/usr/include/boost/system/generic_category.hpp" 1 3 4
# 18 "/usr/include/boost/system/error_code.hpp" 2 3 4
# 1 "/usr/include/boost/system/system_category.hpp" 1 3 4
# 19 "/usr/include/boost/system/error_code.hpp" 2 3 4
# 1 "/usr/include/boost/system/detail/throws.hpp" 1 3 4
# 13 "/usr/include/boost/system/detail/throws.hpp" 3 4
namespace boost
{

namespace system
{

class error_code;

}



namespace detail
{
# 36 "/usr/include/boost/system/detail/throws.hpp" 3 4
inline system::error_code* throws()
{
# 47 "/usr/include/boost/system/detail/throws.hpp" 3 4
    return reinterpret_cast<system::error_code*>(8);
}

}

inline system::error_code& throws()
{
    return *detail::throws();
}

}
# 20 "/usr/include/boost/system/error_code.hpp" 2 3 4
# 24 "/usr/include/boost/thread/exceptions.hpp" 2 3 4


# 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
# 27 "/usr/include/boost/thread/exceptions.hpp" 2 3 4

namespace boost
{


    class __attribute__((__visibility__("default"))) thread_interrupted
    {};


    class __attribute__((__visibility__("default"))) thread_exception:
        public system::system_error

    {
          typedef system::system_error base_type;
    public:
        thread_exception()
          : base_type(0,system::generic_category())
        {}

        thread_exception(int sys_error_code)
          : base_type(sys_error_code, system::generic_category())
        {}

        thread_exception( int ev, const char * what_arg )
        : base_type(system::error_code(ev, system::generic_category()), what_arg)
        {
        }
        thread_exception( int ev, const std::string & what_arg )
        : base_type(system::error_code(ev, system::generic_category()), what_arg)
        {
        }

        ~thread_exception() noexcept
        {}


        int native_error() const
        {
            return code().value();
        }

    };

    class __attribute__((__visibility__("default"))) condition_error:
        public system::system_error

    {
          typedef system::system_error base_type;
    public:
          condition_error()
          : base_type(system::error_code(0, system::generic_category()), "Condition error")
          {}
          condition_error( int ev )
          : base_type(system::error_code(ev, system::generic_category()), "Condition error")
          {
          }
          condition_error( int ev, const char * what_arg )
          : base_type(system::error_code(ev, system::generic_category()), what_arg)
          {
          }
          condition_error( int ev, const std::string & what_arg )
          : base_type(system::error_code(ev, system::generic_category()), what_arg)
          {
          }
    };


    class __attribute__((__visibility__("default"))) lock_error:
        public thread_exception
    {
          typedef thread_exception base_type;
    public:
        lock_error()
        : base_type(0, "boost::lock_error")
        {}

        lock_error( int ev )
        : base_type(ev, "boost::lock_error")
        {
        }
        lock_error( int ev, const char * what_arg )
        : base_type(ev, what_arg)
        {
        }
        lock_error( int ev, const std::string & what_arg )
        : base_type(ev, what_arg)
        {
        }

        ~lock_error() noexcept
        {}

    };

    class __attribute__((__visibility__("default"))) thread_resource_error:
        public thread_exception
    {
          typedef thread_exception base_type;
    public:
          thread_resource_error()
          : base_type(static_cast<int>(system::errc::resource_unavailable_try_again), "boost::thread_resource_error")
          {}

          thread_resource_error( int ev )
          : base_type(ev, "boost::thread_resource_error")
          {
          }
          thread_resource_error( int ev, const char * what_arg )
          : base_type(ev, what_arg)
          {
          }
          thread_resource_error( int ev, const std::string & what_arg )
          : base_type(ev, what_arg)
          {
          }


        ~thread_resource_error() noexcept
        {}

    };

    class __attribute__((__visibility__("default"))) unsupported_thread_option:
        public thread_exception
    {
          typedef thread_exception base_type;
    public:
          unsupported_thread_option()
          : base_type(static_cast<int>(system::errc::invalid_argument), "boost::unsupported_thread_option")
          {}

          unsupported_thread_option( int ev )
          : base_type(ev, "boost::unsupported_thread_option")
          {
          }
          unsupported_thread_option( int ev, const char * what_arg )
          : base_type(ev, what_arg)
          {
          }
          unsupported_thread_option( int ev, const std::string & what_arg )
          : base_type(ev, what_arg)
          {
          }

    };

    class __attribute__((__visibility__("default"))) invalid_thread_argument:
        public thread_exception
    {
          typedef thread_exception base_type;
    public:
        invalid_thread_argument()
        : base_type(static_cast<int>(system::errc::invalid_argument), "boost::invalid_thread_argument")
        {}

        invalid_thread_argument( int ev )
        : base_type(ev, "boost::invalid_thread_argument")
        {
        }
        invalid_thread_argument( int ev, const char * what_arg )
        : base_type(ev, what_arg)
        {
        }
        invalid_thread_argument( int ev, const std::string & what_arg )
        : base_type(ev, what_arg)
        {
        }

    };

    class __attribute__((__visibility__("default"))) thread_permission_error:
        public thread_exception
    {
          typedef thread_exception base_type;
    public:
          thread_permission_error()
          : base_type(static_cast<int>(system::errc::permission_denied), "boost::thread_permission_error")
          {}

          thread_permission_error( int ev )
          : base_type(ev, "boost::thread_permission_error")
          {
          }
          thread_permission_error( int ev, const char * what_arg )
          : base_type(ev, what_arg)
          {
          }
          thread_permission_error( int ev, const std::string & what_arg )
          : base_type(ev, what_arg)
          {
          }

    };

}

# 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
# 224 "/usr/include/boost/thread/exceptions.hpp" 2 3 4
# 15 "/usr/include/boost/thread/pthread/mutex.hpp" 2 3 4

# 1 "/usr/include/boost/thread/lock_types.hpp" 1 3 4
# 11 "/usr/include/boost/thread/lock_types.hpp" 3 4
# 1 "/usr/include/boost/thread/detail/move.hpp" 1 3 4
# 25 "/usr/include/boost/thread/detail/move.hpp" 3 4
# 1 "/usr/include/boost/move/utility.hpp" 1 3 4
# 27 "/usr/include/boost/move/utility.hpp" 3 4
# 1 "/usr/include/boost/move/detail/config_begin.hpp" 1 3 4
# 28 "/usr/include/boost/move/utility.hpp" 2 3 4
# 109 "/usr/include/boost/move/utility.hpp" 3 4
      namespace boost {
# 128 "/usr/include/boost/move/utility.hpp" 3 4
         template <class T>
         inline __attribute__ ((__always_inline__)) typename ::boost::move_detail::enable_if_c
            < ::boost::move_detail::is_nothrow_move_constructible_or_uncopyable<T>::value, T&&>::type
               move_if_noexcept(T& x) noexcept
         { return ::boost::move(x); }

         template <class T>
         inline __attribute__ ((__always_inline__)) typename ::boost::move_detail::enable_if_c
            < !::boost::move_detail::is_nothrow_move_constructible_or_uncopyable<T>::value, const T&>::type
               move_if_noexcept(T& x) noexcept
         { return x; }



      }





# 1 "/usr/include/boost/move/detail/config_end.hpp" 1 3 4
# 149 "/usr/include/boost/move/utility.hpp" 2 3 4
# 26 "/usr/include/boost/thread/detail/move.hpp" 2 3 4

# 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
# 28 "/usr/include/boost/thread/detail/move.hpp" 2 3 4



namespace boost
{

    namespace detail
    {
      template <typename T>
      struct enable_move_utility_emulation_dummy_specialization;
        template<typename T>
        struct thread_move_t
        {
            T& t;
            explicit thread_move_t(T& t_):
                t(t_)
            {}

            T& operator*() const
            {
                return t;
            }

            T* operator->() const
            {
                return &t;
            }
        private:
            void operator=(thread_move_t&);
        };
    }




    template<typename T>
    typename enable_if<boost::is_convertible<T&,boost::detail::thread_move_t<T> >, boost::detail::thread_move_t<T> >::type move(T& t)
    {
        return boost::detail::thread_move_t<T>(t);
    }


    template<typename T>
    boost::detail::thread_move_t<T> move(boost::detail::thread_move_t<T> t)
    {
        return t;
    }


}
# 281 "/usr/include/boost/thread/detail/move.hpp" 3 4
namespace boost
{
  namespace thread_detail
  {
# 311 "/usr/include/boost/thread/detail/move.hpp" 3 4
    template <class Tp>
    struct remove_reference : boost::remove_reference<Tp> {};
    template <class Tp>
    struct decay : boost::decay<Tp> {};
# 353 "/usr/include/boost/thread/detail/move.hpp" 3 4
  template <class T>
  typename decay<T>::type
  decay_copy(T&& t)
  {
      return boost::forward<T>(t);
  }
  typedef void (*void_fct_ptr)();
# 374 "/usr/include/boost/thread/detail/move.hpp" 3 4
  }
}

# 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
# 378 "/usr/include/boost/thread/detail/move.hpp" 2 3 4
# 12 "/usr/include/boost/thread/lock_types.hpp" 2 3 4

# 1 "/usr/include/boost/thread/lock_options.hpp" 1 3 4
# 10 "/usr/include/boost/thread/lock_options.hpp" 3 4
# 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
# 11 "/usr/include/boost/thread/lock_options.hpp" 2 3 4

namespace boost
{
  struct defer_lock_t
  {
  };
  struct try_to_lock_t
  {
  };
  struct adopt_lock_t
  {
  };

  constexpr defer_lock_t defer_lock = {};
  constexpr try_to_lock_t try_to_lock = {};
  constexpr adopt_lock_t adopt_lock = {};

}
# 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
# 30 "/usr/include/boost/thread/lock_options.hpp" 2 3 4
# 14 "/usr/include/boost/thread/lock_types.hpp" 2 3 4
# 1 "/usr/include/boost/thread/lockable_traits.hpp" 1 3 4
# 12 "/usr/include/boost/thread/lockable_traits.hpp" 3 4
# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 58 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 59 "/usr/include/boost/assert.hpp" 2 3 4
# 13 "/usr/include/boost/thread/lockable_traits.hpp" 2 3 4








# 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
# 22 "/usr/include/boost/thread/lockable_traits.hpp" 2 3 4



namespace boost
{
  namespace sync
  {
# 39 "/usr/include/boost/thread/lockable_traits.hpp" 3 4
    namespace detail
    {
# 152 "/usr/include/boost/thread/lockable_traits.hpp" 3 4
      template<typename T,typename Enabled=void>
      struct has_member_lock : false_type {};

      template<typename T>
      struct has_member_lock<T,
          decltype(void(boost::declval<T&>().lock()))
      > : true_type {};

      template<typename T,typename Enabled=void>
      struct has_member_unlock : false_type {};

      template<typename T>
      struct has_member_unlock<T,
          decltype(void(boost::declval<T&>().unlock()))
      > : true_type {};

      template<typename T,typename Enabled=bool>
      struct has_member_try_lock : false_type {};

      template<typename T>
      struct has_member_try_lock<T,
          decltype(bool(boost::declval<T&>().try_lock()))
      > : true_type {};


    }

    template<typename T>
    struct is_basic_lockable
    {
      static const bool value = detail::has_member_lock<T>::value && detail::has_member_unlock<T>::value;

    };
    template<typename T>
    struct is_lockable
    {
      static const bool value = is_basic_lockable<T>::value && detail::has_member_try_lock<T>::value;


    };
# 206 "/usr/include/boost/thread/lockable_traits.hpp" 3 4
    template<typename T>
    struct is_recursive_mutex_sur_parole
    {
      static const bool value = false;
    };
    template<typename T>
    struct is_recursive_mutex_sur_parolle : is_recursive_mutex_sur_parole<T>
    {
    };

    template<typename T>
    struct is_recursive_basic_lockable
    {
      static const bool value = is_basic_lockable<T>::value && is_recursive_mutex_sur_parolle<T>::value;

    };
    template<typename T>
    struct is_recursive_lockable
    {
      static const bool value = is_lockable<T>::value && is_recursive_mutex_sur_parolle<T>::value;

    };
  }
  template<typename T>
  struct is_mutex_type
  {
    static const bool value = sync::is_lockable<T>::value;
  };

}
# 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
# 237 "/usr/include/boost/thread/lockable_traits.hpp" 2 3 4
# 15 "/usr/include/boost/thread/lock_types.hpp" 2 3 4



# 1 "/usr/include/boost/thread/thread_time.hpp" 1 3 4








# 1 "/usr/include/boost/date_time/time_clock.hpp" 1 3 4
# 16 "/usr/include/boost/date_time/time_clock.hpp" 3 4
# 1 "/usr/include/boost/date_time/c_time.hpp" 1 3 4
# 17 "/usr/include/boost/date_time/c_time.hpp" 3 4
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ctime" 1 3 4
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ctime" 3
# 18 "/usr/include/boost/date_time/c_time.hpp" 2 3 4



# 1 "/usr/include/boost/date_time/compiler_config.hpp" 1 3 4
# 11 "/usr/include/boost/date_time/compiler_config.hpp" 3 4
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdlib" 1 3 4
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdlib" 3
# 12 "/usr/include/boost/date_time/compiler_config.hpp" 2 3 4






# 1 "/usr/include/boost/date_time/locale_config.hpp" 1 3 4
# 19 "/usr/include/boost/date_time/compiler_config.hpp" 2 3 4
# 37 "/usr/include/boost/date_time/compiler_config.hpp" 3 4
# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 38 "/usr/include/boost/date_time/compiler_config.hpp" 2 3 4
# 22 "/usr/include/boost/date_time/c_time.hpp" 2 3 4
# 38 "/usr/include/boost/date_time/c_time.hpp" 3 4
namespace boost {
namespace date_time {
# 52 "/usr/include/boost/date_time/c_time.hpp" 3 4
  struct c_time {
    public:


      inline
      static std::tm* localtime(const std::time_t* t, std::tm* result)
      {
# 67 "/usr/include/boost/date_time/c_time.hpp" 3 4
        result = localtime_r(t, result);

        if (!result)
          boost::throw_exception(std::runtime_error("could not convert calendar time to local time"));
        return result;
      }

      inline
      static std::tm* gmtime(const std::time_t* t, std::tm* result)
      {
# 85 "/usr/include/boost/date_time/c_time.hpp" 3 4
        result = gmtime_r(t, result);

        if (!result)
          boost::throw_exception(std::runtime_error("could not convert calendar time to UTC time"));
        return result;
      }
# 125 "/usr/include/boost/date_time/c_time.hpp" 3 4
  };
}}
# 17 "/usr/include/boost/date_time/time_clock.hpp" 2 3 4
# 1 "/usr/include/boost/shared_ptr.hpp" 1 3 4
# 17 "/usr/include/boost/shared_ptr.hpp" 3 4
# 1 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 1 3 4
# 17 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
# 1 "/usr/include/boost/smart_ptr/detail/requires_cxx11.hpp" 1 3 4
# 18 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4
# 1 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 1 3 4
# 25 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
# 1 "/usr/include/boost/smart_ptr/bad_weak_ptr.hpp" 1 3 4
# 27 "/usr/include/boost/smart_ptr/bad_weak_ptr.hpp" 3 4
namespace boost
{
# 42 "/usr/include/boost/smart_ptr/bad_weak_ptr.hpp" 3 4
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wweak-vtables"


class bad_weak_ptr: public std::exception
{
public:

    char const * what() const noexcept override
    {
        return "tr1::bad_weak_ptr";
    }
};


#pragma clang diagnostic pop






}
# 26 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 2 3 4
# 1 "/usr/include/boost/smart_ptr/detail/sp_counted_base.hpp" 1 3 4
# 20 "/usr/include/boost/smart_ptr/detail/sp_counted_base.hpp" 3 4
# 1 "/usr/include/boost/smart_ptr/detail/sp_has_gcc_intrinsics.hpp" 1 3 4
# 21 "/usr/include/boost/smart_ptr/detail/sp_counted_base.hpp" 2 3 4
# 1 "/usr/include/boost/smart_ptr/detail/sp_has_sync_intrinsics.hpp" 1 3 4
# 22 "/usr/include/boost/smart_ptr/detail/sp_counted_base.hpp" 2 3 4
# 40 "/usr/include/boost/smart_ptr/detail/sp_counted_base.hpp" 3 4
# 1 "/usr/include/boost/smart_ptr/detail/sp_counted_base_gcc_atomic.hpp" 1 3 4
# 16 "/usr/include/boost/smart_ptr/detail/sp_counted_base_gcc_atomic.hpp" 3 4
# 1 "/usr/include/boost/smart_ptr/detail/sp_typeinfo_.hpp" 1 3 4
# 42 "/usr/include/boost/smart_ptr/detail/sp_typeinfo_.hpp" 3 4
namespace boost
{

namespace detail
{

typedef std::type_info sp_typeinfo_;

}

}
# 17 "/usr/include/boost/smart_ptr/detail/sp_counted_base_gcc_atomic.hpp" 2 3 4

# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 19 "/usr/include/boost/smart_ptr/detail/sp_counted_base_gcc_atomic.hpp" 2 3 4








namespace boost
{

namespace detail
{

inline void atomic_increment( boost::uint_least32_t * pw )
{
    __atomic_fetch_add( pw, 1, 0 );
}

inline boost::uint_least32_t atomic_decrement( boost::uint_least32_t * pw )
{
    return __atomic_fetch_sub( pw, 1, 4 );
}

inline boost::uint_least32_t atomic_conditional_increment( boost::uint_least32_t * pw )
{




    boost::uint_least32_t r = __atomic_load_n( pw, 0 );

    for( ;; )
    {
        if( r == 0 )
        {
            return r;
        }

        if( __atomic_compare_exchange_n( pw, &r, r + 1, true, 0, 0 ) )
        {
            return r;
        }
    }
}

inline boost::uint_least32_t atomic_load( boost::uint_least32_t const * pw )
{
    return __atomic_load_n( pw, 2 );
}

class __attribute__((__visibility__("default"))) sp_counted_base
{
private:

    sp_counted_base( sp_counted_base const & );
    sp_counted_base & operator= ( sp_counted_base const & );

    boost::uint_least32_t use_count_;
    boost::uint_least32_t weak_count_;

public:

    sp_counted_base(): use_count_( 1 ), weak_count_( 1 )
    {
    }

    virtual ~sp_counted_base()
    {
    }




    virtual void dispose() = 0;



    virtual void destroy()
    {
        delete this;
    }

    virtual void * get_deleter( sp_typeinfo_ const & ti ) = 0;
    virtual void * get_local_deleter( sp_typeinfo_ const & ti ) = 0;
    virtual void * get_untyped_deleter() = 0;

    void add_ref_copy()
    {
        atomic_increment( &use_count_ );
    }

    bool add_ref_lock()
    {
        return atomic_conditional_increment( &use_count_ ) != 0;
    }

    void release()
    {
        if( atomic_decrement( &use_count_ ) == 1 )
        {
            dispose();
            weak_release();
        }
    }

    void weak_add_ref()
    {
        atomic_increment( &weak_count_ );
    }

    void weak_release()
    {
        if( atomic_decrement( &weak_count_ ) == 1 )
        {
            destroy();
        }
    }

    long use_count() const
    {
        return static_cast<long>( atomic_load( &use_count_ ) );
    }
};

}

}
# 41 "/usr/include/boost/smart_ptr/detail/sp_counted_base.hpp" 2 3 4
# 27 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 2 3 4
# 1 "/usr/include/boost/smart_ptr/detail/sp_counted_impl.hpp" 1 3 4
# 26 "/usr/include/boost/smart_ptr/detail/sp_counted_impl.hpp" 3 4
# 1 "/usr/include/boost/smart_ptr/detail/sp_noexcept.hpp" 1 3 4
# 27 "/usr/include/boost/smart_ptr/detail/sp_counted_impl.hpp" 2 3 4
# 38 "/usr/include/boost/smart_ptr/detail/sp_counted_impl.hpp" 3 4
namespace boost
{
# 48 "/usr/include/boost/smart_ptr/detail/sp_counted_impl.hpp" 3 4
namespace detail
{



template<class D> class local_sp_deleter;

template<class D> D * get_local_deleter( D * ) noexcept
{
    return 0;
}

template<class D> D * get_local_deleter( local_sp_deleter<D> * p ) noexcept;



template<class X> class __attribute__((__visibility__("default"))) sp_counted_impl_p: public sp_counted_base
{
private:

    X * px_;

    sp_counted_impl_p( sp_counted_impl_p const & );
    sp_counted_impl_p & operator= ( sp_counted_impl_p const & );

    typedef sp_counted_impl_p<X> this_type;

public:

    explicit sp_counted_impl_p( X * px ): px_( px )
    {



    }

    void dispose() noexcept override
    {



        boost::checked_delete( px_ );
    }

    void * get_deleter( sp_typeinfo_ const & ) noexcept override
    {
        return 0;
    }

    void * get_local_deleter( sp_typeinfo_ const & ) noexcept override
    {
        return 0;
    }

    void * get_untyped_deleter() noexcept override
    {
        return 0;
    }
# 134 "/usr/include/boost/smart_ptr/detail/sp_counted_impl.hpp" 3 4
};
# 143 "/usr/include/boost/smart_ptr/detail/sp_counted_impl.hpp" 3 4
template<class P, class D> class __attribute__((__visibility__("default"))) sp_counted_impl_pd: public sp_counted_base
{
private:

    P ptr;
    D del;

    sp_counted_impl_pd( sp_counted_impl_pd const & );
    sp_counted_impl_pd & operator= ( sp_counted_impl_pd const & );

    typedef sp_counted_impl_pd<P, D> this_type;

public:





    sp_counted_impl_pd( P p, D & d ): ptr( p ), del( static_cast< D&& >( d ) )
    {
    }
# 173 "/usr/include/boost/smart_ptr/detail/sp_counted_impl.hpp" 3 4
    sp_counted_impl_pd( P p ): ptr( p ), del()
    {
    }

    void dispose() noexcept override
    {
        del( ptr );
    }

    void * get_deleter( sp_typeinfo_ const & ti ) noexcept override
    {
        return ti == typeid(D)? &reinterpret_cast<char&>( del ): 0;
    }

    void * get_local_deleter( sp_typeinfo_ const & ti ) noexcept override
    {
        return ti == typeid(D)? boost::detail::get_local_deleter( boost::addressof( del ) ): 0;
    }

    void * get_untyped_deleter() noexcept override
    {
        return &reinterpret_cast<char&>( del );
    }
# 224 "/usr/include/boost/smart_ptr/detail/sp_counted_impl.hpp" 3 4
};

template<class P, class D, class A> class __attribute__((__visibility__("default"))) sp_counted_impl_pda: public sp_counted_base
{
private:

    P p_;
    D d_;
    A a_;

    sp_counted_impl_pda( sp_counted_impl_pda const & );
    sp_counted_impl_pda & operator= ( sp_counted_impl_pda const & );

    typedef sp_counted_impl_pda<P, D, A> this_type;

public:





    sp_counted_impl_pda( P p, D & d, A a ): p_( p ), d_( static_cast< D&& >( d ) ), a_( a )
    {
    }
# 257 "/usr/include/boost/smart_ptr/detail/sp_counted_impl.hpp" 3 4
    sp_counted_impl_pda( P p, A a ): p_( p ), d_( a ), a_( a )
    {
    }

    void dispose() noexcept override
    {
        d_( p_ );
    }

    void destroy() noexcept override
    {


        typedef typename std::allocator_traits<A>::template rebind_alloc< this_type > A2;







        A2 a2( a_ );

        this->~this_type();

        a2.deallocate( this, 1 );
    }

    void * get_deleter( sp_typeinfo_ const & ti ) noexcept override
    {
        return ti == typeid(D)? &reinterpret_cast<char&>( d_ ): 0;
    }

    void * get_local_deleter( sp_typeinfo_ const & ti ) noexcept override
    {
        return ti == typeid(D)? boost::detail::get_local_deleter( boost::addressof( d_ ) ): 0;
    }

    void * get_untyped_deleter() noexcept override
    {
        return &reinterpret_cast<char&>( d_ );
    }
};





}

}
# 28 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 2 3 4
# 1 "/usr/include/boost/smart_ptr/detail/sp_disable_deprecated.hpp" 1 3 4
# 29 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 2 3 4






# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 36 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 2 3 4
# 45 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"


namespace boost
{

namespace movelib
{

template< class T, class D > class unique_ptr;

}

namespace detail
{
# 69 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
struct sp_nothrow_tag {};

template< class D > struct sp_inplace_tag
{
};

template< class T > class sp_reference_wrapper
{
public:

    explicit sp_reference_wrapper( T & t): t_( boost::addressof( t ) )
    {
    }

    template< class Y > void operator()( Y * p ) const
    {
        (*t_)( p );
    }

private:

    T * t_;
};

template< class D > struct sp_convert_reference
{
    typedef D type;
};

template< class D > struct sp_convert_reference< D& >
{
    typedef sp_reference_wrapper< D > type;
};

template<class T> std::size_t sp_hash_pointer( T* p ) noexcept
{
    boost::uintptr_t v = reinterpret_cast<boost::uintptr_t>( p );


    return static_cast<std::size_t>( v + ( v >> 3 ) );
}

class weak_count;

class shared_count
{
private:

    sp_counted_base * pi_;





    friend class weak_count;

public:

    constexpr shared_count() noexcept: pi_(0)



    {
    }

    constexpr explicit shared_count( sp_counted_base * pi ) noexcept: pi_( pi )



    {
    }

    template<class Y> explicit shared_count( Y * p ): pi_( 0 )



    {


        try
        {
            pi_ = new sp_counted_impl_p<Y>( p );
        }
        catch(...)
        {
            boost::checked_delete( p );
            throw;
        }
# 169 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
    }




    template<class P, class D> shared_count( P p, D d ): pi_(0)




    {





        try
        {
            pi_ = new sp_counted_impl_pd<P, D>(p, d);
        }
        catch(...)
        {
            d(p);
            throw;
        }
# 206 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
    }



    template< class P, class D > shared_count( P p, sp_inplace_tag<D> ): pi_( 0 )



    {


        try
        {
            pi_ = new sp_counted_impl_pd< P, D >( p );
        }
        catch( ... )
        {
            D::operator_fn( p );
            throw;
        }
# 238 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
    }



    template<class P, class D, class A> shared_count( P p, D d, A a ): pi_( 0 )



    {
        typedef sp_counted_impl_pda<P, D, A> impl_type;



        typedef typename std::allocator_traits<A>::template rebind_alloc< impl_type > A2;







        A2 a2( a );



        try
        {
            pi_ = a2.allocate( 1 );
            ::new( static_cast< void* >( pi_ ) ) impl_type( p, d, a );
        }
        catch(...)
        {
            d( p );

            if( pi_ != 0 )
            {
                a2.deallocate( static_cast< impl_type* >( pi_ ), 1 );
            }

            throw;
        }
# 295 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
    }



    template< class P, class D, class A > shared_count( P p, sp_inplace_tag< D >, A a ): pi_( 0 )



    {
        typedef sp_counted_impl_pda< P, D, A > impl_type;



        typedef typename std::allocator_traits<A>::template rebind_alloc< impl_type > A2;







        A2 a2( a );



        try
        {
            pi_ = a2.allocate( 1 );
            ::new( static_cast< void* >( pi_ ) ) impl_type( p, a );
        }
        catch(...)
        {
            D::operator_fn( p );

            if( pi_ != 0 )
            {
                a2.deallocate( static_cast< impl_type* >( pi_ ), 1 );
            }

            throw;
        }
# 352 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
    }







    template<class Y>
    explicit shared_count( std::auto_ptr<Y> & r ): pi_( new sp_counted_impl_p<Y>( r.get() ) )



    {
# 375 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
        r.release();
    }





    template<class Y, class D>
    explicit shared_count( std::unique_ptr<Y, D> & r ): pi_( 0 )



    {
        typedef typename sp_convert_reference<D>::type D2;

        D2 d2( static_cast<D&&>( r.get_deleter() ) );
        pi_ = new sp_counted_impl_pd< typename std::unique_ptr<Y, D>::pointer, D2 >( r.get(), d2 );
# 402 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
        r.release();
    }



    template<class Y, class D>
    explicit shared_count( boost::movelib::unique_ptr<Y, D> & r ): pi_( 0 )



    {
        typedef typename sp_convert_reference<D>::type D2;

        D2 d2( r.get_deleter() );
        pi_ = new sp_counted_impl_pd< typename boost::movelib::unique_ptr<Y, D>::pointer, D2 >( r.get(), d2 );
# 427 "/usr/include/boost/smart_ptr/detail/shared_count.hpp" 3 4
        r.release();
    }

    ~shared_count()
    {
        if( pi_ != 0 ) pi_->release();



    }

    shared_count(shared_count const & r) noexcept: pi_(r.pi_)



    {
        if( pi_ != 0 ) pi_->add_ref_copy();
    }



    shared_count(shared_count && r) noexcept: pi_(r.pi_)



    {
        r.pi_ = 0;
    }



    explicit shared_count(weak_count const & r);
    shared_count( weak_count const & r, sp_nothrow_tag ) noexcept;

    shared_count & operator= (shared_count const & r) noexcept
    {
        sp_counted_base * tmp = r.pi_;

        if( tmp != pi_ )
        {
            if( tmp != 0 ) tmp->add_ref_copy();
            if( pi_ != 0 ) pi_->release();
            pi_ = tmp;
        }

        return *this;
    }

    void swap(shared_count & r) noexcept
    {
        sp_counted_base * tmp = r.pi_;
        r.pi_ = pi_;
        pi_ = tmp;
    }

    long use_count() const noexcept
    {
        return pi_ != 0? pi_->use_count(): 0;
    }

    bool unique() const noexcept
    {
        return use_count() == 1;
    }

    bool empty() const noexcept
    {
        return pi_ == 0;
    }

    bool operator==( shared_count const & r ) const noexcept
    {
        return pi_ == r.pi_;
    }

    bool operator==( weak_count const & r ) const noexcept;

    bool operator<( shared_count const & r ) const noexcept
    {
        return std::less<sp_counted_base *>()( pi_, r.pi_ );
    }

    bool operator<( weak_count const & r ) const noexcept;

    void * get_deleter( sp_typeinfo_ const & ti ) const noexcept
    {
        return pi_? pi_->get_deleter( ti ): 0;
    }

    void * get_local_deleter( sp_typeinfo_ const & ti ) const noexcept
    {
        return pi_? pi_->get_local_deleter( ti ): 0;
    }

    void * get_untyped_deleter() const noexcept
    {
        return pi_? pi_->get_untyped_deleter(): 0;
    }

    std::size_t hash_value() const noexcept
    {
        return sp_hash_pointer( pi_ );
    }
};


class weak_count
{
private:

    sp_counted_base * pi_;





    friend class shared_count;

public:

    constexpr weak_count() noexcept: pi_(0)



    {
    }

    weak_count(shared_count const & r) noexcept: pi_(r.pi_)



    {
        if(pi_ != 0) pi_->weak_add_ref();
    }

    weak_count(weak_count const & r) noexcept: pi_(r.pi_)



    {
        if(pi_ != 0) pi_->weak_add_ref();
    }





    weak_count(weak_count && r) noexcept: pi_(r.pi_)



    {
        r.pi_ = 0;
    }



    ~weak_count()
    {
        if(pi_ != 0) pi_->weak_release();



    }

    weak_count & operator= (shared_count const & r) noexcept
    {
        sp_counted_base * tmp = r.pi_;

        if( tmp != pi_ )
        {
            if(tmp != 0) tmp->weak_add_ref();
            if(pi_ != 0) pi_->weak_release();
            pi_ = tmp;
        }

        return *this;
    }

    weak_count & operator= (weak_count const & r) noexcept
    {
        sp_counted_base * tmp = r.pi_;

        if( tmp != pi_ )
        {
            if(tmp != 0) tmp->weak_add_ref();
            if(pi_ != 0) pi_->weak_release();
            pi_ = tmp;
        }

        return *this;
    }

    void swap(weak_count & r) noexcept
    {
        sp_counted_base * tmp = r.pi_;
        r.pi_ = pi_;
        pi_ = tmp;
    }

    long use_count() const noexcept
    {
        return pi_ != 0? pi_->use_count(): 0;
    }

    bool empty() const noexcept
    {
        return pi_ == 0;
    }

    bool operator==( weak_count const & r ) const noexcept
    {
        return pi_ == r.pi_;
    }

    bool operator==( shared_count const & r ) const noexcept
    {
        return pi_ == r.pi_;
    }

    bool operator<( weak_count const & r ) const noexcept
    {
        return std::less<sp_counted_base *>()( pi_, r.pi_ );
    }

    bool operator<( shared_count const & r ) const noexcept
    {
        return std::less<sp_counted_base *>()( pi_, r.pi_ );
    }

    std::size_t hash_value() const noexcept
    {
        return sp_hash_pointer( pi_ );
    }
};

inline shared_count::shared_count( weak_count const & r ): pi_( r.pi_ )



{
    if( pi_ == 0 || !pi_->add_ref_lock() )
    {
        boost::throw_exception( boost::bad_weak_ptr() );
    }
}

inline shared_count::shared_count( weak_count const & r, sp_nothrow_tag ) noexcept: pi_( r.pi_ )



{
    if( pi_ != 0 && !pi_->add_ref_lock() )
    {
        pi_ = 0;
    }
}

inline bool shared_count::operator==( weak_count const & r ) const noexcept
{
    return pi_ == r.pi_;
}

inline bool shared_count::operator<( weak_count const & r ) const noexcept
{
    return std::less<sp_counted_base *>()( pi_, r.pi_ );
}

}

}


#pragma GCC diagnostic pop
# 19 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4
# 1 "/usr/include/boost/smart_ptr/detail/sp_convertible.hpp" 1 3 4
# 35 "/usr/include/boost/smart_ptr/detail/sp_convertible.hpp" 3 4
namespace boost
{

namespace detail
{

template< class Y, class T > struct sp_convertible
{
    typedef char (&yes) [1];
    typedef char (&no) [2];

    static yes f( T* );
    static no f( ... );

    enum _vt { value = sizeof( (f)( static_cast<Y*>(0) ) ) == sizeof(yes) };
};

template< class Y, class T > struct sp_convertible< Y, T[] >
{
    enum _vt { value = false };
};

template< class Y, class T > struct sp_convertible< Y[], T[] >
{
    enum _vt { value = sp_convertible< Y[1], T[1] >::value };
};

template< class Y, std::size_t N, class T > struct sp_convertible< Y[N], T[] >
{
    enum _vt { value = sp_convertible< Y[1], T[1] >::value };
};

struct sp_empty
{
};

template< bool > struct sp_enable_if_convertible_impl;

template<> struct sp_enable_if_convertible_impl<true>
{
    typedef sp_empty type;
};

template<> struct sp_enable_if_convertible_impl<false>
{
};

template< class Y, class T > struct sp_enable_if_convertible: public sp_enable_if_convertible_impl< sp_convertible< Y, T >::value >
{
};

}

}
# 20 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4
# 1 "/usr/include/boost/smart_ptr/detail/sp_nullptr_t.hpp" 1 3 4
# 23 "/usr/include/boost/smart_ptr/detail/sp_nullptr_t.hpp" 3 4
namespace boost
{

namespace detail
{



    typedef decltype(nullptr) sp_nullptr_t;







}

}
# 21 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4




# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 58 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 59 "/usr/include/boost/assert.hpp" 2 3 4
# 26 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4




# 1 "/usr/include/boost/smart_ptr/detail/spinlock_pool.hpp" 1 3 4
# 25 "/usr/include/boost/smart_ptr/detail/spinlock_pool.hpp" 3 4
# 1 "/usr/include/boost/smart_ptr/detail/spinlock.hpp" 1 3 4
# 42 "/usr/include/boost/smart_ptr/detail/spinlock.hpp" 3 4
# 1 "/usr/include/boost/smart_ptr/detail/spinlock_gcc_atomic.hpp" 1 3 4
# 14 "/usr/include/boost/smart_ptr/detail/spinlock_gcc_atomic.hpp" 3 4
# 1 "/usr/include/boost/smart_ptr/detail/yield_k.hpp" 1 3 4
# 22 "/usr/include/boost/smart_ptr/detail/yield_k.hpp" 3 4
# 1 "/usr/include/boost/core/yield_primitives.hpp" 1 3 4







# 1 "/usr/include/boost/core/detail/sp_thread_pause.hpp" 1 3 4
# 56 "/usr/include/boost/core/detail/sp_thread_pause.hpp" 3 4
namespace boost
{
namespace core
{

inline __attribute__ ((__always_inline__)) void sp_thread_pause() noexcept
{
    __builtin_ia32_pause();
}

}
}
# 9 "/usr/include/boost/core/yield_primitives.hpp" 2 3 4
# 1 "/usr/include/boost/core/detail/sp_thread_yield.hpp" 1 3 4
# 64 "/usr/include/boost/core/detail/sp_thread_yield.hpp" 3 4
namespace boost
{
namespace core
{

inline void sp_thread_yield() noexcept
{
    sched_yield();
}

}
}
# 10 "/usr/include/boost/core/yield_primitives.hpp" 2 3 4
# 1 "/usr/include/boost/core/detail/sp_thread_sleep.hpp" 1 3 4
# 63 "/usr/include/boost/core/detail/sp_thread_sleep.hpp" 3 4
namespace boost
{
namespace core
{

inline void sp_thread_sleep() noexcept
{


    int oldst;
    pthread_setcancelstate( PTHREAD_CANCEL_DISABLE, &oldst );




    struct timespec rqtp = { 0, 0 };




    rqtp.tv_sec = 0;
    rqtp.tv_nsec = 1000;

    nanosleep( &rqtp, 0 );



    pthread_setcancelstate( oldst, &oldst );



}

}
}
# 11 "/usr/include/boost/core/yield_primitives.hpp" 2 3 4
# 23 "/usr/include/boost/smart_ptr/detail/yield_k.hpp" 2 3 4

namespace boost
{

namespace detail
{

inline void yield( unsigned k )
{



    if( k & 1 )
    {
        boost::core::sp_thread_sleep();
    }
    else
    {
        boost::core::sp_thread_pause();
    }
}

}

}
# 15 "/usr/include/boost/smart_ptr/detail/spinlock_gcc_atomic.hpp" 2 3 4








namespace boost
{

namespace detail
{

class spinlock
{
public:






    union
    {
        unsigned char v_;
        bool align_;
    };

public:

    bool try_lock()
    {
        return __atomic_test_and_set( &v_, 2 ) == 0;
    }

    void lock()
    {
        for( unsigned k = 0; !try_lock(); ++k )
        {
            boost::detail::yield( k );
        }
    }

    void unlock()
    {
        __atomic_clear( &v_, 3 );
    }

public:

    class scoped_lock
    {
    private:

        spinlock & sp_;

        scoped_lock( scoped_lock const & );
        scoped_lock & operator=( scoped_lock const & );

    public:

        explicit scoped_lock( spinlock & sp ): sp_( sp )
        {
            sp.lock();
        }

        ~scoped_lock()
        {
            sp_.unlock();
        }
    };
};

}
}
# 43 "/usr/include/boost/smart_ptr/detail/spinlock.hpp" 2 3 4
# 26 "/usr/include/boost/smart_ptr/detail/spinlock_pool.hpp" 2 3 4


namespace boost
{

namespace detail
{

template< int M > class spinlock_pool
{
private:

    static spinlock pool_[ 41 ];

public:

    static spinlock & spinlock_for( void const * pv )
    {



        std::size_t i = reinterpret_cast< std::size_t >( pv ) % 41;

        return pool_[ i ];
    }

    class scoped_lock
    {
    private:

        spinlock & sp_;

        scoped_lock( scoped_lock const & );
        scoped_lock & operator=( scoped_lock const & );

    public:

        explicit scoped_lock( void const * pv ): sp_( spinlock_for( pv ) )
        {
            sp_.lock();
        }

        ~scoped_lock()
        {
            sp_.unlock();
        }
    };
};

template< int M > spinlock spinlock_pool< M >::pool_[ 41 ] =
{
    {{0}}, {{0}}, {{0}}, {{0}}, {{0}},
    {{0}}, {{0}}, {{0}}, {{0}}, {{0}},
    {{0}}, {{0}}, {{0}}, {{0}}, {{0}},
    {{0}}, {{0}}, {{0}}, {{0}}, {{0}},
    {{0}}, {{0}}, {{0}}, {{0}}, {{0}},
    {{0}}, {{0}}, {{0}}, {{0}}, {{0}},
    {{0}}, {{0}}, {{0}}, {{0}}, {{0}},
    {{0}}, {{0}}, {{0}}, {{0}}, {{0}},
    {{0}}
};

}
}
# 31 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4
# 48 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"


namespace boost
{

template<class T> class shared_ptr;
template<class T> class weak_ptr;
template<class T> class enable_shared_from_this;
class enable_shared_from_raw;

namespace movelib
{

    template< class T, class D > class unique_ptr;

}

namespace detail
{



template< class T > struct sp_element
{
    typedef T type;
};



template< class T > struct sp_element< T[] >
{
    typedef T type;
};



template< class T, std::size_t N > struct sp_element< T[N] >
{
    typedef T type;
};







template< class T > struct sp_dereference
{
    typedef T & type;
};

template<> struct sp_dereference< void >
{
    typedef void type;
};



template<> struct sp_dereference< void const >
{
    typedef void type;
};

template<> struct sp_dereference< void volatile >
{
    typedef void type;
};

template<> struct sp_dereference< void const volatile >
{
    typedef void type;
};





template< class T > struct sp_dereference< T[] >
{
    typedef void type;
};



template< class T, std::size_t N > struct sp_dereference< T[N] >
{
    typedef void type;
};







template< class T > struct sp_member_access
{
    typedef T * type;
};



template< class T > struct sp_member_access< T[] >
{
    typedef void type;
};



template< class T, std::size_t N > struct sp_member_access< T[N] >
{
    typedef void type;
};







template< class T > struct sp_array_access
{
    typedef void type;
};



template< class T > struct sp_array_access< T[] >
{
    typedef T & type;
};



template< class T, std::size_t N > struct sp_array_access< T[N] >
{
    typedef T & type;
};







template< class T > struct sp_extent
{
    enum _vt { value = 0 };
};



template< class T, std::size_t N > struct sp_extent< T[N] >
{
    enum _vt { value = N };
};





template< class X, class Y, class T > inline void sp_enable_shared_from_this( boost::shared_ptr<X> const * ppx, Y const * py, boost::enable_shared_from_this< T > const * pe )
{
    if( pe != 0 )
    {
        pe->_internal_accept_owner( ppx, const_cast< Y* >( py ) );
    }
}

template< class X, class Y > inline void sp_enable_shared_from_this( boost::shared_ptr<X> * ppx, Y const * py, boost::enable_shared_from_raw const * pe );
# 237 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
inline void sp_enable_shared_from_this( ... )
{
}







template< class T, class R > struct sp_enable_if_auto_ptr
{
};

template< class T, class R > struct sp_enable_if_auto_ptr< std::auto_ptr< T >, R >
{
    typedef R type;
};





template< class Y, class T > inline void sp_assert_convertible() noexcept
{



    typedef char tmp[ sp_convertible< Y, T >::value? 1: -1 ];
    (void)sizeof( tmp );







}



template< class T, class Y > inline void sp_pointer_construct( boost::shared_ptr< T > * ppx, Y * p, boost::detail::shared_count & pn )
{
    boost::detail::shared_count( p ).swap( pn );
    boost::detail::sp_enable_shared_from_this( ppx, p, p );
}



template< class T, class Y > inline void sp_pointer_construct( boost::shared_ptr< T[] > * , Y * p, boost::detail::shared_count & pn )
{
    sp_assert_convertible< Y[], T[] >();
    boost::detail::shared_count( p, boost::checked_array_deleter< T >() ).swap( pn );
}

template< class T, std::size_t N, class Y > inline void sp_pointer_construct( boost::shared_ptr< T[N] > * , Y * p, boost::detail::shared_count & pn )
{
    sp_assert_convertible< Y[N], T[N] >();
    boost::detail::shared_count( p, boost::checked_array_deleter< T >() ).swap( pn );
}





template< class T, class Y > inline void sp_deleter_construct( boost::shared_ptr< T > * ppx, Y * p )
{
    boost::detail::sp_enable_shared_from_this( ppx, p, p );
}



template< class T, class Y > inline void sp_deleter_construct( boost::shared_ptr< T[] > * , Y * )
{
    sp_assert_convertible< Y[], T[] >();
}

template< class T, std::size_t N, class Y > inline void sp_deleter_construct( boost::shared_ptr< T[N] > * , Y * )
{
    sp_assert_convertible< Y[N], T[N] >();
}



struct sp_internal_constructor_tag
{
};

}
# 336 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
template<class T> class shared_ptr
{
private:


    typedef shared_ptr<T> this_type;

public:

    typedef typename boost::detail::sp_element< T >::type element_type;

    constexpr shared_ptr() noexcept : px( 0 ), pn()
    {
    }



    constexpr shared_ptr( boost::detail::sp_nullptr_t ) noexcept : px( 0 ), pn()
    {
    }



    constexpr shared_ptr( boost::detail::sp_internal_constructor_tag, element_type * px_, boost::detail::shared_count const & pn_ ) noexcept : px( px_ ), pn( pn_ )
    {
    }



    constexpr shared_ptr( boost::detail::sp_internal_constructor_tag, element_type * px_, boost::detail::shared_count && pn_ ) noexcept : px( px_ ), pn( std::move( pn_ ) )
    {
    }



    template<class Y>
    explicit shared_ptr( Y * p ): px( p ), pn()
    {
        boost::detail::sp_pointer_construct( this, p, pn );
    }
# 385 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
    template<class Y, class D> shared_ptr( Y * p, D d ): px( p ), pn( p, static_cast< D&& >( d ) )
    {
        boost::detail::sp_deleter_construct( this, p );
    }
# 403 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
    template<class D> shared_ptr( boost::detail::sp_nullptr_t p, D d ): px( p ), pn( p, static_cast< D&& >( d ) )
    {
    }
# 421 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
    template<class Y, class D, class A> shared_ptr( Y * p, D d, A a ): px( p ), pn( p, static_cast< D&& >( d ), a )
    {
        boost::detail::sp_deleter_construct( this, p );
    }
# 439 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
    template<class D, class A> shared_ptr( boost::detail::sp_nullptr_t p, D d, A a ): px( p ), pn( p, static_cast< D&& >( d ), a )
    {
    }
# 459 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
    shared_ptr( shared_ptr const & r ) noexcept : px( r.px ), pn( r.pn )
    {
    }



    template<class Y>
    explicit shared_ptr( weak_ptr<Y> const & r ): pn( r.pn )
    {
        boost::detail::sp_assert_convertible< Y, T >();


        px = r.px;
    }

    template<class Y>
    shared_ptr( weak_ptr<Y> const & r, boost::detail::sp_nothrow_tag )
    noexcept : px( 0 ), pn( r.pn, boost::detail::sp_nothrow_tag() )
    {
        if( !pn.empty() )
        {
            px = r.px;
        }
    }

    template<class Y>


    shared_ptr( shared_ptr<Y> const & r, typename boost::detail::sp_enable_if_convertible<Y,T>::type = boost::detail::sp_empty() )






    noexcept : px( r.px ), pn( r.pn )
    {
        boost::detail::sp_assert_convertible< Y, T >();
    }


    template< class Y >
    shared_ptr( shared_ptr<Y> const & r, element_type * p ) noexcept : px( p ), pn( r.pn )
    {
    }



    template<class Y>
    explicit shared_ptr( std::auto_ptr<Y> & r ): px(r.get()), pn()
    {
        boost::detail::sp_assert_convertible< Y, T >();

        Y * tmp = r.get();
        pn = boost::detail::shared_count( r );

        boost::detail::sp_deleter_construct( this, tmp );
    }



    template<class Y>
    shared_ptr( std::auto_ptr<Y> && r ): px(r.get()), pn()
    {
        boost::detail::sp_assert_convertible< Y, T >();

        Y * tmp = r.get();
        pn = boost::detail::shared_count( r );

        boost::detail::sp_deleter_construct( this, tmp );
    }
# 552 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
    template< class Y, class D >
    shared_ptr( std::unique_ptr< Y, D > && r ): px( r.get() ), pn()
    {
        boost::detail::sp_assert_convertible< Y, T >();

        typename std::unique_ptr< Y, D >::pointer tmp = r.get();

        if( tmp != 0 )
        {
            pn = boost::detail::shared_count( r );
            boost::detail::sp_deleter_construct( this, tmp );
        }
    }



    template< class Y, class D >
    shared_ptr( boost::movelib::unique_ptr< Y, D > r ): px( r.get() ), pn()
    {
        boost::detail::sp_assert_convertible< Y, T >();

        typename boost::movelib::unique_ptr< Y, D >::pointer tmp = r.get();

        if( tmp != 0 )
        {
            pn = boost::detail::shared_count( r );
            boost::detail::sp_deleter_construct( this, tmp );
        }
    }



    shared_ptr & operator=( shared_ptr const & r ) noexcept
    {
        this_type(r).swap(*this);
        return *this;
    }



    template<class Y>
    shared_ptr & operator=(shared_ptr<Y> const & r) noexcept
    {
        this_type(r).swap(*this);
        return *this;
    }





    template<class Y>
    shared_ptr & operator=( std::auto_ptr<Y> & r )
    {
        this_type( r ).swap( *this );
        return *this;
    }



    template<class Y>
    shared_ptr & operator=( std::auto_ptr<Y> && r )
    {
        this_type( static_cast< std::auto_ptr<Y> && >( r ) ).swap( *this );
        return *this;
    }
# 634 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
    template<class Y, class D>
    shared_ptr & operator=( std::unique_ptr<Y, D> && r )
    {
        this_type( static_cast< std::unique_ptr<Y, D> && >( r ) ).swap(*this);
        return *this;
    }



    template<class Y, class D>
    shared_ptr & operator=( boost::movelib::unique_ptr<Y, D> r )
    {


        boost::detail::sp_assert_convertible< Y, T >();

        typename boost::movelib::unique_ptr< Y, D >::pointer p = r.get();

        shared_ptr tmp;

        if( p != 0 )
        {
            tmp.px = p;
            tmp.pn = boost::detail::shared_count( r );

            boost::detail::sp_deleter_construct( &tmp, p );
        }

        tmp.swap( *this );

        return *this;
    }





    shared_ptr( shared_ptr && r ) noexcept : px( r.px ), pn( static_cast< boost::detail::shared_count && >( r.pn ) )
    {
        r.px = 0;
    }

    template<class Y>


    shared_ptr( shared_ptr<Y> && r, typename boost::detail::sp_enable_if_convertible<Y,T>::type = boost::detail::sp_empty() )






    noexcept : px( r.px ), pn( static_cast< boost::detail::shared_count && >( r.pn ) )
    {
        boost::detail::sp_assert_convertible< Y, T >();
        r.px = 0;
    }

    shared_ptr & operator=( shared_ptr && r ) noexcept
    {
        this_type( static_cast< shared_ptr && >( r ) ).swap( *this );
        return *this;
    }

    template<class Y>
    shared_ptr & operator=( shared_ptr<Y> && r ) noexcept
    {
        this_type( static_cast< shared_ptr<Y> && >( r ) ).swap( *this );
        return *this;
    }


    template<class Y>
    shared_ptr( shared_ptr<Y> && r, element_type * p ) noexcept : px( p ), pn()
    {
        pn.swap( r.pn );
        r.px = 0;
    }





    shared_ptr & operator=( boost::detail::sp_nullptr_t ) noexcept
    {
        this_type().swap(*this);
        return *this;
    }



    void reset() noexcept
    {
        this_type().swap(*this);
    }

    template<class Y> void reset( Y * p )
    {
        (static_cast <bool> (p == 0 || p != px) ? void (0) : __assert_fail ("p == 0 || p != px", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        this_type( p ).swap( *this );
    }



    template<class Y, class D> void reset( Y * p, D d )
    {
        this_type( p, static_cast< D&& >( d ) ).swap( *this );
    }

    template<class Y, class D, class A> void reset( Y * p, D d, A a )
    {
        this_type( p, static_cast< D&& >( d ), a ).swap( *this );
    }
# 762 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
    template<class Y> void reset( shared_ptr<Y> const & r, element_type * p ) noexcept
    {
        this_type( r, p ).swap( *this );
    }



    template<class Y> void reset( shared_ptr<Y> && r, element_type * p ) noexcept
    {
        this_type( static_cast< shared_ptr<Y> && >( r ), p ).swap( *this );
    }



    typename boost::detail::sp_dereference< T >::type operator* () const noexcept
    {
        (static_cast <bool> (px != 0) ? void (0) : __assert_fail ("px != 0", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        return *px;
    }

    typename boost::detail::sp_member_access< T >::type operator-> () const noexcept
    {
        (static_cast <bool> (px != 0) ? void (0) : __assert_fail ("px != 0", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        return px;
    }

    typename boost::detail::sp_array_access< T >::type operator[] ( std::ptrdiff_t i ) const noexcept
    {
        (static_cast <bool> (px != 0) ? void (0) : __assert_fail ("px != 0", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        (static_cast <bool> (i >= 0 && ( i < boost::detail::sp_extent< T >::value || boost::detail::sp_extent< T >::value == 0 )) ? void (0) : __assert_fail ("i >= 0 && ( i < boost::detail::sp_extent< T >::value || boost::detail::sp_extent< T >::value == 0 )", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));

        return static_cast< typename boost::detail::sp_array_access< T >::type >( px[ i ] );
    }

    element_type * get() const noexcept
    {
        return px;
    }


# 1 "/usr/include/boost/smart_ptr/detail/operator_bool.hpp" 1 3 4
# 12 "/usr/include/boost/smart_ptr/detail/operator_bool.hpp" 3 4
    explicit operator bool () const noexcept
    {
        return px != 0;
    }
# 61 "/usr/include/boost/smart_ptr/detail/operator_bool.hpp" 3 4
    bool operator! () const noexcept
    {
        return px == 0;
    }
# 803 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4

    bool unique() const noexcept
    {
        return pn.unique();
    }

    long use_count() const noexcept
    {
        return pn.use_count();
    }

    void swap( shared_ptr & other ) noexcept
    {
        std::swap(px, other.px);
        pn.swap(other.pn);
    }

    template<class Y> bool owner_before( shared_ptr<Y> const & rhs ) const noexcept
    {
        return pn < rhs.pn;
    }

    template<class Y> bool owner_before( weak_ptr<Y> const & rhs ) const noexcept
    {
        return pn < rhs.pn;
    }

    template<class Y> bool owner_equals( shared_ptr<Y> const & rhs ) const noexcept
    {
        return pn == rhs.pn;
    }

    template<class Y> bool owner_equals( weak_ptr<Y> const & rhs ) const noexcept
    {
        return pn == rhs.pn;
    }

    std::size_t owner_hash_value() const noexcept
    {
        return pn.hash_value();
    }

    void * _internal_get_deleter( boost::detail::sp_typeinfo_ const & ti ) const noexcept
    {
        return pn.get_deleter( ti );
    }

    void * _internal_get_local_deleter( boost::detail::sp_typeinfo_ const & ti ) const noexcept
    {
        return pn.get_local_deleter( ti );
    }

    void * _internal_get_untyped_deleter() const noexcept
    {
        return pn.get_untyped_deleter();
    }

    bool _internal_equiv( shared_ptr const & r ) const noexcept
    {
        return px == r.px && pn == r.pn;
    }

    boost::detail::shared_count _internal_count() const noexcept
    {
        return pn;
    }






private:

    template<class Y> friend class shared_ptr;
    template<class Y> friend class weak_ptr;




    element_type * px;
    boost::detail::shared_count pn;

};

template<class T, class U> inline bool operator==(shared_ptr<T> const & a, shared_ptr<U> const & b) noexcept
{
    return a.get() == b.get();
}

template<class T, class U> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<U> const & b) noexcept
{
    return a.get() != b.get();
}
# 911 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
template<class T> inline bool operator==( shared_ptr<T> const & p, boost::detail::sp_nullptr_t ) noexcept
{
    return p.get() == 0;
}

template<class T> inline bool operator==( boost::detail::sp_nullptr_t, shared_ptr<T> const & p ) noexcept
{
    return p.get() == 0;
}

template<class T> inline bool operator!=( shared_ptr<T> const & p, boost::detail::sp_nullptr_t ) noexcept
{
    return p.get() != 0;
}

template<class T> inline bool operator!=( boost::detail::sp_nullptr_t, shared_ptr<T> const & p ) noexcept
{
    return p.get() != 0;
}



template<class T, class U> inline bool operator<(shared_ptr<T> const & a, shared_ptr<U> const & b) noexcept
{
    return a.owner_before( b );
}

template<class T> inline void swap(shared_ptr<T> & a, shared_ptr<T> & b) noexcept
{
    a.swap(b);
}

template<class T, class U> shared_ptr<T> static_pointer_cast( shared_ptr<U> const & r ) noexcept
{
    (void) static_cast< T* >( static_cast< U* >( 0 ) );

    typedef typename shared_ptr<T>::element_type E;

    E * p = static_cast< E* >( r.get() );
    return shared_ptr<T>( r, p );
}

template<class T, class U> shared_ptr<T> const_pointer_cast( shared_ptr<U> const & r ) noexcept
{
    (void) const_cast< T* >( static_cast< U* >( 0 ) );

    typedef typename shared_ptr<T>::element_type E;

    E * p = const_cast< E* >( r.get() );
    return shared_ptr<T>( r, p );
}

template<class T, class U> shared_ptr<T> dynamic_pointer_cast( shared_ptr<U> const & r ) noexcept
{
    (void) dynamic_cast< T* >( static_cast< U* >( 0 ) );

    typedef typename shared_ptr<T>::element_type E;

    E * p = dynamic_cast< E* >( r.get() );
    return p? shared_ptr<T>( r, p ): shared_ptr<T>();
}

template<class T, class U> shared_ptr<T> reinterpret_pointer_cast( shared_ptr<U> const & r ) noexcept
{
    (void) reinterpret_cast< T* >( static_cast< U* >( 0 ) );

    typedef typename shared_ptr<T>::element_type E;

    E * p = reinterpret_cast< E* >( r.get() );
    return shared_ptr<T>( r, p );
}



template<class T, class U> shared_ptr<T> static_pointer_cast( shared_ptr<U> && r ) noexcept
{
    (void) static_cast< T* >( static_cast< U* >( 0 ) );

    typedef typename shared_ptr<T>::element_type E;

    E * p = static_cast< E* >( r.get() );
    return shared_ptr<T>( std::move(r), p );
}

template<class T, class U> shared_ptr<T> const_pointer_cast( shared_ptr<U> && r ) noexcept
{
    (void) const_cast< T* >( static_cast< U* >( 0 ) );

    typedef typename shared_ptr<T>::element_type E;

    E * p = const_cast< E* >( r.get() );
    return shared_ptr<T>( std::move(r), p );
}

template<class T, class U> shared_ptr<T> dynamic_pointer_cast( shared_ptr<U> && r ) noexcept
{
    (void) dynamic_cast< T* >( static_cast< U* >( 0 ) );

    typedef typename shared_ptr<T>::element_type E;

    E * p = dynamic_cast< E* >( r.get() );
    return p? shared_ptr<T>( std::move(r), p ): shared_ptr<T>();
}

template<class T, class U> shared_ptr<T> reinterpret_pointer_cast( shared_ptr<U> && r ) noexcept
{
    (void) reinterpret_cast< T* >( static_cast< U* >( 0 ) );

    typedef typename shared_ptr<T>::element_type E;

    E * p = reinterpret_cast< E* >( r.get() );
    return shared_ptr<T>( std::move(r), p );
}





template<class T> inline typename shared_ptr<T>::element_type * get_pointer(shared_ptr<T> const & p) noexcept
{
    return p.get();
}
# 1056 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
template<class E, class T, class Y> std::basic_ostream<E, T> & operator<< (std::basic_ostream<E, T> & os, shared_ptr<Y> const & p)

{
    os << p.get();
    return os;
}
# 1071 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 3 4
namespace detail
{

template<class D, class T> D * basic_get_deleter( shared_ptr<T> const & p ) noexcept
{
    return static_cast<D *>( p._internal_get_deleter(typeid(D)) );
}

template<class D, class T> D * basic_get_local_deleter( D *, shared_ptr<T> const & p ) noexcept;
template<class D, class T> D const * basic_get_local_deleter( D const *, shared_ptr<T> const & p ) noexcept;

class esft2_deleter_wrapper
{
private:

    shared_ptr<void const volatile> deleter_;

public:

    esft2_deleter_wrapper() noexcept
    {
    }

    template< class T > void set_deleter( shared_ptr<T> const & deleter ) noexcept
    {
        deleter_ = deleter;
    }

    template<typename D> D* get_deleter() const noexcept
    {
        return boost::detail::basic_get_deleter<D>( deleter_ );
    }

    template< class T> void operator()( T* ) noexcept
    {
        (static_cast <bool> (deleter_.use_count() <= 1) ? void (0) : __assert_fail ("deleter_.use_count() <= 1", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        deleter_.reset();
    }
};

}

template<class D, class T> D * get_deleter( shared_ptr<T> const & p ) noexcept
{
    D * d = boost::detail::basic_get_deleter<D>( p );

    if( d == 0 )
    {
        d = boost::detail::basic_get_local_deleter( d, p );
    }

    if( d == 0 )
    {
        boost::detail::esft2_deleter_wrapper *del_wrapper = boost::detail::basic_get_deleter<boost::detail::esft2_deleter_wrapper>(p);


        if(del_wrapper) d = del_wrapper->::boost::detail::esft2_deleter_wrapper::get_deleter<D>();
    }

    return d;
}





template<class T> inline bool atomic_is_lock_free( shared_ptr<T> const * ) noexcept
{
    return false;
}

template<class T> shared_ptr<T> atomic_load( shared_ptr<T> const * p ) noexcept
{
    boost::detail::spinlock_pool<2>::scoped_lock lock( p );
    return *p;
}

template<class T, class M> inline shared_ptr<T> atomic_load_explicit( shared_ptr<T> const * p, M ) noexcept
{
    return atomic_load( p );
}

template<class T> void atomic_store( shared_ptr<T> * p, shared_ptr<T> r ) noexcept
{
    boost::detail::spinlock_pool<2>::scoped_lock lock( p );
    p->swap( r );
}

template<class T, class M> inline void atomic_store_explicit( shared_ptr<T> * p, shared_ptr<T> r, M ) noexcept
{
    atomic_store( p, r );
}

template<class T> shared_ptr<T> atomic_exchange( shared_ptr<T> * p, shared_ptr<T> r ) noexcept
{
    boost::detail::spinlock & sp = boost::detail::spinlock_pool<2>::spinlock_for( p );

    sp.lock();
    p->swap( r );
    sp.unlock();

    return r;
}

template<class T, class M> shared_ptr<T> inline atomic_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> r, M ) noexcept
{
    return atomic_exchange( p, r );
}

template<class T> bool atomic_compare_exchange( shared_ptr<T> * p, shared_ptr<T> * v, shared_ptr<T> w ) noexcept
{
    boost::detail::spinlock & sp = boost::detail::spinlock_pool<2>::spinlock_for( p );

    sp.lock();

    if( p->_internal_equiv( *v ) )
    {
        p->swap( w );

        sp.unlock();

        return true;
    }
    else
    {
        shared_ptr<T> tmp( *p );

        sp.unlock();

        tmp.swap( *v );
        return false;
    }
}

template<class T, class M> inline bool atomic_compare_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> * v, shared_ptr<T> w, M, M ) noexcept
{
    return atomic_compare_exchange( p, v, w );
}





template< class T > struct hash;

template< class T > std::size_t hash_value( boost::shared_ptr<T> const & p ) noexcept
{
    return boost::hash< typename boost::shared_ptr<T>::element_type* >()( p.get() );
}

}





namespace std
{

template<class T> struct hash< ::boost::shared_ptr<T> >
{
    std::size_t operator()( ::boost::shared_ptr<T> const & p ) const noexcept
    {
        return std::hash< typename ::boost::shared_ptr<T>::element_type* >()( p.get() );
    }
};

}



# 1 "/usr/include/boost/smart_ptr/detail/local_sp_deleter.hpp" 1 3 4
# 20 "/usr/include/boost/smart_ptr/detail/local_sp_deleter.hpp" 3 4
# 1 "/usr/include/boost/smart_ptr/detail/local_counted_base.hpp" 1 3 4
# 24 "/usr/include/boost/smart_ptr/detail/local_counted_base.hpp" 3 4
namespace boost
{

namespace detail
{

class __attribute__((__visibility__("default"))) local_counted_base
{
private:

    local_counted_base & operator= ( local_counted_base const & );

private:


    enum count_type { min_ = 0, initial_ = 1, max_ = 2147483647 };

    count_type local_use_count_;

public:

    constexpr local_counted_base() noexcept: local_use_count_( initial_ )
    {
    }

    constexpr local_counted_base( local_counted_base const & ) noexcept: local_use_count_( initial_ )
    {
    }

    virtual ~local_counted_base()
    {
    }

    virtual void local_cb_destroy() noexcept = 0;

    virtual boost::detail::shared_count local_cb_get_shared_count() const noexcept = 0;

    void add_ref() noexcept
    {




        __builtin_assume( local_use_count_ >= 1 );





        local_use_count_ = static_cast<count_type>( local_use_count_ + 1 );
    }

    void release() noexcept
    {
        local_use_count_ = static_cast<count_type>( local_use_count_ - 1 );

        if( local_use_count_ == 0 )
        {
            local_cb_destroy();
        }
    }

    long local_use_count() const noexcept
    {
        return local_use_count_;
    }
};

class __attribute__((__visibility__("default"))) local_counted_impl: public local_counted_base
{
private:

    local_counted_impl( local_counted_impl const & );

private:

    shared_count pn_;

public:

    explicit local_counted_impl( shared_count const& pn ) noexcept: pn_( pn )
    {
    }



    explicit local_counted_impl( shared_count && pn ) noexcept: pn_( std::move(pn) )
    {
    }



    void local_cb_destroy() noexcept override
    {
        delete this;
    }

    boost::detail::shared_count local_cb_get_shared_count() const noexcept override
    {
        return pn_;
    }
};

class __attribute__((__visibility__("default"))) local_counted_impl_em: public local_counted_base
{
public:

    shared_count pn_;

    void local_cb_destroy() noexcept override
    {
        shared_count().swap( pn_ );
    }

    boost::detail::shared_count local_cb_get_shared_count() const noexcept override
    {
        return pn_;
    }
};

}

}
# 21 "/usr/include/boost/smart_ptr/detail/local_sp_deleter.hpp" 2 3 4


namespace boost
{

namespace detail
{

template<class D> class local_sp_deleter: public local_counted_impl_em
{
private:

    D d_;

public:

    local_sp_deleter(): d_()
    {
    }

    explicit local_sp_deleter( D const& d ) noexcept: d_( d )
    {
    }



    explicit local_sp_deleter( D&& d ) noexcept: d_( std::move(d) )
    {
    }



    D& deleter() noexcept
    {
        return d_;
    }

    template<class Y> void operator()( Y* p ) noexcept
    {
        d_( p );
    }



    void operator()( boost::detail::sp_nullptr_t p ) noexcept
    {
        d_( p );
    }


};

template<> class local_sp_deleter<void>
{
};

template<class D> D * get_local_deleter( local_sp_deleter<D> * p ) noexcept
{
    return &p->deleter();
}

inline void * get_local_deleter( local_sp_deleter<void> * ) noexcept
{
    return 0;
}

}

}
# 1243 "/usr/include/boost/smart_ptr/shared_ptr.hpp" 2 3 4

namespace boost
{

namespace detail
{

template<class D, class T> D * basic_get_local_deleter( D *, shared_ptr<T> const & p ) noexcept
{
    return static_cast<D *>( p._internal_get_local_deleter( typeid(local_sp_deleter<D>) ) );
}

template<class D, class T> D const * basic_get_local_deleter( D const *, shared_ptr<T> const & p ) noexcept
{
    return static_cast<D *>( p._internal_get_local_deleter( typeid(local_sp_deleter<D>) ) );
}

}



template<class T> shared_ptr( weak_ptr<T> ) -> shared_ptr<T>;
template<class T, class D> shared_ptr( std::unique_ptr<T, D> ) -> shared_ptr<T>;



}


#pragma GCC diagnostic pop
# 18 "/usr/include/boost/shared_ptr.hpp" 2 3 4
# 18 "/usr/include/boost/date_time/time_clock.hpp" 2 3 4

namespace boost {
namespace date_time {





  template<class time_type>
  class second_clock
  {
  public:
    typedef typename time_type::date_type date_type;
    typedef typename time_type::time_duration_type time_duration_type;

    static time_type local_time()
    {
      ::std::time_t t;
      ::std::time(&t);
      ::std::tm curr, *curr_ptr;

      curr_ptr = c_time::localtime(&t, &curr);
      return create_time(curr_ptr);
    }



    static time_type universal_time()
    {

      ::std::time_t t;
      ::std::time(&t);
      ::std::tm curr, *curr_ptr;

      curr_ptr = c_time::gmtime(&t, &curr);
      return create_time(curr_ptr);
    }

    template<class time_zone_type>
    static time_type local_time(boost::shared_ptr<time_zone_type> tz_ptr)
    {
      typedef typename time_type::utc_time_type utc_time_type;
      utc_time_type utc_time = second_clock<utc_time_type>::universal_time();
      return time_type(utc_time, tz_ptr);
    }


  private:
    static time_type create_time(::std::tm* current)
    {
      date_type d(static_cast<unsigned short>(current->tm_year + 1900),
                  static_cast<unsigned short>(current->tm_mon + 1),
                  static_cast<unsigned short>(current->tm_mday));
      time_duration_type td(current->tm_hour,
                            current->tm_min,
                            current->tm_sec);
      return time_type(d,td);
    }

  };


} }
# 10 "/usr/include/boost/thread/thread_time.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/microsec_time_clock.hpp" 1 3 4
# 17 "/usr/include/boost/date_time/microsec_time_clock.hpp" 3 4
# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 18 "/usr/include/boost/date_time/microsec_time_clock.hpp" 2 3 4
# 29 "/usr/include/boost/date_time/microsec_time_clock.hpp" 3 4
namespace boost {
namespace date_time {
# 40 "/usr/include/boost/date_time/microsec_time_clock.hpp" 3 4
  template<class time_type>
  class microsec_clock
  {
  private:

    typedef std::tm* (*time_converter)(const std::time_t*, std::tm*);

  public:
    typedef typename time_type::date_type date_type;
    typedef typename time_type::time_duration_type time_duration_type;
    typedef typename time_duration_type::rep_type resolution_traits_type;



    template<class time_zone_type>
    static time_type local_time(shared_ptr<time_zone_type> tz_ptr)
    {
      typedef typename time_type::utc_time_type utc_time_type;
      typedef second_clock<utc_time_type> second_clock;


      utc_time_type utc_time = second_clock::universal_time();
      time_duration_type utc_offset = second_clock::local_time() - utc_time;


      utc_time = microsec_clock<utc_time_type>::local_time() - utc_offset;
      return time_type(utc_time, tz_ptr);
    }


    static time_type local_time()
    {
      return create_time(&c_time::localtime);
    }


    static time_type universal_time()
    {
      return create_time(&c_time::gmtime);
    }

  private:
    static time_type create_time(time_converter converter)
    {

      timeval tv;
      gettimeofday(&tv, 0);
      std::time_t t = tv.tv_sec;
      boost::uint32_t sub_sec = tv.tv_usec;
# 110 "/usr/include/boost/date_time/microsec_time_clock.hpp" 3 4
      std::tm curr;
      std::tm* curr_ptr = converter(&t, &curr);
      date_type d(static_cast< typename date_type::year_type::value_type >(curr_ptr->tm_year + 1900),
                  static_cast< typename date_type::month_type::value_type >(curr_ptr->tm_mon + 1),
                  static_cast< typename date_type::day_type::value_type >(curr_ptr->tm_mday));





      int adjust = static_cast< int >(resolution_traits_type::res_adjust() / 1000000);

      time_duration_type td(static_cast< typename time_duration_type::hour_type >(curr_ptr->tm_hour),
                            static_cast< typename time_duration_type::min_type >(curr_ptr->tm_min),
                            static_cast< typename time_duration_type::sec_type >(curr_ptr->tm_sec),
                            sub_sec * adjust);

      return time_type(d,td);
    }
# 149 "/usr/include/boost/date_time/microsec_time_clock.hpp" 3 4
  };


} }
# 11 "/usr/include/boost/thread/thread_time.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/posix_time/posix_time_types.hpp" 1 3 4
# 12 "/usr/include/boost/date_time/posix_time/posix_time_types.hpp" 3 4
# 1 "/usr/include/boost/date_time/posix_time/ptime.hpp" 1 3 4
# 12 "/usr/include/boost/date_time/posix_time/ptime.hpp" 3 4
# 1 "/usr/include/boost/date_time/posix_time/posix_time_system.hpp" 1 3 4
# 13 "/usr/include/boost/date_time/posix_time/posix_time_system.hpp" 3 4
# 1 "/usr/include/boost/date_time/posix_time/posix_time_config.hpp" 1 3 4
# 12 "/usr/include/boost/date_time/posix_time/posix_time_config.hpp" 3 4
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdlib" 1 3 4
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdlib" 3
# 13 "/usr/include/boost/date_time/posix_time/posix_time_config.hpp" 2 3 4
# 1 "/usr/include/boost/limits.hpp" 1 3 4
# 14 "/usr/include/boost/date_time/posix_time/posix_time_config.hpp" 2 3 4
# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 15 "/usr/include/boost/date_time/posix_time/posix_time_config.hpp" 2 3 4
# 1 "/usr/include/boost/config/no_tr1/cmath.hpp" 1 3 4
# 21 "/usr/include/boost/config/no_tr1/cmath.hpp" 3 4
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cmath" 1 3 4
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cmath" 3
# 22 "/usr/include/boost/config/no_tr1/cmath.hpp" 2 3 4
# 16 "/usr/include/boost/date_time/posix_time/posix_time_config.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/time_duration.hpp" 1 3 4
# 13 "/usr/include/boost/date_time/time_duration.hpp" 3 4
# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 14 "/usr/include/boost/date_time/time_duration.hpp" 2 3 4

# 1 "/usr/include/boost/date_time/special_defs.hpp" 1 3 4
# 12 "/usr/include/boost/date_time/special_defs.hpp" 3 4
namespace boost {
namespace date_time {

    enum special_values {not_a_date_time,
                         neg_infin, pos_infin,
                         min_date_time, max_date_time,
                         not_special, NumSpecialValues};


} }
# 16 "/usr/include/boost/date_time/time_duration.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/time_defs.hpp" 1 3 4
# 19 "/usr/include/boost/date_time/time_defs.hpp" 3 4
namespace boost {
namespace date_time {


  enum time_resolutions {
    sec,
    tenth,
    hundreth,
    hundredth = hundreth,
    milli,
    ten_thousandth,
    micro,
    nano,
    NumResolutions
  };


  enum dst_flags {not_dst, is_dst, calculate};


} }
# 17 "/usr/include/boost/date_time/time_duration.hpp" 2 3 4
# 1 "/usr/include/boost/operators.hpp" 1 3 4
# 125 "/usr/include/boost/operators.hpp" 3 4
namespace boost
{
namespace operators_impl
{
namespace operators_detail
{

template <typename T> class empty_base {};

}






template <class T, class U, class B = operators_detail::empty_base<T> >
struct less_than_comparable2 : B
{
     friend constexpr bool operator<=(const T& x, const U& y) { return !static_cast<bool>(x > y); }
     friend constexpr bool operator>=(const T& x, const U& y) { return !static_cast<bool>(x < y); }
     friend constexpr bool operator>(const U& x, const T& y) { return y < x; }
     friend constexpr bool operator<(const U& x, const T& y) { return y > x; }
     friend constexpr bool operator<=(const U& x, const T& y) { return !static_cast<bool>(y < x); }
     friend constexpr bool operator>=(const U& x, const T& y) { return !static_cast<bool>(y > x); }
};

template <class T, class B = operators_detail::empty_base<T> >
struct less_than_comparable1 : B
{
     friend constexpr bool operator>(const T& x, const T& y) { return y < x; }
     friend constexpr bool operator<=(const T& x, const T& y) { return !static_cast<bool>(y < x); }
     friend constexpr bool operator>=(const T& x, const T& y) { return !static_cast<bool>(x < y); }
};

template <class T, class U, class B = operators_detail::empty_base<T> >
struct equality_comparable2 : B
{
     friend constexpr bool operator==(const U& y, const T& x) { return x == y; }
     friend constexpr bool operator!=(const U& y, const T& x) { return !static_cast<bool>(x == y); }
     friend constexpr bool operator!=(const T& y, const U& x) { return !static_cast<bool>(y == x); }
};

template <class T, class B = operators_detail::empty_base<T> >
struct equality_comparable1 : B
{
     friend constexpr bool operator!=(const T& x, const T& y) { return !static_cast<bool>(x == y); }
};
# 268 "/usr/include/boost/operators.hpp" 3 4
template <class T, class U, class B = operators_detail::empty_base<T> > struct multipliable2 : B { friend T operator *( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv *= rhs; return nrv; } friend T operator *( const U& lhs, const T& rhs ) { T nrv( rhs ); nrv *= lhs; return nrv; } }; template <class T, class B = operators_detail::empty_base<T> > struct multipliable1 : B { friend T operator *( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv *= rhs; return nrv; } };
template <class T, class U, class B = operators_detail::empty_base<T> > struct addable2 : B { friend T operator +( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv += rhs; return nrv; } friend T operator +( const U& lhs, const T& rhs ) { T nrv( rhs ); nrv += lhs; return nrv; } }; template <class T, class B = operators_detail::empty_base<T> > struct addable1 : B { friend T operator +( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv += rhs; return nrv; } };
template <class T, class U, class B = operators_detail::empty_base<T> > struct subtractable2 : B { friend T operator -( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv -= rhs; return nrv; } }; template <class T, class U, class B = operators_detail::empty_base<T> > struct subtractable2_left : B { friend T operator -( const U& lhs, const T& rhs ) { T nrv( lhs ); nrv -= rhs; return nrv; } }; template <class T, class B = operators_detail::empty_base<T> > struct subtractable1 : B { friend T operator -( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv -= rhs; return nrv; } };
template <class T, class U, class B = operators_detail::empty_base<T> > struct dividable2 : B { friend T operator /( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv /= rhs; return nrv; } }; template <class T, class U, class B = operators_detail::empty_base<T> > struct dividable2_left : B { friend T operator /( const U& lhs, const T& rhs ) { T nrv( lhs ); nrv /= rhs; return nrv; } }; template <class T, class B = operators_detail::empty_base<T> > struct dividable1 : B { friend T operator /( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv /= rhs; return nrv; } };
template <class T, class U, class B = operators_detail::empty_base<T> > struct modable2 : B { friend T operator %( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv %= rhs; return nrv; } }; template <class T, class U, class B = operators_detail::empty_base<T> > struct modable2_left : B { friend T operator %( const U& lhs, const T& rhs ) { T nrv( lhs ); nrv %= rhs; return nrv; } }; template <class T, class B = operators_detail::empty_base<T> > struct modable1 : B { friend T operator %( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv %= rhs; return nrv; } };
template <class T, class U, class B = operators_detail::empty_base<T> > struct xorable2 : B { friend T operator ^( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv ^= rhs; return nrv; } friend T operator ^( const U& lhs, const T& rhs ) { T nrv( rhs ); nrv ^= lhs; return nrv; } }; template <class T, class B = operators_detail::empty_base<T> > struct xorable1 : B { friend T operator ^( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv ^= rhs; return nrv; } };
template <class T, class U, class B = operators_detail::empty_base<T> > struct andable2 : B { friend T operator &( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv &= rhs; return nrv; } friend T operator &( const U& lhs, const T& rhs ) { T nrv( rhs ); nrv &= lhs; return nrv; } }; template <class T, class B = operators_detail::empty_base<T> > struct andable1 : B { friend T operator &( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv &= rhs; return nrv; } };
template <class T, class U, class B = operators_detail::empty_base<T> > struct orable2 : B { friend T operator |( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv |= rhs; return nrv; } friend T operator |( const U& lhs, const T& rhs ) { T nrv( rhs ); nrv |= lhs; return nrv; } }; template <class T, class B = operators_detail::empty_base<T> > struct orable1 : B { friend T operator |( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv |= rhs; return nrv; } };







template <class T, class B = operators_detail::empty_base<T> >
struct incrementable : B
{
  friend T operator++(T& x, int)
  {
    incrementable_type nrv(x);
    ++x;
    return nrv;
  }
private:
  typedef T incrementable_type;
};

template <class T, class B = operators_detail::empty_base<T> >
struct decrementable : B
{
  friend T operator--(T& x, int)
  {
    decrementable_type nrv(x);
    --x;
    return nrv;
  }
private:
  typedef T decrementable_type;
};



template <class T, class P, class B = operators_detail::empty_base<T> >
struct dereferenceable : B
{
  P operator->() const
  {
    return ::boost::addressof(*static_cast<const T&>(*this));
  }
};

template <class T, class I, class R, class B = operators_detail::empty_base<T> >
struct indexable : B
{
  R operator[](I n) const
  {
    return *(static_cast<const T&>(*this) + n);
  }
};
# 366 "/usr/include/boost/operators.hpp" 3 4
template <class T, class U, class B = operators_detail::empty_base<T> > struct left_shiftable2 : B { friend T operator <<( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv <<= rhs; return nrv; } }; template <class T, class B = operators_detail::empty_base<T> > struct left_shiftable1 : B { friend T operator <<( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv <<= rhs; return nrv; } };
template <class T, class U, class B = operators_detail::empty_base<T> > struct right_shiftable2 : B { friend T operator >>( const T& lhs, const U& rhs ) { T nrv( lhs ); nrv >>= rhs; return nrv; } }; template <class T, class B = operators_detail::empty_base<T> > struct right_shiftable1 : B { friend T operator >>( const T& lhs, const T& rhs ) { T nrv( lhs ); nrv >>= rhs; return nrv; } };



template <class T, class U, class B = operators_detail::empty_base<T> >
struct equivalent2 : B
{
  friend constexpr bool operator==(const T& x, const U& y)
  {
    return !static_cast<bool>(x < y) && !static_cast<bool>(x > y);
  }
};

template <class T, class B = operators_detail::empty_base<T> >
struct equivalent1 : B
{
  friend constexpr bool operator==(const T&x, const T&y)
  {
    return !static_cast<bool>(x < y) && !static_cast<bool>(y < x);
  }
};

template <class T, class U, class B = operators_detail::empty_base<T> >
struct partially_ordered2 : B
{
  friend constexpr bool operator<=(const T& x, const U& y)
    { return static_cast<bool>(x < y) || static_cast<bool>(x == y); }
  friend constexpr bool operator>=(const T& x, const U& y)
    { return static_cast<bool>(x > y) || static_cast<bool>(x == y); }
  friend constexpr bool operator>(const U& x, const T& y)
    { return y < x; }
  friend constexpr bool operator<(const U& x, const T& y)
    { return y > x; }
  friend constexpr bool operator<=(const U& x, const T& y)
    { return static_cast<bool>(y > x) || static_cast<bool>(y == x); }
  friend constexpr bool operator>=(const U& x, const T& y)
    { return static_cast<bool>(y < x) || static_cast<bool>(y == x); }
};

template <class T, class B = operators_detail::empty_base<T> >
struct partially_ordered1 : B
{
  friend constexpr bool operator>(const T& x, const T& y)
    { return y < x; }
  friend constexpr bool operator<=(const T& x, const T& y)
    { return static_cast<bool>(x < y) || static_cast<bool>(x == y); }
  friend constexpr bool operator>=(const T& x, const T& y)
    { return static_cast<bool>(y < x) || static_cast<bool>(x == y); }
};



template <class T, class U, class B = operators_detail::empty_base<T> >
struct totally_ordered2
    : less_than_comparable2<T, U
    , equality_comparable2<T, U, B
      > > {};

template <class T, class B = operators_detail::empty_base<T> >
struct totally_ordered1
    : less_than_comparable1<T
    , equality_comparable1<T, B
      > > {};

template <class T, class U, class B = operators_detail::empty_base<T> >
struct additive2
    : addable2<T, U
    , subtractable2<T, U, B
      > > {};

template <class T, class B = operators_detail::empty_base<T> >
struct additive1
    : addable1<T
    , subtractable1<T, B
      > > {};

template <class T, class U, class B = operators_detail::empty_base<T> >
struct multiplicative2
    : multipliable2<T, U
    , dividable2<T, U, B
      > > {};

template <class T, class B = operators_detail::empty_base<T> >
struct multiplicative1
    : multipliable1<T
    , dividable1<T, B
      > > {};

template <class T, class U, class B = operators_detail::empty_base<T> >
struct integer_multiplicative2
    : multiplicative2<T, U
    , modable2<T, U, B
      > > {};

template <class T, class B = operators_detail::empty_base<T> >
struct integer_multiplicative1
    : multiplicative1<T
    , modable1<T, B
      > > {};

template <class T, class U, class B = operators_detail::empty_base<T> >
struct arithmetic2
    : additive2<T, U
    , multiplicative2<T, U, B
      > > {};

template <class T, class B = operators_detail::empty_base<T> >
struct arithmetic1
    : additive1<T
    , multiplicative1<T, B
      > > {};

template <class T, class U, class B = operators_detail::empty_base<T> >
struct integer_arithmetic2
    : additive2<T, U
    , integer_multiplicative2<T, U, B
      > > {};

template <class T, class B = operators_detail::empty_base<T> >
struct integer_arithmetic1
    : additive1<T
    , integer_multiplicative1<T, B
      > > {};

template <class T, class U, class B = operators_detail::empty_base<T> >
struct bitwise2
    : xorable2<T, U
    , andable2<T, U
    , orable2<T, U, B
      > > > {};

template <class T, class B = operators_detail::empty_base<T> >
struct bitwise1
    : xorable1<T
    , andable1<T
    , orable1<T, B
      > > > {};

template <class T, class B = operators_detail::empty_base<T> >
struct unit_steppable
    : incrementable<T
    , decrementable<T, B
      > > {};

template <class T, class U, class B = operators_detail::empty_base<T> >
struct shiftable2
    : left_shiftable2<T, U
    , right_shiftable2<T, U, B
      > > {};

template <class T, class B = operators_detail::empty_base<T> >
struct shiftable1
    : left_shiftable1<T
    , right_shiftable1<T, B
      > > {};

template <class T, class U, class B = operators_detail::empty_base<T> >
struct ring_operators2
    : additive2<T, U
    , subtractable2_left<T, U
    , multipliable2<T, U, B
      > > > {};

template <class T, class B = operators_detail::empty_base<T> >
struct ring_operators1
    : additive1<T
    , multipliable1<T, B
      > > {};

template <class T, class U, class B = operators_detail::empty_base<T> >
struct ordered_ring_operators2
    : ring_operators2<T, U
    , totally_ordered2<T, U, B
      > > {};

template <class T, class B = operators_detail::empty_base<T> >
struct ordered_ring_operators1
    : ring_operators1<T
    , totally_ordered1<T, B
      > > {};

template <class T, class U, class B = operators_detail::empty_base<T> >
struct field_operators2
    : ring_operators2<T, U
    , dividable2<T, U
    , dividable2_left<T, U, B
      > > > {};

template <class T, class B = operators_detail::empty_base<T> >
struct field_operators1
    : ring_operators1<T
    , dividable1<T, B
      > > {};

template <class T, class U, class B = operators_detail::empty_base<T> >
struct ordered_field_operators2
    : field_operators2<T, U
    , totally_ordered2<T, U, B
      > > {};

template <class T, class B = operators_detail::empty_base<T> >
struct ordered_field_operators1
    : field_operators1<T
    , totally_ordered1<T, B
      > > {};

template <class T, class U, class B = operators_detail::empty_base<T> >
struct euclidian_ring_operators2
    : ring_operators2<T, U
    , dividable2<T, U
    , dividable2_left<T, U
    , modable2<T, U
    , modable2_left<T, U, B
      > > > > > {};

template <class T, class B = operators_detail::empty_base<T> >
struct euclidian_ring_operators1
    : ring_operators1<T
    , dividable1<T
    , modable1<T, B
      > > > {};

template <class T, class U, class B = operators_detail::empty_base<T> >
struct ordered_euclidian_ring_operators2
    : totally_ordered2<T, U
    , euclidian_ring_operators2<T, U, B
      > > {};

template <class T, class B = operators_detail::empty_base<T> >
struct ordered_euclidian_ring_operators1
    : totally_ordered1<T
    , euclidian_ring_operators1<T, B
      > > {};

template <class T, class U, class B = operators_detail::empty_base<T> >
struct euclidean_ring_operators2
    : ring_operators2<T, U
    , dividable2<T, U
    , dividable2_left<T, U
    , modable2<T, U
    , modable2_left<T, U, B
      > > > > > {};

template <class T, class B = operators_detail::empty_base<T> >
struct euclidean_ring_operators1
    : ring_operators1<T
    , dividable1<T
    , modable1<T, B
      > > > {};

template <class T, class U, class B = operators_detail::empty_base<T> >
struct ordered_euclidean_ring_operators2
    : totally_ordered2<T, U
    , euclidean_ring_operators2<T, U, B
      > > {};

template <class T, class B = operators_detail::empty_base<T> >
struct ordered_euclidean_ring_operators1
    : totally_ordered1<T
    , euclidean_ring_operators1<T, B
      > > {};

template <class T, class P, class B = operators_detail::empty_base<T> >
struct input_iteratable
    : equality_comparable1<T
    , incrementable<T
    , dereferenceable<T, P, B
      > > > {};

template <class T, class B = operators_detail::empty_base<T> >
struct output_iteratable
    : incrementable<T, B
      > {};

template <class T, class P, class B = operators_detail::empty_base<T> >
struct forward_iteratable
    : input_iteratable<T, P, B
      > {};

template <class T, class P, class B = operators_detail::empty_base<T> >
struct bidirectional_iteratable
    : forward_iteratable<T, P
    , decrementable<T, B
      > > {};





template <class T, class P, class D, class R, class B = operators_detail::empty_base<T> >
struct random_access_iteratable
    : bidirectional_iteratable<T, P
    , less_than_comparable1<T
    , additive2<T, D
    , indexable<T, D, R, B
      > > > > {};
# 671 "/usr/include/boost/operators.hpp" 3 4
namespace operators_detail
{



struct true_t {};
struct false_t {};

}
# 688 "/usr/include/boost/operators.hpp" 3 4
template<class T> struct is_chained_base {
  typedef operators_detail::false_t value;
};
# 766 "/usr/include/boost/operators.hpp" 3 4
template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct less_than_comparable; template<class T, class U, class B> struct less_than_comparable<T, U, B, operators_detail::false_t> : less_than_comparable2<T, U, B> {}; template<class T, class U> struct less_than_comparable<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : less_than_comparable1<T, U> {}; template <class T, class B> struct less_than_comparable<T, T, B, operators_detail::false_t> : less_than_comparable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< less_than_comparable<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< less_than_comparable2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< less_than_comparable1<T, B> > { typedef operators_detail::true_t value; };
template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct equality_comparable; template<class T, class U, class B> struct equality_comparable<T, U, B, operators_detail::false_t> : equality_comparable2<T, U, B> {}; template<class T, class U> struct equality_comparable<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : equality_comparable1<T, U> {}; template <class T, class B> struct equality_comparable<T, T, B, operators_detail::false_t> : equality_comparable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< equality_comparable<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< equality_comparable2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< equality_comparable1<T, B> > { typedef operators_detail::true_t value; };
template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct multipliable; template<class T, class U, class B> struct multipliable<T, U, B, operators_detail::false_t> : multipliable2<T, U, B> {}; template<class T, class U> struct multipliable<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : multipliable1<T, U> {}; template <class T, class B> struct multipliable<T, T, B, operators_detail::false_t> : multipliable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< multipliable<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< multipliable2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< multipliable1<T, B> > { typedef operators_detail::true_t value; };
template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct addable; template<class T, class U, class B> struct addable<T, U, B, operators_detail::false_t> : addable2<T, U, B> {}; template<class T, class U> struct addable<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : addable1<T, U> {}; template <class T, class B> struct addable<T, T, B, operators_detail::false_t> : addable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< addable<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< addable2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< addable1<T, B> > { typedef operators_detail::true_t value; };
template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct subtractable; template<class T, class U, class B> struct subtractable<T, U, B, operators_detail::false_t> : subtractable2<T, U, B> {}; template<class T, class U> struct subtractable<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : subtractable1<T, U> {}; template <class T, class B> struct subtractable<T, T, B, operators_detail::false_t> : subtractable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< subtractable<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< subtractable2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< subtractable1<T, B> > { typedef operators_detail::true_t value; };
template<class T, class U, class B> struct is_chained_base< subtractable2_left<T, U, B> > { typedef operators_detail::true_t value; };
template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct dividable; template<class T, class U, class B> struct dividable<T, U, B, operators_detail::false_t> : dividable2<T, U, B> {}; template<class T, class U> struct dividable<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : dividable1<T, U> {}; template <class T, class B> struct dividable<T, T, B, operators_detail::false_t> : dividable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< dividable<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< dividable2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< dividable1<T, B> > { typedef operators_detail::true_t value; };
template<class T, class U, class B> struct is_chained_base< dividable2_left<T, U, B> > { typedef operators_detail::true_t value; };
template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct modable; template<class T, class U, class B> struct modable<T, U, B, operators_detail::false_t> : modable2<T, U, B> {}; template<class T, class U> struct modable<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : modable1<T, U> {}; template <class T, class B> struct modable<T, T, B, operators_detail::false_t> : modable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< modable<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< modable2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< modable1<T, B> > { typedef operators_detail::true_t value; };
template<class T, class U, class B> struct is_chained_base< modable2_left<T, U, B> > { typedef operators_detail::true_t value; };
template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct xorable; template<class T, class U, class B> struct xorable<T, U, B, operators_detail::false_t> : xorable2<T, U, B> {}; template<class T, class U> struct xorable<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : xorable1<T, U> {}; template <class T, class B> struct xorable<T, T, B, operators_detail::false_t> : xorable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< xorable<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< xorable2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< xorable1<T, B> > { typedef operators_detail::true_t value; };
template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct andable; template<class T, class U, class B> struct andable<T, U, B, operators_detail::false_t> : andable2<T, U, B> {}; template<class T, class U> struct andable<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : andable1<T, U> {}; template <class T, class B> struct andable<T, T, B, operators_detail::false_t> : andable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< andable<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< andable2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< andable1<T, B> > { typedef operators_detail::true_t value; };
template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct orable; template<class T, class U, class B> struct orable<T, U, B, operators_detail::false_t> : orable2<T, U, B> {}; template<class T, class U> struct orable<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : orable1<T, U> {}; template <class T, class B> struct orable<T, T, B, operators_detail::false_t> : orable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< orable<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< orable2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< orable1<T, B> > { typedef operators_detail::true_t value; };

template<class T, class B> struct is_chained_base< incrementable<T, B> > { typedef operators_detail::true_t value; };
template<class T, class B> struct is_chained_base< decrementable<T, B> > { typedef operators_detail::true_t value; };

template<class T, class U, class B> struct is_chained_base< dereferenceable<T, U, B> > { typedef operators_detail::true_t value; };
template<class T, class U, class V, class B> struct is_chained_base< indexable<T, U, V, B> > { typedef operators_detail::true_t value; };

template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct left_shiftable; template<class T, class U, class B> struct left_shiftable<T, U, B, operators_detail::false_t> : left_shiftable2<T, U, B> {}; template<class T, class U> struct left_shiftable<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : left_shiftable1<T, U> {}; template <class T, class B> struct left_shiftable<T, T, B, operators_detail::false_t> : left_shiftable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< left_shiftable<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< left_shiftable2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< left_shiftable1<T, B> > { typedef operators_detail::true_t value; };
template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct right_shiftable; template<class T, class U, class B> struct right_shiftable<T, U, B, operators_detail::false_t> : right_shiftable2<T, U, B> {}; template<class T, class U> struct right_shiftable<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : right_shiftable1<T, U> {}; template <class T, class B> struct right_shiftable<T, T, B, operators_detail::false_t> : right_shiftable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< right_shiftable<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< right_shiftable2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< right_shiftable1<T, B> > { typedef operators_detail::true_t value; };
template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct equivalent; template<class T, class U, class B> struct equivalent<T, U, B, operators_detail::false_t> : equivalent2<T, U, B> {}; template<class T, class U> struct equivalent<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : equivalent1<T, U> {}; template <class T, class B> struct equivalent<T, T, B, operators_detail::false_t> : equivalent1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< equivalent<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< equivalent2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< equivalent1<T, B> > { typedef operators_detail::true_t value; };
template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct partially_ordered; template<class T, class U, class B> struct partially_ordered<T, U, B, operators_detail::false_t> : partially_ordered2<T, U, B> {}; template<class T, class U> struct partially_ordered<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : partially_ordered1<T, U> {}; template <class T, class B> struct partially_ordered<T, T, B, operators_detail::false_t> : partially_ordered1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< partially_ordered<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< partially_ordered2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< partially_ordered1<T, B> > { typedef operators_detail::true_t value; };

template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct totally_ordered; template<class T, class U, class B> struct totally_ordered<T, U, B, operators_detail::false_t> : totally_ordered2<T, U, B> {}; template<class T, class U> struct totally_ordered<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : totally_ordered1<T, U> {}; template <class T, class B> struct totally_ordered<T, T, B, operators_detail::false_t> : totally_ordered1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< totally_ordered<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< totally_ordered2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< totally_ordered1<T, B> > { typedef operators_detail::true_t value; };
template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct additive; template<class T, class U, class B> struct additive<T, U, B, operators_detail::false_t> : additive2<T, U, B> {}; template<class T, class U> struct additive<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : additive1<T, U> {}; template <class T, class B> struct additive<T, T, B, operators_detail::false_t> : additive1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< additive<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< additive2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< additive1<T, B> > { typedef operators_detail::true_t value; };
template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct multiplicative; template<class T, class U, class B> struct multiplicative<T, U, B, operators_detail::false_t> : multiplicative2<T, U, B> {}; template<class T, class U> struct multiplicative<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : multiplicative1<T, U> {}; template <class T, class B> struct multiplicative<T, T, B, operators_detail::false_t> : multiplicative1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< multiplicative<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< multiplicative2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< multiplicative1<T, B> > { typedef operators_detail::true_t value; };
template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct integer_multiplicative; template<class T, class U, class B> struct integer_multiplicative<T, U, B, operators_detail::false_t> : integer_multiplicative2<T, U, B> {}; template<class T, class U> struct integer_multiplicative<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : integer_multiplicative1<T, U> {}; template <class T, class B> struct integer_multiplicative<T, T, B, operators_detail::false_t> : integer_multiplicative1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< integer_multiplicative<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< integer_multiplicative2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< integer_multiplicative1<T, B> > { typedef operators_detail::true_t value; };
template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct arithmetic; template<class T, class U, class B> struct arithmetic<T, U, B, operators_detail::false_t> : arithmetic2<T, U, B> {}; template<class T, class U> struct arithmetic<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : arithmetic1<T, U> {}; template <class T, class B> struct arithmetic<T, T, B, operators_detail::false_t> : arithmetic1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< arithmetic<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< arithmetic2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< arithmetic1<T, B> > { typedef operators_detail::true_t value; };
template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct integer_arithmetic; template<class T, class U, class B> struct integer_arithmetic<T, U, B, operators_detail::false_t> : integer_arithmetic2<T, U, B> {}; template<class T, class U> struct integer_arithmetic<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : integer_arithmetic1<T, U> {}; template <class T, class B> struct integer_arithmetic<T, T, B, operators_detail::false_t> : integer_arithmetic1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< integer_arithmetic<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< integer_arithmetic2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< integer_arithmetic1<T, B> > { typedef operators_detail::true_t value; };
template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct bitwise; template<class T, class U, class B> struct bitwise<T, U, B, operators_detail::false_t> : bitwise2<T, U, B> {}; template<class T, class U> struct bitwise<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : bitwise1<T, U> {}; template <class T, class B> struct bitwise<T, T, B, operators_detail::false_t> : bitwise1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< bitwise<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< bitwise2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< bitwise1<T, B> > { typedef operators_detail::true_t value; };
template<class T, class B> struct is_chained_base< unit_steppable<T, B> > { typedef operators_detail::true_t value; };
template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct shiftable; template<class T, class U, class B> struct shiftable<T, U, B, operators_detail::false_t> : shiftable2<T, U, B> {}; template<class T, class U> struct shiftable<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : shiftable1<T, U> {}; template <class T, class B> struct shiftable<T, T, B, operators_detail::false_t> : shiftable1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< shiftable<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< shiftable2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< shiftable1<T, B> > { typedef operators_detail::true_t value; };
template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct ring_operators; template<class T, class U, class B> struct ring_operators<T, U, B, operators_detail::false_t> : ring_operators2<T, U, B> {}; template<class T, class U> struct ring_operators<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : ring_operators1<T, U> {}; template <class T, class B> struct ring_operators<T, T, B, operators_detail::false_t> : ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ring_operators<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ring_operators2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< ring_operators1<T, B> > { typedef operators_detail::true_t value; };
template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct ordered_ring_operators; template<class T, class U, class B> struct ordered_ring_operators<T, U, B, operators_detail::false_t> : ordered_ring_operators2<T, U, B> {}; template<class T, class U> struct ordered_ring_operators<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : ordered_ring_operators1<T, U> {}; template <class T, class B> struct ordered_ring_operators<T, T, B, operators_detail::false_t> : ordered_ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ordered_ring_operators<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ordered_ring_operators2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< ordered_ring_operators1<T, B> > { typedef operators_detail::true_t value; };
template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct field_operators; template<class T, class U, class B> struct field_operators<T, U, B, operators_detail::false_t> : field_operators2<T, U, B> {}; template<class T, class U> struct field_operators<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : field_operators1<T, U> {}; template <class T, class B> struct field_operators<T, T, B, operators_detail::false_t> : field_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< field_operators<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< field_operators2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< field_operators1<T, B> > { typedef operators_detail::true_t value; };
template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct ordered_field_operators; template<class T, class U, class B> struct ordered_field_operators<T, U, B, operators_detail::false_t> : ordered_field_operators2<T, U, B> {}; template<class T, class U> struct ordered_field_operators<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : ordered_field_operators1<T, U> {}; template <class T, class B> struct ordered_field_operators<T, T, B, operators_detail::false_t> : ordered_field_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ordered_field_operators<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ordered_field_operators2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< ordered_field_operators1<T, B> > { typedef operators_detail::true_t value; };
template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct euclidian_ring_operators; template<class T, class U, class B> struct euclidian_ring_operators<T, U, B, operators_detail::false_t> : euclidian_ring_operators2<T, U, B> {}; template<class T, class U> struct euclidian_ring_operators<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : euclidian_ring_operators1<T, U> {}; template <class T, class B> struct euclidian_ring_operators<T, T, B, operators_detail::false_t> : euclidian_ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< euclidian_ring_operators<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< euclidian_ring_operators2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< euclidian_ring_operators1<T, B> > { typedef operators_detail::true_t value; };
template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct ordered_euclidian_ring_operators; template<class T, class U, class B> struct ordered_euclidian_ring_operators<T, U, B, operators_detail::false_t> : ordered_euclidian_ring_operators2<T, U, B> {}; template<class T, class U> struct ordered_euclidian_ring_operators<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : ordered_euclidian_ring_operators1<T, U> {}; template <class T, class B> struct ordered_euclidian_ring_operators<T, T, B, operators_detail::false_t> : ordered_euclidian_ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ordered_euclidian_ring_operators<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ordered_euclidian_ring_operators2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< ordered_euclidian_ring_operators1<T, B> > { typedef operators_detail::true_t value; };
template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct euclidean_ring_operators; template<class T, class U, class B> struct euclidean_ring_operators<T, U, B, operators_detail::false_t> : euclidean_ring_operators2<T, U, B> {}; template<class T, class U> struct euclidean_ring_operators<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : euclidean_ring_operators1<T, U> {}; template <class T, class B> struct euclidean_ring_operators<T, T, B, operators_detail::false_t> : euclidean_ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< euclidean_ring_operators<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< euclidean_ring_operators2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< euclidean_ring_operators1<T, B> > { typedef operators_detail::true_t value; };
template <class T ,class U = T ,class B = operators_detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct ordered_euclidean_ring_operators; template<class T, class U, class B> struct ordered_euclidean_ring_operators<T, U, B, operators_detail::false_t> : ordered_euclidean_ring_operators2<T, U, B> {}; template<class T, class U> struct ordered_euclidean_ring_operators<T, U, operators_detail::empty_base<T>, operators_detail::true_t> : ordered_euclidean_ring_operators1<T, U> {}; template <class T, class B> struct ordered_euclidean_ring_operators<T, T, B, operators_detail::false_t> : ordered_euclidean_ring_operators1<T, B> {}; template<class T, class U, class B, class O> struct is_chained_base< ordered_euclidean_ring_operators<T, U, B, O> > { typedef operators_detail::true_t value; }; template<class T, class U, class B> struct is_chained_base< ordered_euclidean_ring_operators2<T, U, B> > { typedef operators_detail::true_t value; }; template<class T, class B> struct is_chained_base< ordered_euclidean_ring_operators1<T, B> > { typedef operators_detail::true_t value; };
template<class T, class U, class B> struct is_chained_base< input_iteratable<T, U, B> > { typedef operators_detail::true_t value; };
template<class T, class B> struct is_chained_base< output_iteratable<T, B> > { typedef operators_detail::true_t value; };
template<class T, class U, class B> struct is_chained_base< forward_iteratable<T, U, B> > { typedef operators_detail::true_t value; };
template<class T, class U, class B> struct is_chained_base< bidirectional_iteratable<T, U, B> > { typedef operators_detail::true_t value; };
template<class T, class U, class V, class W, class B> struct is_chained_base< random_access_iteratable<T, U, V, W, B> > { typedef operators_detail::true_t value; };







template <class T, class U>
struct operators2
    : totally_ordered2<T,U
    , integer_arithmetic2<T,U
    , bitwise2<T,U
      > > > {};

template <class T, class U = T>
struct operators : operators2<T, U> {};

template <class T> struct operators<T, T>
    : totally_ordered<T
    , integer_arithmetic<T
    , bitwise<T
    , unit_steppable<T
      > > > > {};





template <class Category,
          class T,
          class Distance = std::ptrdiff_t,
          class Pointer = T*,
          class Reference = T&>
struct iterator_helper
{
  typedef Category iterator_category;
  typedef T value_type;
  typedef Distance difference_type;
  typedef Pointer pointer;
  typedef Reference reference;
};

template <class T,
          class V,
          class D = std::ptrdiff_t,
          class P = V const *,
          class R = V const &>
struct input_iterator_helper
  : input_iteratable<T, P
  , iterator_helper<std::input_iterator_tag, V, D, P, R
    > > {};

template<class T>
struct output_iterator_helper
  : output_iteratable<T
  , iterator_helper<std::output_iterator_tag, void, void, void, void
  > >
{
  T& operator*() { return static_cast<T&>(*this); }
  T& operator++() { return static_cast<T&>(*this); }
};

template <class T,
          class V,
          class D = std::ptrdiff_t,
          class P = V*,
          class R = V&>
struct forward_iterator_helper
  : forward_iteratable<T, P
  , iterator_helper<std::forward_iterator_tag, V, D, P, R
    > > {};

template <class T,
          class V,
          class D = std::ptrdiff_t,
          class P = V*,
          class R = V&>
struct bidirectional_iterator_helper
  : bidirectional_iteratable<T, P
  , iterator_helper<std::bidirectional_iterator_tag, V, D, P, R
    > > {};

template <class T,
          class V,
          class D = std::ptrdiff_t,
          class P = V*,
          class R = V&>
struct random_access_iterator_helper
  : random_access_iteratable<T, P, D, R
  , iterator_helper<std::random_access_iterator_tag, V, D, P, R
    > >
{
  friend D requires_difference_operator(const T& x, const T& y) {
    return x - y;
  }
};

}
using namespace operators_impl;

}
# 18 "/usr/include/boost/date_time/time_duration.hpp" 2 3 4



namespace boost {
namespace date_time {
# 35 "/usr/include/boost/date_time/time_duration.hpp" 3 4
  template<class T, typename rep_type>
  class __attribute__((__visibility__("default"))) time_duration : private
      boost::less_than_comparable<T
    , boost::equality_comparable<T
    > >





  {
  public:

    typedef void _is_boost_date_time_duration;
    typedef T duration_type;
    typedef rep_type traits_type;
    typedef typename rep_type::day_type day_type;
    typedef typename rep_type::hour_type hour_type;
    typedef typename rep_type::min_type min_type;
    typedef typename rep_type::sec_type sec_type;
    typedef typename rep_type::fractional_seconds_type fractional_seconds_type;
    typedef typename rep_type::tick_type tick_type;
    typedef typename rep_type::impl_type impl_type;

    constexpr time_duration() : ticks_(0) {}
    constexpr time_duration(hour_type hours_in,
                  min_type minutes_in,
                  sec_type seconds_in=0,
                  fractional_seconds_type frac_sec_in = 0) :
      ticks_(rep_type::to_tick_count(hours_in,minutes_in,seconds_in,frac_sec_in))
    {}

    constexpr time_duration(special_values sv) : ticks_(impl_type::from_special(sv))
    {}

    static constexpr duration_type unit()
    {
      return duration_type(0,0,0,1);
    }

    static constexpr tick_type ticks_per_second()
    {
      return rep_type::res_adjust();
    }

    static constexpr time_resolutions resolution()
    {
      return rep_type::resolution();
    }

    constexpr hour_type hours() const
    {
      return static_cast<hour_type>(ticks() / (3600*ticks_per_second()));
    }

    constexpr min_type minutes() const
    {
      return static_cast<min_type>((ticks() / (60*ticks_per_second())) % 60);
    }

    constexpr sec_type seconds() const
    {
      return static_cast<sec_type>((ticks()/ticks_per_second()) % 60);
    }

    constexpr sec_type total_seconds() const
    {
      return static_cast<sec_type>(ticks() / ticks_per_second());
    }

    constexpr tick_type total_milliseconds() const
    {
      if (ticks_per_second() < 1000) {
        return ticks() * (static_cast<tick_type>(1000) / ticks_per_second());
      }
      return ticks() / (ticks_per_second() / static_cast<tick_type>(1000)) ;
    }

    constexpr tick_type total_nanoseconds() const
    {
      if (ticks_per_second() < 1000000000) {
        return ticks() * (static_cast<tick_type>(1000000000) / ticks_per_second());
      }
      return ticks() / (ticks_per_second() / static_cast<tick_type>(1000000000)) ;
    }

    constexpr tick_type total_microseconds() const
    {
      if (ticks_per_second() < 1000000) {
        return ticks() * (static_cast<tick_type>(1000000) / ticks_per_second());
      }
      return ticks() / (ticks_per_second() / static_cast<tick_type>(1000000)) ;
    }

    constexpr fractional_seconds_type fractional_seconds() const
    {
      return (ticks() % ticks_per_second());
    }

    static constexpr unsigned short num_fractional_digits()
    {
      return rep_type::num_fractional_digits();
    }
    constexpr duration_type invert_sign() const
    {
      return duration_type(ticks_ * (-1));
    }
    constexpr duration_type abs() const
    {
      if ( is_negative() )
      {
        return invert_sign();
      }
      return duration_type(ticks_);
    }
    constexpr bool is_negative() const
    {
      return ticks_ < 0;
    }
    constexpr bool is_zero() const
    {
      return ticks_ == 0;
    }
    constexpr bool is_positive() const
    {
      return ticks_ > 0;
    }
    constexpr bool operator<(const time_duration& rhs) const
    {
      return ticks_ < rhs.ticks_;
    }
    constexpr bool operator==(const time_duration& rhs) const
    {
      return ticks_ == rhs.ticks_;
    }

    constexpr duration_type operator-()const
    {
      return duration_type(ticks_ * (-1));
    }
    constexpr duration_type operator-(const duration_type& d) const
    {
      return duration_type(ticks_ - d.ticks_);
    }
    constexpr duration_type operator+(const duration_type& d) const
    {
      return duration_type(ticks_ + d.ticks_);
    }
    constexpr duration_type operator/(int divisor) const
    {
      return duration_type(ticks_ / divisor);
    }
    constexpr duration_type operator-=(const duration_type& d)
    {
      ticks_ = ticks_ - d.ticks_;
      return duration_type(ticks_);
    }
    constexpr duration_type operator+=(const duration_type& d)
    {
      ticks_ = ticks_ + d.ticks_;
      return duration_type(ticks_);
    }

    constexpr duration_type operator/=(int divisor)
    {
      ticks_ = ticks_ / divisor;
      return duration_type(ticks_);
    }

    constexpr duration_type operator*(int rhs) const
    {
      return duration_type(ticks_ * rhs);
    }
    constexpr duration_type operator*=(int divisor)
    {
      ticks_ = ticks_ * divisor;
      return duration_type(ticks_);
    }
    constexpr tick_type ticks() const
    {
      return traits_type::as_number(ticks_);
    }


    constexpr bool is_special()const
    {
      if(traits_type::is_adapted())
      {
        return ticks_.is_special();
      }
      else{
        return false;
      }
    }

    constexpr bool is_pos_infinity()const
    {
      if(traits_type::is_adapted())
      {
        return ticks_.is_pos_infinity();
      }
      else{
        return false;
      }
    }

    constexpr bool is_neg_infinity()const
    {
      if(traits_type::is_adapted())
      {
        return ticks_.is_neg_infinity();
      }
      else{
        return false;
      }
    }

    constexpr bool is_not_a_date_time()const
    {
      if(traits_type::is_adapted())
      {
        return ticks_.is_nan();
      }
      else{
        return false;
      }
    }


    constexpr impl_type get_rep()const
    {
      return ticks_;
    }

  protected:
    constexpr explicit time_duration(impl_type in) : ticks_(in) {}
    impl_type ticks_;
  };







  template<class base_duration, boost::int64_t frac_of_second>
  class __attribute__((__visibility__("default"))) subsecond_duration : public base_duration
  {
  public:
    typedef typename base_duration::impl_type impl_type;
    typedef typename base_duration::traits_type traits_type;

  private:

    static_assert((traits_type::ticks_per_second >= frac_of_second ? traits_type::ticks_per_second % frac_of_second : frac_of_second % traits_type::ticks_per_second) == 0, "The base duration resolution must be a multiple of the subsecond duration resolution");

    static const boost::int64_t adjustment_ratio = (traits_type::ticks_per_second >= frac_of_second ? traits_type::ticks_per_second / frac_of_second : frac_of_second / traits_type::ticks_per_second);

  public:

    template <typename T>
    constexpr explicit subsecond_duration(T const& ss,
                                                      typename boost::enable_if<boost::is_integral<T>,
                                                        void>::type* = nullptr) :
      base_duration(impl_type(traits_type::ticks_per_second >= frac_of_second ? ss * adjustment_ratio : ss / adjustment_ratio))
    {
    }
  };

} }
# 17 "/usr/include/boost/date_time/posix_time/posix_time_config.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/time_resolution_traits.hpp" 1 3 4
# 12 "/usr/include/boost/date_time/time_resolution_traits.hpp" 3 4
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ctime" 1 3 4
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ctime" 3
# 13 "/usr/include/boost/date_time/time_resolution_traits.hpp" 2 3 4
# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 14 "/usr/include/boost/date_time/time_resolution_traits.hpp" 2 3 4

# 1 "/usr/include/boost/date_time/int_adapter.hpp" 1 3 4
# 27 "/usr/include/boost/date_time/int_adapter.hpp" 3 4
namespace boost {
namespace date_time {
# 45 "/usr/include/boost/date_time/int_adapter.hpp" 3 4
template<typename int_type_>
class int_adapter {
public:
  typedef int_type_ int_type;
  constexpr int_adapter(int_type v) :
    value_(v)
  {}
  static constexpr bool has_infinity()
  {
    return true;
  }
  static constexpr int_adapter pos_infinity()
  {
    return (::std::numeric_limits<int_type>::max)();
  }
  static constexpr int_adapter neg_infinity()
  {
    return (::std::numeric_limits<int_type>::min)();
  }
  static constexpr int_adapter not_a_number()
  {
    return (::std::numeric_limits<int_type>::max)()-1;
  }
  static constexpr int_adapter max ()
  {
    return (::std::numeric_limits<int_type>::max)()-2;
  }
  static constexpr int_adapter min ()
  {
    return (::std::numeric_limits<int_type>::min)()+1;
  }
  static constexpr int_adapter from_special(special_values sv)
  {
    switch (sv) {
    case not_a_date_time: return not_a_number();
    case neg_infin: return neg_infinity();
    case pos_infin: return pos_infinity();
    case max_date_time: return (max)();
    case min_date_time: return (min)();
    default: return not_a_number();
    }
  }
  static constexpr bool is_inf(int_type v)
  {
    return (v == neg_infinity().as_number() ||
            v == pos_infinity().as_number());
  }
  static constexpr bool is_neg_inf(int_type v)
  {
    return (v == neg_infinity().as_number());
  }
  static constexpr bool is_pos_inf(int_type v)
  {
    return (v == pos_infinity().as_number());
  }
  static constexpr bool is_not_a_number(int_type v)
  {
    return (v == not_a_number().as_number());
  }

  static constexpr special_values to_special(int_type v)
  {
    if (is_not_a_number(v)) return not_a_date_time;
    if (is_neg_inf(v)) return neg_infin;
    if (is_pos_inf(v)) return pos_infin;
    return not_special;
  }


  static constexpr int_type maxcount()
  {
    return (::std::numeric_limits<int_type>::max)()-3;
  }
  constexpr bool is_infinity() const
  {
    return (value_ == neg_infinity().as_number() ||
            value_ == pos_infinity().as_number());
  }
  constexpr bool is_pos_infinity()const
  {
    return(value_ == pos_infinity().as_number());
  }
  constexpr bool is_neg_infinity()const
  {
    return(value_ == neg_infinity().as_number());
  }
  constexpr bool is_nan() const
  {
    return (value_ == not_a_number().as_number());
  }
  constexpr bool is_special() const
  {
    return(is_infinity() || is_nan());
  }
  constexpr bool operator==(const int_adapter& rhs) const
  {
    return (compare(rhs) == 0);
  }
  constexpr bool operator==(const int& rhs) const
  {
    if(!std::numeric_limits<int_type>::is_signed)
    {
      if(is_neg_inf(value_) && rhs == 0)
      {
        return false;
      }
    }
    return (compare(rhs) == 0);
  }
  constexpr bool operator!=(const int_adapter& rhs) const
  {
    return (compare(rhs) != 0);
  }
  constexpr bool operator!=(const int& rhs) const
  {
    if(!std::numeric_limits<int_type>::is_signed)
    {
      if(is_neg_inf(value_) && rhs == 0)
      {
        return true;
      }
    }
    return (compare(rhs) != 0);
  }
  constexpr bool operator<(const int_adapter& rhs) const
  {
    return (compare(rhs) == -1);
  }
  constexpr bool operator<(const int& rhs) const
  {

    if(!std::numeric_limits<int_type>::is_signed)
    {
      if(is_neg_inf(value_) && rhs == 0)
      {
        return true;
      }
    }
    return (compare(rhs) == -1);
  }
  constexpr bool operator>(const int_adapter& rhs) const
  {
    return (compare(rhs) == 1);
  }
  constexpr int_type as_number() const
  {
    return value_;
  }

  constexpr special_values as_special() const
  {
    return int_adapter::to_special(value_);
  }
# 206 "/usr/include/boost/date_time/int_adapter.hpp" 3 4
  template<class rhs_type>
  constexpr
  int_adapter operator+(const int_adapter<rhs_type>& rhs) const
  {
    if(is_special() || rhs.is_special())
    {
      if (is_nan() || rhs.is_nan())
      {
        return int_adapter::not_a_number();
      }
      if((is_pos_inf(value_) && rhs.is_neg_inf(rhs.as_number())) ||
      (is_neg_inf(value_) && rhs.is_pos_inf(rhs.as_number())) )
      {
        return int_adapter::not_a_number();
      }
      if (is_infinity())
      {
        return *this;
      }
      if (rhs.is_pos_inf(rhs.as_number()))
      {
        return int_adapter::pos_infinity();
      }
      if (rhs.is_neg_inf(rhs.as_number()))
      {
        return int_adapter::neg_infinity();
      }
    }
    return int_adapter<int_type>(value_ + static_cast<int_type>(rhs.as_number()));
  }

  constexpr
  int_adapter operator+(const int_type rhs) const
  {
    if(is_special())
    {
      if (is_nan())
      {
        return int_adapter<int_type>(not_a_number());
      }
      if (is_infinity())
      {
        return *this;
      }
    }
    return int_adapter<int_type>(value_ + rhs);
  }



  template<class rhs_type>
  constexpr
  int_adapter operator-(const int_adapter<rhs_type>& rhs)const
  {
    if(is_special() || rhs.is_special())
    {
      if (is_nan() || rhs.is_nan())
      {
        return int_adapter::not_a_number();
      }
      if((is_pos_inf(value_) && rhs.is_pos_inf(rhs.as_number())) ||
         (is_neg_inf(value_) && rhs.is_neg_inf(rhs.as_number())) )
      {
        return int_adapter::not_a_number();
      }
      if (is_infinity())
      {
        return *this;
      }
      if (rhs.is_pos_inf(rhs.as_number()))
      {
        return int_adapter::neg_infinity();
      }
      if (rhs.is_neg_inf(rhs.as_number()))
      {
        return int_adapter::pos_infinity();
      }
    }
    return int_adapter<int_type>(value_ - static_cast<int_type>(rhs.as_number()));
  }

  constexpr
  int_adapter operator-(const int_type rhs) const
  {
    if(is_special())
    {
      if (is_nan())
      {
        return int_adapter<int_type>(not_a_number());
      }
      if (is_infinity())
      {
        return *this;
      }
    }
    return int_adapter<int_type>(value_ - rhs);
  }


  constexpr
  int_adapter operator*(const int_adapter& rhs)const
  {
    if(this->is_special() || rhs.is_special())
    {
      return mult_div_specials(rhs);
    }
    return int_adapter<int_type>(value_ * rhs.value_);
  }



  constexpr
  int_adapter operator*(const int rhs) const
  {
    if(is_special())
    {
      return mult_div_specials(rhs);
    }
    return int_adapter<int_type>(value_ * rhs);
  }


  constexpr
  int_adapter operator/(const int_adapter& rhs)const
  {
    if(this->is_special() || rhs.is_special())
    {
      if(is_infinity() && rhs.is_infinity())
      {
        return int_adapter<int_type>(not_a_number());
      }
      if(rhs != 0)
      {
        return mult_div_specials(rhs);
      }
      else {
        return int_adapter<int_type>(value_ / rhs.value_);
      }
    }
    return int_adapter<int_type>(value_ / rhs.value_);
  }



  constexpr
  int_adapter operator/(const int rhs) const
  {
    if(is_special() && rhs != 0)
    {
      return mult_div_specials(rhs);
    }

    return int_adapter<int_type>(value_ / rhs);
  }


  constexpr
  int_adapter operator%(const int_adapter& rhs)const
  {
    if(this->is_special() || rhs.is_special())
    {
      if(is_infinity() && rhs.is_infinity())
      {
        return int_adapter<int_type>(not_a_number());
      }
      if(rhs != 0)
      {
        return mult_div_specials(rhs);
      }
      else {
        return int_adapter<int_type>(value_ % rhs.value_);
      }
    }
    return int_adapter<int_type>(value_ % rhs.value_);
  }



  constexpr
  int_adapter operator%(const int rhs) const
  {
    if(is_special() && rhs != 0)
    {
      return mult_div_specials(rhs);
    }

    return int_adapter<int_type>(value_ % rhs);
  }

private:
  int_type value_;


  constexpr
  int compare( const int_adapter& rhs ) const
  {
    if(this->is_special() || rhs.is_special())
    {
      if(this->is_nan() || rhs.is_nan()) {
        if(this->is_nan() && rhs.is_nan()) {
          return 0;
        }
        else {
          return 2;
        }
      }
      if((is_neg_inf(value_) && !is_neg_inf(rhs.value_)) ||
         (is_pos_inf(rhs.value_) && !is_pos_inf(value_)) )
        {
          return -1;
        }
      if((is_pos_inf(value_) && !is_pos_inf(rhs.value_)) ||
         (is_neg_inf(rhs.value_) && !is_neg_inf(value_)) ) {
        return 1;
      }
    }
    if(value_ < rhs.value_) return -1;
    if(value_ > rhs.value_) return 1;

    return 0;
  }






  constexpr
  int_adapter mult_div_specials(const int_adapter& rhs) const
  {
    if(this->is_nan() || rhs.is_nan()) {
      return int_adapter<int_type>(not_a_number());
    }
    constexpr int min_value = std::numeric_limits<int_type>::is_signed ? 0 : 1;
    if((*this > 0 && rhs > 0) || (*this < min_value && rhs < min_value)) {
        return int_adapter<int_type>(pos_infinity());
    }
    if((*this > 0 && rhs < min_value) || (*this < min_value && rhs > 0)) {
        return int_adapter<int_type>(neg_infinity());
    }

    return int_adapter<int_type>(not_a_number());
  }







  constexpr
  int_adapter mult_div_specials(const int& rhs) const
  {
    if(this->is_nan()) {
      return int_adapter<int_type>(not_a_number());
    }
    constexpr int min_value = std::numeric_limits<int_type>::is_signed ? 0 : 1;
    if((*this > 0 && rhs > 0) || (*this < min_value && rhs < 0)) {
        return int_adapter<int_type>(pos_infinity());
    }
    if((*this > 0 && rhs < 0) || (*this < min_value && rhs > 0)) {
        return int_adapter<int_type>(neg_infinity());
    }

    return int_adapter<int_type>(not_a_number());
  }

};






  template<class charT, class traits, typename int_type>
  inline
  std::basic_ostream<charT, traits>&
  operator<<(std::basic_ostream<charT, traits>& os, const int_adapter<int_type>& ia)
  {
    if(ia.is_special()) {

      switch(ia.as_special())
        {
      case not_a_date_time:
        os << "not-a-number";
        break;
      case pos_infin:
        os << "+infinity";
        break;
      case neg_infin:
        os << "-infinity";
        break;
      default:
        os << "";
      }
    }
    else {
      os << ia.as_number();
    }
    return os;
  }



} }
# 16 "/usr/include/boost/date_time/time_resolution_traits.hpp" 2 3 4


namespace boost {
namespace date_time {


  template <typename T>


  inline constexpr T absolute_value(T x)
  {
    return x < 0 ? -x : x;
  }


  struct time_resolution_traits_bi32_impl {
    typedef boost::int32_t int_type;
    typedef boost::int32_t impl_type;
    static constexpr int_type as_number(impl_type i){ return i;}

    static constexpr bool is_adapted() { return false;}
  };

  struct time_resolution_traits_adapted32_impl {
    typedef boost::int32_t int_type;
    typedef boost::date_time::int_adapter<boost::int32_t> impl_type;
    static constexpr int_type as_number(impl_type i){ return i.as_number();}

    static constexpr bool is_adapted() { return true;}
  };

  struct time_resolution_traits_bi64_impl {
    typedef boost::int64_t int_type;
    typedef boost::int64_t impl_type;
    static constexpr int_type as_number(impl_type i){ return i;}

    static constexpr bool is_adapted() { return false;}
  };

  struct time_resolution_traits_adapted64_impl {
    typedef boost::int64_t int_type;
    typedef boost::date_time::int_adapter<boost::int64_t> impl_type;
    static constexpr int_type as_number(impl_type i){ return i.as_number();}

    static constexpr bool is_adapted() { return true;}
  };
# 86 "/usr/include/boost/date_time/time_resolution_traits.hpp" 3 4
  template<typename frac_sec_type,
           time_resolutions res,



           typename frac_sec_type::int_type resolution_adjust,

           unsigned short frac_digits,
           typename var_type = boost::int64_t >
  class time_resolution_traits {
  public:
    typedef typename frac_sec_type::int_type fractional_seconds_type;
    typedef typename frac_sec_type::int_type tick_type;
    typedef typename frac_sec_type::impl_type impl_type;
    typedef var_type day_type;
    typedef var_type hour_type;
    typedef var_type min_type;
    typedef var_type sec_type;


    static constexpr fractional_seconds_type as_number(impl_type i)
    {
      return frac_sec_type::as_number(i);
    }
    static constexpr bool is_adapted()
    {
      return frac_sec_type::is_adapted();
    }





    static const fractional_seconds_type ticks_per_second = resolution_adjust;


    static constexpr time_resolutions resolution()
    {
      return res;
    }
    static constexpr unsigned short num_fractional_digits()
    {
      return frac_digits;
    }
    static constexpr fractional_seconds_type res_adjust()
    {
      return resolution_adjust;
    }

    static constexpr tick_type to_tick_count(hour_type hours,
                                                         min_type minutes,
                                                         sec_type seconds,
                                                         fractional_seconds_type fs)
    {
      if(hours < 0 || minutes < 0 || seconds < 0 || fs < 0)
      {
        hours = absolute_value(hours);
        minutes = absolute_value(minutes);
        seconds = absolute_value(seconds);
        fs = absolute_value(fs);
        return static_cast<tick_type>(((((fractional_seconds_type(hours)*3600)
                                       + (fractional_seconds_type(minutes)*60)
                                       + seconds)*res_adjust()) + fs) * -1);
      }

      return static_cast<tick_type>((((fractional_seconds_type(hours)*3600)
                                    + (fractional_seconds_type(minutes)*60)
                                    + seconds)*res_adjust()) + fs);
    }

  };

  typedef time_resolution_traits<time_resolution_traits_adapted32_impl, milli, 1000, 3 > milli_res;
  typedef time_resolution_traits<time_resolution_traits_adapted64_impl, micro, 1000000, 6 > micro_res;
  typedef time_resolution_traits<time_resolution_traits_adapted64_impl, nano, 1000000000, 9 > nano_res;


} }
# 18 "/usr/include/boost/date_time/posix_time/posix_time_config.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/gregorian/gregorian_types.hpp" 1 3 4
# 17 "/usr/include/boost/date_time/gregorian/gregorian_types.hpp" 3 4
# 1 "/usr/include/boost/date_time/date.hpp" 1 3 4
# 14 "/usr/include/boost/date_time/date.hpp" 3 4
# 1 "/usr/include/boost/date_time/year_month_day.hpp" 1 3 4
# 14 "/usr/include/boost/date_time/year_month_day.hpp" 3 4
namespace boost {
namespace date_time {


  template<typename YearType, typename MonthType, typename DayType>
  struct __attribute__((__visibility__("default"))) year_month_day_base {
    constexpr
    year_month_day_base(YearType year,
                        MonthType month,
                        DayType day);

    YearType year;
    MonthType month;
    DayType day;
    typedef YearType year_type;
    typedef MonthType month_type;
    typedef DayType day_type;
  };



  template<typename YearType, typename MonthType, typename DayType>
  inline constexpr
  year_month_day_base<YearType,MonthType,DayType>::year_month_day_base(YearType y,
                                                                       MonthType m,
                                                                       DayType d) :
    year(y),
    month(m),
    day(d)
  {}

} }
# 15 "/usr/include/boost/date_time/date.hpp" 2 3 4


namespace boost {
namespace date_time {
# 53 "/usr/include/boost/date_time/date.hpp" 3 4
  template<class T, class calendar, class duration_type_>
  class __attribute__((__visibility__("default"))) date : private
       boost::less_than_comparable<T
     , boost::equality_comparable<T
    > >
  {
  public:
    typedef T date_type;
    typedef calendar calendar_type;
    typedef typename calendar::date_traits_type traits_type;
    typedef duration_type_ duration_type;
    typedef typename calendar::year_type year_type;
    typedef typename calendar::month_type month_type;
    typedef typename calendar::day_type day_type;
    typedef typename calendar::ymd_type ymd_type;
    typedef typename calendar::date_rep_type date_rep_type;
    typedef typename calendar::date_int_type date_int_type;
    typedef typename calendar::day_of_week_type day_of_week_type;
    constexpr date(year_type y, month_type m, day_type d)
      : days_(calendar::day_number(ymd_type(y, m, d)))
    {}
    constexpr date(const ymd_type& ymd)
      : days_(calendar::day_number(ymd))
    {}

    constexpr year_type year() const
    {
      ymd_type ymd = calendar::from_day_number(days_);
      return ymd.year;
    }
    constexpr month_type month() const
    {
      ymd_type ymd = calendar::from_day_number(days_);
      return ymd.month;
    }
    constexpr day_type day() const
    {
      ymd_type ymd = calendar::from_day_number(days_);
      return ymd.day;
    }
    constexpr day_of_week_type day_of_week() const
    {
      ymd_type ymd = calendar::from_day_number(days_);
      return calendar::day_of_week(ymd);
    }
    constexpr ymd_type year_month_day() const
    {
      return calendar::from_day_number(days_);
    }
    constexpr bool operator<(const date_type& rhs) const
    {
      return days_ < rhs.days_;
    }
    constexpr bool operator==(const date_type& rhs) const
    {
      return days_ == rhs.days_;
    }

    constexpr bool is_special()const
    {
      return(is_not_a_date() || is_infinity());
    }

    constexpr bool is_not_a_date() const
    {
      return traits_type::is_not_a_number(days_);
    }

    constexpr bool is_infinity() const
    {
      return traits_type::is_inf(days_);
    }

    constexpr bool is_pos_infinity() const
    {
      return traits_type::is_pos_inf(days_);
    }

    constexpr bool is_neg_infinity() const
    {
      return traits_type::is_neg_inf(days_);
    }

    constexpr special_values as_special() const
    {
      return traits_type::to_special(days_);
    }
    constexpr duration_type operator-(const date_type& d) const
    {
      if (!this->is_special() && !d.is_special())
      {


        typedef typename duration_type::duration_rep_type duration_rep_type;
        return duration_type(static_cast< duration_rep_type >(days_) - static_cast< duration_rep_type >(d.days_));
      }
      else
      {

        date_rep_type val = date_rep_type(days_) - date_rep_type(d.days_);
        return duration_type(val.as_special());
      }
    }

    constexpr date_type operator-(const duration_type& dd) const
    {
      if(dd.is_special())
      {
        return date_type(date_rep_type(days_) - dd.get_rep());
      }
      return date_type(date_rep_type(days_) - static_cast<date_int_type>(dd.days()));
    }
    constexpr date_type operator-=(const duration_type& dd)
    {
      *this = *this - dd;
      return date_type(days_);
    }
    constexpr date_rep_type day_count() const
    {
      return days_;
    }

    constexpr date_type operator+(const duration_type& dd) const
    {
      if(dd.is_special())
      {
        return date_type(date_rep_type(days_) + dd.get_rep());
      }
      return date_type(date_rep_type(days_) + static_cast<date_int_type>(dd.days()));
    }
    constexpr date_type operator+=(const duration_type& dd)
    {
      *this = *this + dd;
      return date_type(days_);
    }


  protected:




    constexpr explicit date(date_int_type days) : days_(days) {}
    constexpr explicit date(date_rep_type days) : days_(days.as_number()) {}
    date_int_type days_;

  };




} }
# 18 "/usr/include/boost/date_time/gregorian/gregorian_types.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/period.hpp" 1 3 4
# 24 "/usr/include/boost/date_time/period.hpp" 3 4
namespace boost {
namespace date_time {
# 51 "/usr/include/boost/date_time/period.hpp" 3 4
  template<class point_rep, class duration_rep>
  class __attribute__((__visibility__("default"))) period : private
      boost::less_than_comparable<period<point_rep, duration_rep>
    , boost::equality_comparable< period<point_rep, duration_rep>
    > >
  {
  public:
    typedef point_rep point_type;
    typedef duration_rep duration_type;

    constexpr period(point_rep first_point, point_rep end_point);
    constexpr period(point_rep first_point, duration_rep len);
    constexpr point_rep begin() const;
    constexpr point_rep end() const;
    constexpr point_rep last() const;
    constexpr duration_rep length() const;
    constexpr bool is_null() const;
    constexpr bool operator==(const period& rhs) const;
    constexpr bool operator<(const period& rhs) const;
    constexpr void shift(const duration_rep& d);
    constexpr void expand(const duration_rep& d);
    constexpr bool contains(const point_rep& point) const;
    constexpr bool contains(const period& other) const;
    constexpr bool intersects(const period& other) const;
    constexpr bool is_adjacent(const period& other) const;
    constexpr bool is_before(const point_rep& point) const;
    constexpr bool is_after(const point_rep& point) const;
    constexpr period intersection(const period& other) const;
    constexpr period merge(const period& other) const;
    constexpr period span(const period& other) const;
  private:
    point_rep begin_;
    point_rep last_;
  };




  template<class point_rep, class duration_rep>
  inline constexpr
  period<point_rep,duration_rep>::period(point_rep first_point,
                                         point_rep end_point) :
    begin_(first_point),
    last_(end_point - duration_rep::unit())
  {}




  template<class point_rep, class duration_rep>
  inline constexpr
  period<point_rep,duration_rep>::period(point_rep first_point, duration_rep len) :
    begin_(first_point),
    last_(first_point + len-duration_rep::unit())
  { }



  template<class point_rep, class duration_rep>
  inline constexpr
  point_rep period<point_rep,duration_rep>::begin() const
  {
    return begin_;
  }


  template<class point_rep, class duration_rep>
  inline constexpr
  point_rep period<point_rep,duration_rep>::end() const
  {
    return last_ + duration_rep::unit();
  }


  template<class point_rep, class duration_rep>
  inline constexpr
  point_rep period<point_rep,duration_rep>::last() const
  {
    return last_;
  }


  template<class point_rep, class duration_rep>
  inline constexpr
  bool period<point_rep,duration_rep>::is_null() const
  {
    return end() <= begin_;
  }


  template<class point_rep, class duration_rep>
  inline constexpr
  duration_rep period<point_rep,duration_rep>::length() const
  {
    if(last_ < begin_){
      return last_+duration_rep::unit() - begin_;
    }
    else{
      return end() - begin_;
    }
  }


  template<class point_rep, class duration_rep>
  inline constexpr
  bool period<point_rep,duration_rep>::operator==(const period& rhs) const
  {
    return ((begin_ == rhs.begin_) &&
             (last_ == rhs.last_));
  }


  template<class point_rep, class duration_rep>
  inline constexpr
  bool period<point_rep,duration_rep>::operator<(const period& rhs) const
  {
    return (last_ < rhs.begin_);
  }



  template<class point_rep, class duration_rep>
  inline constexpr
  void period<point_rep,duration_rep>::shift(const duration_rep& d)
  {
    begin_ = begin_ + d;
    last_ = last_ + d;
  }
# 199 "/usr/include/boost/date_time/period.hpp" 3 4
  template<class point_rep, class duration_rep>
  inline constexpr
  void period<point_rep,duration_rep>::expand(const duration_rep& d)
  {
    begin_ = begin_ - d;
    last_ = last_ + d;
  }


  template<class point_rep, class duration_rep>
  inline constexpr
  bool period<point_rep,duration_rep>::contains(const point_rep& point) const
  {
    return ((point >= begin_) &&
            (point <= last_));
  }



  template<class point_rep, class duration_rep>
  inline constexpr
  bool period<point_rep,duration_rep>::contains(const period<point_rep,duration_rep>& other) const
  {
    return ((begin_ <= other.begin_) && (last_ >= other.last_));
  }
# 235 "/usr/include/boost/date_time/period.hpp" 3 4
  template<class point_rep, class duration_rep>
  inline constexpr
  bool period<point_rep,duration_rep>::is_adjacent(const period<point_rep,duration_rep>& other) const
  {
    return (other.begin() == end() ||
            begin_ == other.end());
  }
# 253 "/usr/include/boost/date_time/period.hpp" 3 4
  template<class point_rep, class duration_rep>
  inline constexpr
  bool period<point_rep,duration_rep>::is_after(const point_rep& t) const
  {
    if (is_null())
    {
      return false;
    }

    return t < begin_;
  }
# 274 "/usr/include/boost/date_time/period.hpp" 3 4
  template<class point_rep, class duration_rep>
  inline constexpr
  bool period<point_rep,duration_rep>::is_before(const point_rep& t) const
  {
    if (is_null())
    {
      return false;
    }

    return last_ < t;
  }
# 298 "/usr/include/boost/date_time/period.hpp" 3 4
  template<class point_rep, class duration_rep>
  inline constexpr
  bool period<point_rep,duration_rep>::intersects(const period<point_rep,duration_rep>& other) const
  {
    return ( contains(other.begin_) ||
             other.contains(begin_) ||
             ((other.begin_ < begin_) && (other.last_ >= begin_)));
  }


  template<class point_rep, class duration_rep>
  inline constexpr
  period<point_rep,duration_rep>
  period<point_rep,duration_rep>::intersection(const period<point_rep,duration_rep>& other) const
  {
    if (begin_ > other.begin_) {
      if (last_ <= other.last_) {
        return *this;
      }

      return period<point_rep,duration_rep>(begin_, other.end());
    }
    else {
      if (last_ <= other.last_) {
        return period<point_rep,duration_rep>(other.begin_, this->end());
      }

      return other;
    }

  }




  template<class point_rep, class duration_rep>
  inline constexpr
  period<point_rep,duration_rep>
  period<point_rep,duration_rep>::merge(const period<point_rep,duration_rep>& other) const
  {
    if (this->intersects(other)) {
      if (begin_ < other.begin_) {
        return period<point_rep,duration_rep>(begin_, last_ > other.last_ ? this->end() : other.end());
      }

      return period<point_rep,duration_rep>(other.begin_, last_ > other.last_ ? this->end() : other.end());

    }
    return period<point_rep,duration_rep>(begin_,begin_);
  }
# 360 "/usr/include/boost/date_time/period.hpp" 3 4
  template<class point_rep, class duration_rep>
  inline constexpr
  period<point_rep,duration_rep>
  period<point_rep,duration_rep>::span(const period<point_rep,duration_rep>& other) const
  {
    point_rep start((begin_ < other.begin_) ? begin() : other.begin());
    point_rep newend((last_ < other.last_) ? other.end() : this->end());
    return period<point_rep,duration_rep>(start, newend);
  }


} }
# 19 "/usr/include/boost/date_time/gregorian/gregorian_types.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/gregorian/greg_calendar.hpp" 1 3 4
# 12 "/usr/include/boost/date_time/gregorian/greg_calendar.hpp" 3 4
# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 13 "/usr/include/boost/date_time/gregorian/greg_calendar.hpp" 2 3 4

# 1 "/usr/include/boost/date_time/gregorian/greg_weekday.hpp" 1 3 4
# 12 "/usr/include/boost/date_time/gregorian/greg_weekday.hpp" 3 4
# 1 "/usr/include/boost/date_time/constrained_value.hpp" 1 3 4
# 19 "/usr/include/boost/date_time/constrained_value.hpp" 3 4
namespace boost {


namespace CV {

  enum violation_enum {min_violation, max_violation};
# 41 "/usr/include/boost/date_time/constrained_value.hpp" 3 4
  template<class value_policies>
  class __attribute__((__visibility__("default"))) constrained_value {
  public:
    typedef typename value_policies::value_type value_type;

    constexpr constrained_value(value_type value) : value_((min)())
    {
      assign(value);
    }
    constexpr constrained_value& operator=(value_type v)
    {
      assign(v);
      return *this;
    }

    static constexpr value_type
    max () {return (value_policies::max)();}


    static constexpr value_type
    min () {return (value_policies::min)();}


    constexpr operator value_type() const {return value_;}
  protected:
    value_type value_;
  private:
    constexpr void assign(value_type value)
    {


      if (value+1 < (min)()+1) {
        value_policies::on_error(value_, value, min_violation);
        return;
      }
      if (value > (max)()) {
        value_policies::on_error(value_, value, max_violation);
        return;
      }
      value_ = value;
    }
};


  template<typename rep_type, rep_type min_value,
           rep_type max_value, class exception_type>
  class __attribute__((__visibility__("default"))) simple_exception_policy
  {
    struct __attribute__((__visibility__("default"))) exception_wrapper : public exception_type
    {




      operator std::out_of_range () const
      {

        return std::out_of_range("constrained value boundary has been violated");
      }
    };

    typedef typename conditional<
      is_base_of< std::exception, exception_type >::value,
      exception_type,
      exception_wrapper
    >::type actual_exception_type;

  public:
    typedef rep_type value_type;
    static constexpr rep_type
    min () { return min_value; }

    static constexpr rep_type
    max () { return max_value; }

    static void on_error(rep_type, rep_type, violation_enum)
    {
      boost::throw_exception(actual_exception_type());
    }
  };



} }
# 13 "/usr/include/boost/date_time/gregorian/greg_weekday.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/date_defs.hpp" 1 3 4
# 13 "/usr/include/boost/date_time/date_defs.hpp" 3 4
namespace boost {
namespace date_time {


  enum weekdays {Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday};


  enum months_of_year {Jan=1,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec,NotAMonth,NumMonths};

} }
# 14 "/usr/include/boost/date_time/gregorian/greg_weekday.hpp" 2 3 4




namespace boost {
namespace gregorian {


  using date_time::Sunday;
  using date_time::Monday;
  using date_time::Tuesday;
  using date_time::Wednesday;
  using date_time::Thursday;
  using date_time::Friday;
  using date_time::Saturday;



  struct __attribute__((__visibility__("default"))) bad_weekday : public std::out_of_range
  {
    bad_weekday() : std::out_of_range(std::string("Weekday is out of range 0..6")) {}
  };
  typedef CV::simple_exception_policy<unsigned short, 0, 6, bad_weekday> greg_weekday_policies;
  typedef CV::constrained_value<greg_weekday_policies> greg_weekday_rep;



  class __attribute__((__visibility__("default"))) greg_weekday : public greg_weekday_rep {
  public:
    typedef boost::date_time::weekdays weekday_enum;
    constexpr greg_weekday(value_type day_of_week_num) :
      greg_weekday_rep(day_of_week_num)
    {}

    constexpr value_type as_number() const {return value_;}
    constexpr weekday_enum as_enum() const {return static_cast<weekday_enum>(value_);}


    const char* as_short_string() const
    {
      static const char* const short_weekday_names[]
        = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};

      return short_weekday_names[value_];
    }


    const char* as_long_string() const
    {
      static const char* const long_weekday_names[]
        = {"Sunday","Monday","Tuesday","Wednesday", "Thursday", "Friday", "Saturday"};

      return long_weekday_names[value_];
    }





    const wchar_t* as_short_wstring() const
    {
      static const wchar_t* const w_short_weekday_names[]={L"Sun", L"Mon", L"Tue",
                                                           L"Wed", L"Thu", L"Fri", L"Sat"};
      return w_short_weekday_names[value_];
    }


    const wchar_t* as_long_wstring() const
    {
      static const wchar_t* const w_long_weekday_names[]= {L"Sunday",L"Monday",L"Tuesday",
                                                           L"Wednesday", L"Thursday",
                                                           L"Friday", L"Saturday"};
      return w_long_weekday_names[value_];
    }




  };



} }
# 15 "/usr/include/boost/date_time/gregorian/greg_calendar.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/gregorian/greg_day_of_year.hpp" 1 3 4
# 17 "/usr/include/boost/date_time/gregorian/greg_day_of_year.hpp" 3 4
namespace boost {
namespace gregorian {


  struct __attribute__((__visibility__("default"))) bad_day_of_year : public std::out_of_range
  {
    bad_day_of_year() :
      std::out_of_range(std::string("Day of year value is out of range 1..366"))
    {}
  };


  typedef CV::simple_exception_policy<unsigned short,1,366,bad_day_of_year> greg_day_of_year_policies;


  typedef CV::constrained_value<greg_day_of_year_policies> greg_day_of_year_rep;


} }
# 16 "/usr/include/boost/date_time/gregorian/greg_calendar.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/gregorian_calendar.hpp" 1 3 4
# 14 "/usr/include/boost/date_time/gregorian_calendar.hpp" 3 4
namespace boost {
namespace date_time {
# 28 "/usr/include/boost/date_time/gregorian_calendar.hpp" 3 4
  template<typename ymd_type_, typename date_int_type_>
  class __attribute__((__visibility__("default"))) gregorian_calendar_base {
  public:

    typedef ymd_type_ ymd_type;

    typedef typename ymd_type::month_type month_type;

    typedef typename ymd_type::day_type day_type;

    typedef typename ymd_type::year_type year_type;

    typedef date_int_type_ date_int_type;


    static constexpr unsigned short day_of_week(const ymd_type& ymd);
    static constexpr int week_number(const ymd_type&ymd);
    static constexpr date_int_type day_number(const ymd_type& ymd);
    static constexpr date_int_type julian_day_number(const ymd_type& ymd);
    static constexpr date_int_type modjulian_day_number(const ymd_type& ymd);
    static constexpr ymd_type from_day_number(date_int_type);
    static constexpr ymd_type from_julian_day_number(date_int_type);
    static constexpr ymd_type from_modjulian_day_number(date_int_type);
    static constexpr bool is_leap_year(year_type);
    static constexpr unsigned short end_of_month_day(year_type y, month_type m);
    static constexpr ymd_type epoch();
    static constexpr unsigned short days_in_week();

  };



} }

# 1 "/usr/include/boost/date_time/gregorian_calendar.ipp" 1 3 4
# 10 "/usr/include/boost/date_time/gregorian_calendar.ipp" 3 4
namespace boost {
namespace date_time {



  template<typename ymd_type_, typename date_int_type_>
  constexpr
  inline
  unsigned short
  gregorian_calendar_base<ymd_type_,date_int_type_>::day_of_week(const ymd_type& ymd) {
    unsigned short a = static_cast<unsigned short>((14-ymd.month)/12);
    unsigned short y = static_cast<unsigned short>(ymd.year - a);
    unsigned short m = static_cast<unsigned short>(ymd.month + 12*a - 2);
    unsigned short d = static_cast<unsigned short>((ymd.day + y + (y/4) - (y/100) + (y/400) + (31*m)/12) % 7);

    return d;
  }







  template<typename ymd_type_, typename date_int_type_>
  constexpr
  inline
  int
  gregorian_calendar_base<ymd_type_,date_int_type_>::week_number(const ymd_type& ymd) {
    unsigned long julianbegin = julian_day_number(ymd_type(ymd.year,1,1));
    unsigned long juliantoday = julian_day_number(ymd);
    unsigned long day = (julianbegin + 3) % 7;
    unsigned long week = (juliantoday + day - julianbegin + 4)/7;

    if ((week >= 1) && (week <= 52)) {
      return static_cast<int>(week);
    }

    if (week == 53) {
      if((day==6) ||(day == 5 && is_leap_year(ymd.year))) {
        return static_cast<int>(week);
      } else {
        return 1;
      }
    }

    else if (week == 0) {
      julianbegin = julian_day_number(ymd_type(static_cast<unsigned short>(ymd.year-1),1,1));
      juliantoday = julian_day_number(ymd);
      day = (julianbegin + 3) % 7;
      week = (juliantoday + day - julianbegin + 4)/7;
      return static_cast<int>(week);
    }

    return static_cast<int>(week);

  }




  template<typename ymd_type_, typename date_int_type_>
  constexpr
  inline
  date_int_type_
  gregorian_calendar_base<ymd_type_,date_int_type_>::day_number(const ymd_type& ymd)
  {
    unsigned short a = static_cast<unsigned short>((14-ymd.month)/12);
    unsigned short y = static_cast<unsigned short>(ymd.year + 4800 - a);
    unsigned short m = static_cast<unsigned short>(ymd.month + 12*a - 3);
    unsigned long d = static_cast<unsigned long>(ymd.day) + ((153*m + 2)/5) + 365*y + (y/4) - (y/100) + (y/400) - 32045;
    return static_cast<date_int_type>(d);
  }




  template<typename ymd_type_, typename date_int_type_>
  constexpr
  inline
  date_int_type_
  gregorian_calendar_base<ymd_type_,date_int_type_>::julian_day_number(const ymd_type& ymd)
  {
    return day_number(ymd);
  }





  template<typename ymd_type_, typename date_int_type_>
  constexpr
  inline
  date_int_type_
  gregorian_calendar_base<ymd_type_,date_int_type_>::modjulian_day_number(const ymd_type& ymd)
  {
    return julian_day_number(ymd)-2400001;
  }


  template<typename ymd_type_, typename date_int_type_>
  constexpr
  inline
  ymd_type_
  gregorian_calendar_base<ymd_type_,date_int_type_>::from_day_number(date_int_type dayNumber)
  {
    date_int_type a = dayNumber + 32044;
    date_int_type b = (4*a + 3)/146097;
    date_int_type c = a-((146097*b)/4);
    date_int_type d = (4*c + 3)/1461;
    date_int_type e = c - (1461*d)/4;
    date_int_type m = (5*e + 2)/153;
    unsigned short day = static_cast<unsigned short>(e - ((153*m + 2)/5) + 1);
    unsigned short month = static_cast<unsigned short>(m + 3 - 12 * (m/10));
    year_type year = static_cast<unsigned short>(100*b + d - 4800 + (m/10));


    return ymd_type(static_cast<unsigned short>(year),month,day);
  }


  template<typename ymd_type_, typename date_int_type_>
  constexpr
  inline
  ymd_type_
  gregorian_calendar_base<ymd_type_,date_int_type_>::from_julian_day_number(date_int_type dayNumber)
  {
    date_int_type a = dayNumber + 32044;
    date_int_type b = (4*a+3)/146097;
    date_int_type c = a - ((146097*b)/4);
    date_int_type d = (4*c + 3)/1461;
    date_int_type e = c - ((1461*d)/4);
    date_int_type m = (5*e + 2)/153;
    unsigned short day = static_cast<unsigned short>(e - ((153*m + 2)/5) + 1);
    unsigned short month = static_cast<unsigned short>(m + 3 - 12 * (m/10));
    year_type year = static_cast<year_type>(100*b + d - 4800 + (m/10));


    return ymd_type(year,month,day);
  }


  template<typename ymd_type_, typename date_int_type_>
  constexpr
  inline
  ymd_type_
  gregorian_calendar_base<ymd_type_,date_int_type_>::from_modjulian_day_number(date_int_type dayNumber) {
    date_int_type jd = dayNumber + 2400001;
    return from_julian_day_number(jd);
  }





  template<typename ymd_type_, typename date_int_type_>
  constexpr
  inline
  bool
  gregorian_calendar_base<ymd_type_,date_int_type_>::is_leap_year(year_type year)
  {

    return (!(year % 4)) && ((year % 100) || (!(year % 400)));
  }





  template<typename ymd_type_, typename date_int_type_>
  constexpr
  inline
  unsigned short
  gregorian_calendar_base<ymd_type_,date_int_type_>::end_of_month_day(year_type year,
                                                                      month_type month)
  {
    switch (month) {
    case 2:
      if (is_leap_year(year)) {
        return 29;
      } else {
        return 28;
      }
    case 4:
    case 6:
    case 9:
    case 11:
      return 30;
    default:
      return 31;
    }
  }


  template<typename ymd_type_, typename date_int_type_>
  constexpr
  inline
  ymd_type_
  gregorian_calendar_base<ymd_type_,date_int_type_>::epoch()
  {
    return ymd_type(1400,1,1);
  }


  template<typename ymd_type_, typename date_int_type_>
  constexpr
  inline
  unsigned short
  gregorian_calendar_base<ymd_type_,date_int_type_>::days_in_week()
  {
    return 7;
  }


} }
# 63 "/usr/include/boost/date_time/gregorian_calendar.hpp" 2 3 4
# 17 "/usr/include/boost/date_time/gregorian/greg_calendar.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/gregorian/greg_ymd.hpp" 1 3 4
# 14 "/usr/include/boost/date_time/gregorian/greg_ymd.hpp" 3 4
# 1 "/usr/include/boost/date_time/gregorian/greg_day.hpp" 1 3 4
# 17 "/usr/include/boost/date_time/gregorian/greg_day.hpp" 3 4
namespace boost {
namespace gregorian {


  struct __attribute__((__visibility__("default"))) bad_day_of_month : public std::out_of_range
  {
    bad_day_of_month() :
      std::out_of_range(std::string("Day of month value is out of range 1..31"))
    {}

    bad_day_of_month(const std::string& s) :
      std::out_of_range(s)
    {}
  };

  typedef CV::simple_exception_policy<unsigned short, 1, 31, bad_day_of_month> greg_day_policies;


  typedef CV::constrained_value<greg_day_policies> greg_day_rep;







  class __attribute__((__visibility__("default"))) greg_day : public greg_day_rep {
  public:
    constexpr greg_day(value_type day_of_month) : greg_day_rep(day_of_month) {}
    constexpr value_type as_number() const {return value_;}
    constexpr operator value_type() const {return value_;}
  private:

  };



} }
# 15 "/usr/include/boost/date_time/gregorian/greg_ymd.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/gregorian/greg_year.hpp" 1 3 4
# 17 "/usr/include/boost/date_time/gregorian/greg_year.hpp" 3 4
namespace boost {
namespace gregorian {


  struct __attribute__((__visibility__("default"))) bad_year : public std::out_of_range
  {
    bad_year() :
      std::out_of_range(std::string("Year is out of valid range: 1400..9999"))
    {}
  };

  typedef CV::simple_exception_policy<unsigned short, 1400, 9999, bad_year> greg_year_policies;


  typedef CV::constrained_value<greg_year_policies> greg_year_rep;
# 40 "/usr/include/boost/date_time/gregorian/greg_year.hpp" 3 4
  class __attribute__((__visibility__("default"))) greg_year : public greg_year_rep {
  public:
    constexpr greg_year(value_type year) : greg_year_rep(year) {}
    constexpr operator value_type() const {return value_;}
  };



} }
# 16 "/usr/include/boost/date_time/gregorian/greg_ymd.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/gregorian/greg_month.hpp" 1 3 4
# 18 "/usr/include/boost/date_time/gregorian/greg_month.hpp" 3 4
namespace boost {
namespace gregorian {

  typedef date_time::months_of_year months_of_year;


  using date_time::Jan;
  using date_time::Feb;
  using date_time::Mar;
  using date_time::Apr;
  using date_time::May;
  using date_time::Jun;
  using date_time::Jul;
  using date_time::Aug;
  using date_time::Sep;
  using date_time::Oct;
  using date_time::Nov;
  using date_time::Dec;
  using date_time::NotAMonth;
  using date_time::NumMonths;


  struct __attribute__((__visibility__("default"))) bad_month : public std::out_of_range
  {
    bad_month() : std::out_of_range(std::string("Month number is out of range 1..12")) {}
  };

  typedef CV::simple_exception_policy<unsigned short, 1, 12, bad_month> greg_month_policies;

  typedef CV::constrained_value<greg_month_policies> greg_month_rep;



  class __attribute__((__visibility__("default"))) greg_month : public greg_month_rep {
  public:
    typedef date_time::months_of_year month_enum;


    constexpr greg_month(month_enum theMonth) :
      greg_month_rep(static_cast<greg_month_rep::value_type>(theMonth)) {}

    constexpr greg_month(value_type theMonth) : greg_month_rep(theMonth) {}

    constexpr operator value_type() const {return value_;}

    constexpr value_type as_number() const {return value_;}
    constexpr month_enum as_enum() const {return static_cast<month_enum>(value_);}


    const char*
    as_short_string() const
    {
      static const char* const short_month_names[NumMonths]
        = {"Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec", "NAM"};
      return short_month_names[value_-1];
    }


    const char*
    as_long_string() const
    {
      static const char* const long_month_names[NumMonths]
        = {"January","February","March","April","May","June","July","August",
           "September","October","November","December","NotAMonth"};
      return long_month_names[value_-1];
    }




    const wchar_t*
    as_short_wstring() const
    {
      static const wchar_t* const w_short_month_names[NumMonths]
        = {L"Jan",L"Feb",L"Mar",L"Apr",L"May",L"Jun",L"Jul",L"Aug",L"Sep",L"Oct",
           L"Nov",L"Dec",L"NAM"};
      return w_short_month_names[value_-1];
    }


    const wchar_t*
    as_long_wstring() const
    {
      static const wchar_t* const w_long_month_names[NumMonths]
        = {L"January",L"February",L"March",L"April",L"May",L"June",L"July",L"August",
           L"September",L"October",L"November",L"December",L"NotAMonth"};
      return w_long_month_names[value_-1];
    }





    const char* as_short_string(char) const
    {
      return as_short_string();
    }
    const char* as_long_string(char) const
    {
      return as_long_string();
    }

    const wchar_t* as_short_string(wchar_t) const
    {
      return as_short_wstring();
    }
    const wchar_t* as_long_string(wchar_t) const
    {
      return as_long_wstring();
    }

  };

} }
# 17 "/usr/include/boost/date_time/gregorian/greg_ymd.hpp" 2 3 4

namespace boost {
namespace gregorian {

  typedef date_time::year_month_day_base<greg_year,
                                         greg_month,
                                         greg_day> greg_year_month_day;



} }
# 18 "/usr/include/boost/date_time/gregorian/greg_calendar.hpp" 2 3 4


namespace boost {
namespace gregorian {


  typedef date_time::int_adapter<uint32_t> fancy_date_rep;


  class __attribute__((__visibility__("default"))) gregorian_calendar :
    public date_time::gregorian_calendar_base<greg_year_month_day, fancy_date_rep::int_type> {
  public:

    typedef greg_weekday day_of_week_type;

    typedef greg_day_of_year_rep day_of_year_type;

    typedef fancy_date_rep date_rep_type;

    typedef fancy_date_rep date_traits_type;


  private:
  };

} }
# 20 "/usr/include/boost/date_time/gregorian/gregorian_types.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/gregorian/greg_duration.hpp" 1 3 4
# 13 "/usr/include/boost/date_time/gregorian/greg_duration.hpp" 3 4
# 1 "/usr/include/boost/date_time/date_duration.hpp" 1 3 4
# 18 "/usr/include/boost/date_time/date_duration.hpp" 3 4
namespace boost {
namespace date_time {



  template<class duration_rep_traits>
  class __attribute__((__visibility__("default"))) date_duration : private
              boost::less_than_comparable1< date_duration< duration_rep_traits >
            , boost::equality_comparable1< date_duration< duration_rep_traits >
            , boost::addable1< date_duration< duration_rep_traits >
            , boost::subtractable1< date_duration< duration_rep_traits >
            , boost::dividable2< date_duration< duration_rep_traits >, int
            > > > > >
  {
  public:
    typedef typename duration_rep_traits::int_type duration_rep_type;
    typedef typename duration_rep_traits::impl_type duration_rep;


    constexpr explicit date_duration(duration_rep day_count) : days_(day_count) {}



    constexpr date_duration(special_values sv) :
            days_(duration_rep::from_special(sv))
    {}


    constexpr duration_rep get_rep()const
    {
        return days_;
    }
    constexpr special_values as_special() const
    {
        return days_.as_special();
    }
    constexpr bool is_special()const
    {
        return days_.is_special();
    }

    constexpr duration_rep_type days() const
    {
        return duration_rep_traits::as_number(days_);
    }

    static constexpr date_duration unit()
    {
        return date_duration<duration_rep_traits>(1);
    }

    constexpr bool operator==(const date_duration& rhs) const
    {
        return days_ == rhs.days_;
    }

    constexpr bool operator<(const date_duration& rhs) const
    {
        return days_ < rhs.days_;
    }







    constexpr date_duration& operator-=(const date_duration& rhs)
    {

        days_ = days_ - rhs.days_;
        return *this;
    }

    constexpr date_duration& operator+=(const date_duration& rhs)
    {
        days_ = days_ + rhs.days_;
        return *this;
    }


    constexpr date_duration operator-() const
    {
        return date_duration<duration_rep_traits>(get_rep() * (-1));
    }

    constexpr date_duration& operator/=(int divisor)
    {
        days_ = days_ / divisor;
        return *this;
    }


    constexpr bool is_negative() const
    {
        return days_ < 0;
    }

  private:
    duration_rep days_;
  };





  struct __attribute__((__visibility__("default"))) duration_traits_long
  {
    typedef long int_type;
    typedef long impl_type;
    static constexpr int_type as_number(impl_type i) { return i; }
  };




  struct __attribute__((__visibility__("default"))) duration_traits_adapted
  {
    typedef long int_type;
    typedef boost::date_time::int_adapter<long> impl_type;
    static constexpr int_type as_number(impl_type i) { return i.as_number(); }
  };


} }
# 14 "/usr/include/boost/date_time/gregorian/greg_duration.hpp" 2 3 4



namespace boost {
namespace gregorian {


  typedef boost::date_time::duration_traits_adapted date_duration_rep;




  class __attribute__((__visibility__("default"))) date_duration :
    public boost::date_time::date_duration< date_duration_rep >
  {
    typedef boost::date_time::date_duration< date_duration_rep > base_type;

  public:
    typedef base_type::duration_rep duration_rep;


    constexpr explicit
    date_duration(duration_rep day_count = 0) : base_type(day_count) {}


    constexpr
    date_duration(date_time::special_values sv) : base_type(sv) {}


    constexpr
    date_duration(const base_type& other) : base_type(other)
    {}





    constexpr bool operator== (const date_duration& rhs) const
    {
      return base_type::operator== (rhs);
    }
    constexpr bool operator!= (const date_duration& rhs) const
    {
      return !operator== (rhs);
    }
    constexpr bool operator< (const date_duration& rhs) const
    {
      return base_type::operator< (rhs);
    }
    constexpr bool operator> (const date_duration& rhs) const
    {
      return !(base_type::operator< (rhs) || base_type::operator== (rhs));
    }
    constexpr bool operator<= (const date_duration& rhs) const
    {
      return (base_type::operator< (rhs) || base_type::operator== (rhs));
    }
    constexpr bool operator>= (const date_duration& rhs) const
    {
      return !base_type::operator< (rhs);
    }


    constexpr date_duration& operator-= (const date_duration& rhs)
    {
      base_type::operator-= (rhs);
      return *this;
    }

    constexpr friend
    date_duration operator- (date_duration rhs, date_duration const& lhs);


    constexpr date_duration& operator+= (const date_duration& rhs)
    {
      base_type::operator+= (rhs);
      return *this;
    }

    constexpr friend
    date_duration operator+ (date_duration rhs, date_duration const& lhs);


    constexpr date_duration operator- ()const
    {
      return date_duration(get_rep() * (-1));
    }


    constexpr date_duration& operator/= (int divisor)
    {
      base_type::operator/= (divisor);
      return *this;
    }

    constexpr friend date_duration operator/ (date_duration rhs, int lhs);


    static constexpr date_duration unit()
    {
      return date_duration(base_type::unit().get_rep());
    }
  };

  inline constexpr
  date_duration operator- (date_duration rhs, date_duration const& lhs)
    {
      rhs -= lhs;
      return rhs;
    }

  inline constexpr
  date_duration operator+ (date_duration rhs, date_duration const& lhs)
    {
      rhs += lhs;
      return rhs;
    }

  inline constexpr date_duration operator/ (date_duration rhs, int lhs)
    {
      rhs /= lhs;
      return rhs;
    }


  typedef date_duration days;

} }


# 1 "/usr/include/boost/date_time/date_duration_types.hpp" 1 3 4
# 17 "/usr/include/boost/date_time/date_duration_types.hpp" 3 4
namespace boost {
namespace date_time {



  template <class duration_config>
  class __attribute__((__visibility__("default"))) weeks_duration : public date_duration<duration_config> {
  public:
    constexpr weeks_duration(typename duration_config::impl_type w)
      : date_duration<duration_config>(w * 7) {}
    constexpr weeks_duration(special_values sv)
      : date_duration<duration_config>(sv) {}
  };


  template<class t>
  class __attribute__((__visibility__("default"))) years_duration;






  template<class base_config>
  class __attribute__((__visibility__("default"))) months_duration
  {
    private:
      typedef typename base_config::int_rep int_rep;
      typedef typename int_rep::int_type int_type;
      typedef typename base_config::date_type date_type;
      typedef typename date_type::duration_type duration_type;
      typedef typename base_config::month_adjustor_type month_adjustor_type;
      typedef months_duration<base_config> months_type;
      typedef years_duration<base_config> years_type;
    public:
      constexpr months_duration(int_rep num) : _m(num) {}
      constexpr months_duration(special_values sv) : _m(sv)
      {
        _m = int_rep::from_special(sv);
      }
      int_rep number_of_months() const { return _m; }

      constexpr duration_type get_neg_offset(const date_type& d) const
      {
        month_adjustor_type m_adj(_m.as_number());
        return duration_type(m_adj.get_neg_offset(d));
      }
      constexpr duration_type get_offset(const date_type& d) const
      {
        month_adjustor_type m_adj(_m.as_number());
        return duration_type(m_adj.get_offset(d));
      }
      constexpr bool operator==(const months_type& rhs) const
      {
        return(_m == rhs._m);
      }
      constexpr bool operator!=(const months_type& rhs) const
      {
        return(_m != rhs._m);
      }
      constexpr months_type operator+(const months_type& rhs)const
      {
        return months_type(_m + rhs._m);
      }
      constexpr months_type& operator+=(const months_type& rhs)
      {
        _m = _m + rhs._m;
        return *this;
      }
      constexpr months_type operator-(const months_type& rhs)const
      {
        return months_type(_m - rhs._m);
      }
      constexpr months_type& operator-=(const months_type& rhs)
      {
        _m = _m - rhs._m;
        return *this;
      }
      constexpr months_type operator*(const int_type rhs)const
      {
        return months_type(_m * rhs);
      }
      constexpr months_type& operator*=(const int_type rhs)
      {
        _m = _m * rhs;
        return *this;
      }
      constexpr months_type operator/(const int_type rhs)const
      {
        return months_type(_m / rhs);
      }
      constexpr months_type& operator/=(const int_type rhs)
      {
        _m = _m / rhs;
        return *this;
      }
      constexpr months_type operator+(const years_type& y)const
      {
        return months_type(y.number_of_years() * 12 + _m);
      }
      constexpr months_type& operator+=(const years_type& y)
      {
        _m = y.number_of_years() * 12 + _m;
        return *this;
      }
      constexpr months_type operator-(const years_type& y) const
      {
        return months_type(_m - y.number_of_years() * 12);
      }
      constexpr months_type& operator-=(const years_type& y)
      {
        _m = _m - y.number_of_years() * 12;
        return *this;
      }

      constexpr friend date_type operator+(const date_type& d, const months_type& m)
      {
        return d + m.get_offset(d);
      }
      constexpr friend date_type operator+=(date_type& d, const months_type& m)
      {
        return d += m.get_offset(d);
      }
      constexpr friend date_type operator-(const date_type& d, const months_type& m)
      {

        return d + m.get_neg_offset(d);
      }
      constexpr friend date_type operator-=(date_type& d, const months_type& m)
      {

        return d += m.get_neg_offset(d);
      }
    private:
      int_rep _m;
  };







  template<class base_config>
  class __attribute__((__visibility__("default"))) years_duration
  {
    private:
      typedef typename base_config::int_rep int_rep;
      typedef typename int_rep::int_type int_type;
      typedef typename base_config::date_type date_type;
      typedef typename date_type::duration_type duration_type;
      typedef typename base_config::month_adjustor_type month_adjustor_type;
      typedef years_duration<base_config> years_type;
      typedef months_duration<base_config> months_type;
    public:
      constexpr years_duration(int_rep num) : _y(num) {}
      constexpr years_duration(special_values sv) : _y(sv)
      {
        _y = int_rep::from_special(sv);
      }
      constexpr int_rep number_of_years() const { return _y; }

      constexpr duration_type get_neg_offset(const date_type& d) const
      {
        month_adjustor_type m_adj(_y.as_number() * 12);
        return duration_type(m_adj.get_neg_offset(d));
      }
      constexpr duration_type get_offset(const date_type& d) const
      {
        month_adjustor_type m_adj(_y.as_number() * 12);
        return duration_type(m_adj.get_offset(d));
      }
      constexpr bool operator==(const years_type& rhs) const
      {
        return(_y == rhs._y);
      }
      bool operator!=(const years_type& rhs) const
      {
        return(_y != rhs._y);
      }
      constexpr years_type operator+(const years_type& rhs)const
      {
        return years_type(_y + rhs._y);
      }
      constexpr years_type& operator+=(const years_type& rhs)
      {
        _y = _y + rhs._y;
        return *this;
      }
      constexpr years_type operator-(const years_type& rhs)const
      {
        return years_type(_y - rhs._y);
      }
      constexpr years_type& operator-=(const years_type& rhs)
      {
        _y = _y - rhs._y;
        return *this;
      }
      constexpr years_type operator*(const int_type rhs)const
      {
        return years_type(_y * rhs);
      }
      constexpr years_type& operator*=(const int_type rhs)
      {
        _y = _y * rhs;
        return *this;
      }
      constexpr years_type operator/(const int_type rhs)const
      {
        return years_type(_y / rhs);
      }
      constexpr years_type& operator/=(const int_type rhs)
      {
        _y = _y / rhs;
        return *this;
      }
      constexpr months_type operator+(const months_type& m) const
      {
        return(months_type(_y * 12 + m.number_of_months()));
      }
      constexpr months_type operator-(const months_type& m) const
      {
        return(months_type(_y * 12 - m.number_of_months()));
      }

      constexpr friend date_type operator+(const date_type& d, const years_type& y)
      {
        return d + y.get_offset(d);
      }
      constexpr friend date_type operator+=(date_type& d, const years_type& y)
      {
        return d += y.get_offset(d);
      }
      constexpr friend date_type operator-(const date_type& d, const years_type& y)
      {

        return d + y.get_neg_offset(d);
      }
      constexpr friend date_type operator-=(date_type& d, const years_type& y)
      {

        return d += y.get_neg_offset(d);
      }
    private:
      int_rep _y;
  };
}}
# 145 "/usr/include/boost/date_time/gregorian/greg_duration.hpp" 2 3 4
# 21 "/usr/include/boost/date_time/gregorian/gregorian_types.hpp" 2 3 4

# 1 "/usr/include/boost/date_time/gregorian/greg_duration_types.hpp" 1 3 4
# 13 "/usr/include/boost/date_time/gregorian/greg_duration_types.hpp" 3 4
# 1 "/usr/include/boost/date_time/gregorian/greg_date.hpp" 1 3 4
# 19 "/usr/include/boost/date_time/gregorian/greg_date.hpp" 3 4
namespace boost {
namespace gregorian {


  using date_time::special_values;
  using date_time::not_special;
  using date_time::neg_infin;
  using date_time::pos_infin;
  using date_time::not_a_date_time;
  using date_time::max_date_time;
  using date_time::min_date_time;
# 38 "/usr/include/boost/date_time/gregorian/greg_date.hpp" 3 4
  class __attribute__((__visibility__("default"))) date : public date_time::date<date, gregorian_calendar, date_duration>
  {
   public:
    typedef gregorian_calendar::year_type year_type;
    typedef gregorian_calendar::month_type month_type;
    typedef gregorian_calendar::day_type day_type;
    typedef gregorian_calendar::day_of_year_type day_of_year_type;
    typedef gregorian_calendar::ymd_type ymd_type;
    typedef gregorian_calendar::date_rep_type date_rep_type;
    typedef gregorian_calendar::date_int_type date_int_type;
    typedef date_duration duration_type;


    constexpr date():
      date_time::date<date, gregorian_calendar, date_duration>(date_rep_type::from_special(not_a_date_time))
    {}


    constexpr date(year_type y, month_type m, day_type d)
      : date_time::date<date, gregorian_calendar, date_duration>(y, m, d)
    {
      if (gregorian_calendar::end_of_month_day(y, m) < d) {
        boost::throw_exception(bad_day_of_month(std::string("Day of month is not valid for year")));
      }
    }

    constexpr explicit date(const ymd_type& ymd)
      : date_time::date<date, gregorian_calendar, date_duration>(ymd)
    {}

    constexpr explicit date(const date_int_type& rhs):
      date_time::date<date,gregorian_calendar, date_duration>(rhs)
    {}

    constexpr explicit date(date_rep_type rhs):
      date_time::date<date,gregorian_calendar, date_duration>(rhs)
    {}

    constexpr explicit date(special_values sv):
      date_time::date<date, gregorian_calendar, date_duration>(from_special_adjusted(sv))
    {}

    constexpr date_int_type julian_day() const
    {
      ymd_type ymd = year_month_day();
      return gregorian_calendar::julian_day_number(ymd);
    }

    constexpr day_of_year_type day_of_year() const
    {
      date start_of_year(year(), 1, 1);
      unsigned short doy = static_cast<unsigned short>((*this-start_of_year).days() + 1);
      return day_of_year_type(doy);
    }

    constexpr date_int_type modjulian_day() const
    {
      ymd_type ymd = year_month_day();
      return gregorian_calendar::modjulian_day_number(ymd);
    }

    constexpr int week_number() const
    {
      ymd_type ymd = year_month_day();
      return gregorian_calendar::week_number(ymd);
    }

    constexpr date_int_type day_number() const
    {
      return days_;
    }

    constexpr date end_of_month() const
    {
      ymd_type ymd = year_month_day();
      unsigned short eom_day = gregorian_calendar::end_of_month_day(ymd.year, ymd.month);
      return date(ymd.year, ymd.month, eom_day);
    }

    friend constexpr
    bool operator==(const date& lhs, const date& rhs);

   private:

    constexpr date_rep_type from_special_adjusted(special_values sv)
    {
      switch (sv)
      {
        case min_date_time: return gregorian_calendar::day_number(ymd_type(1400, 1, 1));
        case max_date_time: return gregorian_calendar::day_number(ymd_type(9999, 12, 31));
        default: return date_rep_type::from_special(sv);
      }
    }
  };

  inline constexpr
  bool operator==(const date& lhs, const date& rhs)
  {
    return lhs.days_ == rhs.days_;
  }


} }
# 14 "/usr/include/boost/date_time/gregorian/greg_duration_types.hpp" 2 3 4

# 1 "/usr/include/boost/date_time/adjust_functors.hpp" 1 3 4
# 13 "/usr/include/boost/date_time/adjust_functors.hpp" 3 4
# 1 "/usr/include/boost/date_time/wrapping_int.hpp" 1 3 4
# 14 "/usr/include/boost/date_time/wrapping_int.hpp" 3 4
namespace boost {
namespace date_time {
# 31 "/usr/include/boost/date_time/wrapping_int.hpp" 3 4
template<typename int_type_, int_type_ wrap_val>
class wrapping_int {
public:
  typedef int_type_ int_type;

  static constexpr int_type wrap_value() {return wrap_val;}

  constexpr wrapping_int(int_type v) : value_(v) {}

  constexpr int_type as_int() const {return value_;}
  constexpr operator int_type() const {return value_;}





  template< typename IntT >
  constexpr IntT add(IntT v)
  {
    int_type remainder = static_cast<int_type>(v % (wrap_val));
    IntT overflow = static_cast<IntT>(v / (wrap_val));
    value_ = static_cast<int_type>(value_ + remainder);
    return calculate_wrap(overflow);
  }






  template< typename IntT >
  constexpr IntT subtract(IntT v)
  {
    int_type remainder = static_cast<int_type>(v % (wrap_val));
    IntT underflow = static_cast<IntT>(-(v / (wrap_val)));
    value_ = static_cast<int_type>(value_ - remainder);
    return calculate_wrap(underflow) * -1;
  }
private:
  int_type value_;

  template< typename IntT >
  constexpr IntT calculate_wrap(IntT wrap)
  {
    if ((value_) >= wrap_val)
    {
      ++wrap;
      value_ -= (wrap_val);
    }
    else if(value_ < 0)
    {
      --wrap;
      value_ += (wrap_val);
    }
    return wrap;
  }

};






template<typename int_type_, int_type_ wrap_min, int_type_ wrap_max>
class wrapping_int2 {
public:
  typedef int_type_ int_type;
  static constexpr int_type wrap_value() {return wrap_max;}
  static constexpr int_type min_value() {return wrap_min;}


  constexpr wrapping_int2(int_type v) : value_(v) {
    if(value_ < wrap_min)
    {
      value_ = wrap_min;
    }
    if(value_ > wrap_max)
    {
      value_ = wrap_max;
    }
  }

  constexpr int_type as_int() const {return value_;}
  constexpr operator int_type() const {return value_;}





  template< typename IntT >
  constexpr IntT add(IntT v)
  {
    int_type remainder = static_cast<int_type>(v % (wrap_max - wrap_min + 1));
    IntT overflow = static_cast<IntT>(v / (wrap_max - wrap_min + 1));
    value_ = static_cast<int_type>(value_ + remainder);
    return calculate_wrap(overflow);
  }





  template< typename IntT >
  constexpr IntT subtract(IntT v)
  {
    int_type remainder = static_cast<int_type>(v % (wrap_max - wrap_min + 1));
    IntT underflow = static_cast<IntT>(-(v / (wrap_max - wrap_min + 1)));
    value_ = static_cast<int_type>(value_ - remainder);
    return calculate_wrap(underflow);
  }

private:
  int_type value_;

  template< typename IntT >
  constexpr IntT calculate_wrap(IntT wrap)
  {
    if ((value_) > wrap_max)
    {
      ++wrap;
      value_ -= (wrap_max - wrap_min + 1);
    }
    else if((value_) < wrap_min)
    {
      --wrap;
      value_ += (wrap_max - wrap_min + 1);
    }
    return wrap;
  }
};



} }
# 14 "/usr/include/boost/date_time/adjust_functors.hpp" 2 3 4

namespace boost {
namespace date_time {



  template<class date_type>
  class day_functor
  {
  public:
    typedef typename date_type::duration_type duration_type;
    day_functor(int f) : f_(f) {}
    duration_type get_offset(const date_type&) const
    {
      return duration_type(f_);
    }
    duration_type get_neg_offset(const date_type&) const
    {
      return duration_type(-f_);
    }
  private:
    int f_;
  };
# 48 "/usr/include/boost/date_time/adjust_functors.hpp" 3 4
  template<class date_type>
  class month_functor
  {
  public:
    typedef typename date_type::duration_type duration_type;
    typedef typename date_type::calendar_type cal_type;
    typedef typename cal_type::ymd_type ymd_type;
    typedef typename cal_type::day_type day_type;

    month_functor(int f) : f_(f), origDayOfMonth_(0) {}
    duration_type get_offset(const date_type& d) const
    {
      ymd_type ymd(d.year_month_day());
      if (origDayOfMonth_ == 0) {
        origDayOfMonth_ = ymd.day;
        day_type endOfMonthDay(cal_type::end_of_month_day(ymd.year,ymd.month));
        if (endOfMonthDay == ymd.day) {
          origDayOfMonth_ = -1;
        }
      }
      typedef date_time::wrapping_int2<short,1,12> wrap_int2;
      wrap_int2 wi(ymd.month);

      const typename ymd_type::year_type year(static_cast<typename ymd_type::year_type::value_type>(ymd.year + wi.add(f_)));



      day_type resultingEndOfMonthDay(cal_type::end_of_month_day(year, wi.as_int()));

      if (origDayOfMonth_ == -1) {
        return date_type(year, wi.as_int(), resultingEndOfMonthDay) - d;
      }
      day_type dayOfMonth = origDayOfMonth_;
      if (dayOfMonth > resultingEndOfMonthDay) {
        dayOfMonth = resultingEndOfMonthDay;
      }
      return date_type(year, wi.as_int(), dayOfMonth) - d;
    }

    duration_type get_neg_offset(const date_type& d) const
    {
      ymd_type ymd(d.year_month_day());
      if (origDayOfMonth_ == 0) {
        origDayOfMonth_ = ymd.day;
        day_type endOfMonthDay(cal_type::end_of_month_day(ymd.year,ymd.month));
        if (endOfMonthDay == ymd.day) {
          origDayOfMonth_ = -1;
        }
      }
      typedef date_time::wrapping_int2<short,1,12> wrap_int2;
      wrap_int2 wi(ymd.month);

      const typename ymd_type::year_type year(static_cast<typename ymd_type::year_type::value_type>(ymd.year + wi.subtract(f_)));

      day_type resultingEndOfMonthDay(cal_type::end_of_month_day(year, wi.as_int()));

      if (origDayOfMonth_ == -1) {
        return date_type(year, wi.as_int(), resultingEndOfMonthDay) - d;
      }
      day_type dayOfMonth = origDayOfMonth_;
      if (dayOfMonth > resultingEndOfMonthDay) {
        dayOfMonth = resultingEndOfMonthDay;
      }
      return date_type(year, wi.as_int(), dayOfMonth) - d;
    }
  private:
    int f_;
    mutable short origDayOfMonth_;
  };



  template<class date_type>
  class week_functor
  {
  public:
    typedef typename date_type::duration_type duration_type;
    typedef typename date_type::calendar_type calendar_type;
    week_functor(int f) : f_(f) {}
    duration_type get_offset(const date_type&) const
    {
      return duration_type(f_*static_cast<int>(calendar_type::days_in_week()));
    }
    duration_type get_neg_offset(const date_type&) const
    {
      return duration_type(-f_*static_cast<int>(calendar_type::days_in_week()));
    }
  private:
    int f_;
  };


  template<class date_type>
  class year_functor
  {
  public:

    typedef typename date_type::duration_type duration_type;
    year_functor(int f) : _mf(f * 12) {}
    duration_type get_offset(const date_type& d) const
    {
      return _mf.get_offset(d);
    }
    duration_type get_neg_offset(const date_type& d) const
    {
      return _mf.get_neg_offset(d);
    }
  private:
    month_functor<date_type> _mf;
  };


} }
# 16 "/usr/include/boost/date_time/gregorian/greg_duration_types.hpp" 2 3 4



namespace boost {
namespace gregorian {


  struct __attribute__((__visibility__("default"))) greg_durations_config {
    typedef date date_type;
    typedef date_time::int_adapter<int> int_rep;
    typedef date_time::month_functor<date_type> month_adjustor_type;
  };

  typedef date_time::months_duration<greg_durations_config> months;
  typedef date_time::years_duration<greg_durations_config> years;

  class __attribute__((__visibility__("default"))) weeks_duration : public date_duration {
  public:
    constexpr weeks_duration(duration_rep w)
      : date_duration(w * 7) {}
    constexpr weeks_duration(date_time::special_values sv)
      : date_duration(sv) {}
  };

  typedef weeks_duration weeks;

}}
# 23 "/usr/include/boost/date_time/gregorian/gregorian_types.hpp" 2 3 4


# 1 "/usr/include/boost/date_time/date_generators.hpp" 1 3 4
# 22 "/usr/include/boost/date_time/date_generators.hpp" 3 4
namespace boost {
namespace date_time {







  template<class date_type>
  class year_based_generator
  {
  public:
    typedef typename date_type::calendar_type calendar_type;
    typedef typename calendar_type::year_type year_type;
    year_based_generator() {}
    virtual ~year_based_generator() {}
    virtual date_type get_date(year_type y) const = 0;

    virtual std::string to_string() const = 0;
  };
# 55 "/usr/include/boost/date_time/date_generators.hpp" 3 4
  template<class date_type>
 class partial_date : public year_based_generator<date_type>
 {
 public:
   typedef typename date_type::calendar_type calendar_type;
   typedef typename calendar_type::day_type day_type;
   typedef typename calendar_type::month_type month_type;
   typedef typename calendar_type::year_type year_type;
   typedef typename date_type::duration_type duration_type;
   typedef typename duration_type::duration_rep duration_rep;
   partial_date(day_type d, month_type m) :
     day_(d),
     month_(m)
   {}





   partial_date(duration_rep days) :
     day_(1),
     month_(1)
   {
     date_type d1(2000,1,1);
     if(days > 1) {
       if(days > 366)
       {
         days = 366;
       }
       days = days - 1;
       duration_type dd(days);
       d1 = d1 + dd;
     }
     day_ = d1.day();
     month_ = d1.month();
   }
# 101 "/usr/include/boost/date_time/date_generators.hpp" 3 4
   date_type get_date(year_type y) const override
   {
     if((day_ == 29) && (month_ == 2) && !(calendar_type::is_leap_year(y))) {
       std::ostringstream ss;
       ss << "No Feb 29th in given year of " << y << ".";
       boost::throw_exception(std::invalid_argument(ss.str()));
     }
     return date_type(y, month_, day_);
   }
   date_type operator()(year_type y) const
   {
     return get_date(y);

   }
   bool operator==(const partial_date& rhs) const
   {
     return (month_ == rhs.month_) && (day_ == rhs.day_);
   }
   bool operator<(const partial_date& rhs) const
   {
     if (month_ < rhs.month_) return true;
     if (month_ > rhs.month_) return false;

     return (day_ < rhs.day_);
   }


   month_type month() const
   {
     return month_;
   }
   day_type day() const
   {
     return day_;
   }






   std::string to_string() const override
   {
     std::ostringstream ss;
     date_type d(2004, month_, day_);
     unsigned short c = d.day_of_year();
     c--;
     ss << c;
     return ss.str();
   }
 private:
   day_type day_;
   month_type month_;
 };


  inline const char* nth_as_str(int ele)
  {
    static const char* const _nth_as_str[] = {"out of range", "first", "second",
                                              "third", "fourth", "fifth"};
    if(ele >= 1 && ele <= 5) {
      return _nth_as_str[ele];
    }
    else {
      return _nth_as_str[0];
    }
  }
# 186 "/usr/include/boost/date_time/date_generators.hpp" 3 4
  template<class date_type>
  class nth_kday_of_month : public year_based_generator<date_type>
  {
  public:
    typedef typename date_type::calendar_type calendar_type;
    typedef typename calendar_type::day_of_week_type day_of_week_type;
    typedef typename calendar_type::month_type month_type;
    typedef typename calendar_type::year_type year_type;
    typedef typename date_type::duration_type duration_type;
    enum week_num {first=1, second, third, fourth, fifth};
    nth_kday_of_month(week_num week_no,
                      day_of_week_type dow,
                      month_type m) :
      month_(m),
      wn_(week_no),
      dow_(dow)
    {}

    date_type get_date(year_type y) const override
    {
      date_type d(y, month_, 1);
      duration_type one_day(1);
      duration_type one_week(7);
      while (dow_ != d.day_of_week()) {
        d = d + one_day;
      }
      int week = 1;
      while (week < wn_) {
        d = d + one_week;
        week++;
      }

      if(d.month() != month_) {
        d = d - one_week;
      }
      return d;
    }

    month_type month() const
    {
      return month_;
    }
    week_num nth_week() const
    {
      return wn_;
    }
    day_of_week_type day_of_week() const
    {
      return dow_;
    }
    const char* nth_week_as_str() const
    {
      return nth_as_str(wn_);
    }


    std::string to_string() const override
    {
     std::ostringstream ss;
     ss << 'M'
       << static_cast<int>(month_) << '.'
       << static_cast<int>(wn_) << '.'
       << static_cast<int>(dow_);
     return ss.str();
    }
  private:
    month_type month_;
    week_num wn_;
    day_of_week_type dow_;
  };





  template<class date_type>
  class first_kday_of_month : public year_based_generator<date_type>
  {
  public:
    typedef typename date_type::calendar_type calendar_type;
    typedef typename calendar_type::day_of_week_type day_of_week_type;
    typedef typename calendar_type::month_type month_type;
    typedef typename calendar_type::year_type year_type;
    typedef typename date_type::duration_type duration_type;




    first_kday_of_month(day_of_week_type dow, month_type m) :
      month_(m),
      dow_(dow)
    {}

    date_type get_date(year_type year) const override
    {
      date_type d(year, month_,1);
      duration_type one_day(1);
      while (dow_ != d.day_of_week()) {
        d = d + one_day;
      }
      return d;
    }

    month_type month() const
    {
      return month_;
    }
    day_of_week_type day_of_week() const
    {
      return dow_;
    }


    std::string to_string() const override
    {
     std::ostringstream ss;
     ss << 'M'
       << static_cast<int>(month_) << '.'
       << 1 << '.'
       << static_cast<int>(dow_);
     return ss.str();
    }
  private:
    month_type month_;
    day_of_week_type dow_;
  };
# 322 "/usr/include/boost/date_time/date_generators.hpp" 3 4
  template<class date_type>
  class last_kday_of_month : public year_based_generator<date_type>
  {
  public:
    typedef typename date_type::calendar_type calendar_type;
    typedef typename calendar_type::day_of_week_type day_of_week_type;
    typedef typename calendar_type::month_type month_type;
    typedef typename calendar_type::year_type year_type;
    typedef typename date_type::duration_type duration_type;




    last_kday_of_month(day_of_week_type dow, month_type m) :
      month_(m),
      dow_(dow)
    {}

    date_type get_date(year_type year) const override
    {
      date_type d(year, month_, calendar_type::end_of_month_day(year,month_));
      duration_type one_day(1);
      while (dow_ != d.day_of_week()) {
        d = d - one_day;
      }
      return d;
    }

    month_type month() const
    {
      return month_;
    }
    day_of_week_type day_of_week() const
    {
      return dow_;
    }


    std::string to_string() const override
    {
      std::ostringstream ss;
      ss << 'M'
         << static_cast<int>(month_) << '.'
         << 5 << '.'
         << static_cast<int>(dow_);
      return ss.str();
    }
  private:
    month_type month_;
    day_of_week_type dow_;
   };
# 384 "/usr/include/boost/date_time/date_generators.hpp" 3 4
  template<class date_type>
  class first_kday_after
  {
  public:
    typedef typename date_type::calendar_type calendar_type;
    typedef typename calendar_type::day_of_week_type day_of_week_type;
    typedef typename date_type::duration_type duration_type;
    first_kday_after(day_of_week_type dow) :
      dow_(dow)
    {}

    date_type get_date(date_type start_day) const
    {
      duration_type one_day(1);
      date_type d = start_day + one_day;
      while (dow_ != d.day_of_week()) {
        d = d + one_day;
      }
      return d;
    }

    day_of_week_type day_of_week() const
    {
      return dow_;
    }
  private:
    day_of_week_type dow_;
  };
# 422 "/usr/include/boost/date_time/date_generators.hpp" 3 4
  template<class date_type>
  class first_kday_before
  {
  public:
    typedef typename date_type::calendar_type calendar_type;
    typedef typename calendar_type::day_of_week_type day_of_week_type;
    typedef typename date_type::duration_type duration_type;
    first_kday_before(day_of_week_type dow) :
      dow_(dow)
    {}

    date_type get_date(date_type start_day) const
    {
      duration_type one_day(1);
      date_type d = start_day - one_day;
      while (dow_ != d.day_of_week()) {
        d = d - one_day;
      }
      return d;
    }

    day_of_week_type day_of_week() const
    {
      return dow_;
    }
  private:
    day_of_week_type dow_;
  };





  template<typename date_type, class weekday_type>
  inline
  typename date_type::duration_type days_until_weekday(const date_type& d, const weekday_type& wd)
  {
    typedef typename date_type::duration_type duration_type;
    duration_type wks(0);
    duration_type dd(wd.as_number() - d.day_of_week().as_number());
    if(dd.is_negative()){
      wks = duration_type(7);
    }
    return dd + wks;
  }






  template<typename date_type, class weekday_type>
  inline
  typename date_type::duration_type days_before_weekday(const date_type& d, const weekday_type& wd)
  {
    typedef typename date_type::duration_type duration_type;
    duration_type wks(0);
    duration_type dd(wd.as_number() - d.day_of_week().as_number());
    if(dd.days() > 0){
      wks = duration_type(7);
    }


    return (-dd + wks);
  }






  template<class date_type, class weekday_type>
  inline
  date_type next_weekday(const date_type& d, const weekday_type& wd)
  {
    return d + days_until_weekday(d, wd);
  }






  template<class date_type, class weekday_type>
  inline
  date_type previous_weekday(const date_type& d, const weekday_type& wd)
  {
    return d - days_before_weekday(d, wd);
  }

} }
# 26 "/usr/include/boost/date_time/gregorian/gregorian_types.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/date_clock_device.hpp" 1 3 4
# 15 "/usr/include/boost/date_time/date_clock_device.hpp" 3 4
namespace boost {
namespace date_time {







  template<class date_type>
  class day_clock
  {
  public:
    typedef typename date_type::ymd_type ymd_type;

    static date_type local_day()
    {
      return date_type(local_day_ymd());
    }

    static typename date_type::ymd_type local_day_ymd()
    {
      ::std::tm result;
      ::std::tm* curr = get_local_time(result);
      return ymd_type(static_cast<unsigned short>(curr->tm_year + 1900),
                      static_cast<unsigned short>(curr->tm_mon + 1),
                      static_cast<unsigned short>(curr->tm_mday));
    }

    static typename date_type::ymd_type universal_day_ymd()
    {
      ::std::tm result;
      ::std::tm* curr = get_universal_time(result);
      return ymd_type(static_cast<unsigned short>(curr->tm_year + 1900),
                      static_cast<unsigned short>(curr->tm_mon + 1),
                      static_cast<unsigned short>(curr->tm_mday));
    }

    static date_type universal_day()
    {
      return date_type(universal_day_ymd());
    }

  private:
    static ::std::tm* get_local_time(std::tm& result)
    {
      ::std::time_t t;
      ::std::time(&t);
      return c_time::localtime(&t, &result);
    }
    static ::std::tm* get_universal_time(std::tm& result)
    {
      ::std::time_t t;
      ::std::time(&t);
      return c_time::gmtime(&t, &result);
    }

  };

} }
# 27 "/usr/include/boost/date_time/gregorian/gregorian_types.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/date_iterator.hpp" 1 3 4
# 14 "/usr/include/boost/date_time/date_iterator.hpp" 3 4
namespace boost {
namespace date_time {

  enum date_resolutions {day, week, months, year, decade, century, NumDateResolutions};
# 32 "/usr/include/boost/date_time/date_iterator.hpp" 3 4
  template<class date_type>
  class date_itr_base {



  public:
    typedef typename date_type::duration_type duration_type;
    typedef date_type value_type;
    typedef std::input_iterator_tag iterator_category;

    date_itr_base(date_type d) : current_(d) {}
    virtual ~date_itr_base() {}
    date_itr_base& operator++()
    {
      current_ = current_ + get_offset(current_);
      return *this;
    }
    date_itr_base& operator--()
    {
      current_ = current_ + get_neg_offset(current_);
      return *this;
    }
    virtual duration_type get_offset(const date_type& current) const=0;
    virtual duration_type get_neg_offset(const date_type& current) const=0;
    const date_type& operator*() const {return current_;}
    const date_type* operator->() const {return &current_;}
    bool operator< (const date_type& d) const {return current_ < d;}
    bool operator<= (const date_type& d) const {return current_ <= d;}
    bool operator> (const date_type& d) const {return current_ > d;}
    bool operator>= (const date_type& d) const {return current_ >= d;}
    bool operator== (const date_type& d) const {return current_ == d;}
    bool operator!= (const date_type& d) const {return current_ != d;}
  private:
    date_type current_;
  };
# 76 "/usr/include/boost/date_time/date_iterator.hpp" 3 4
  template<class offset_functor, class date_type>
  class date_itr : public date_itr_base<date_type> {
  public:
    typedef typename date_type::duration_type duration_type;
    date_itr(date_type d, int factor=1) :
      date_itr_base<date_type>(d),
      of_(factor)
    {}
  private:
    virtual duration_type get_offset(const date_type& current) const
    {
      return of_.get_offset(current);
    }
    virtual duration_type get_neg_offset(const date_type& current) const
    {
      return of_.get_neg_offset(current);
    }
    offset_functor of_;
  };



} }
# 28 "/usr/include/boost/date_time/gregorian/gregorian_types.hpp" 2 3 4


namespace boost {






namespace gregorian {



  typedef date_time::period<date, date_duration> date_period;






  typedef date_time::year_based_generator<date> year_based_generator;


  typedef date_time::partial_date<date> partial_date;

  typedef date_time::nth_kday_of_month<date> nth_kday_of_month;
  typedef nth_kday_of_month nth_day_of_the_week_in_month;

  typedef date_time::first_kday_of_month<date> first_kday_of_month;
  typedef first_kday_of_month first_day_of_the_week_in_month;

  typedef date_time::last_kday_of_month<date> last_kday_of_month;
  typedef last_kday_of_month last_day_of_the_week_in_month;

  typedef date_time::first_kday_after<date> first_kday_after;
  typedef first_kday_after first_day_of_the_week_after;

  typedef date_time::first_kday_before<date> first_kday_before;
  typedef first_kday_before first_day_of_the_week_before;




  typedef date_time::day_clock<date> day_clock;




  typedef date_time::date_itr_base<date> date_iterator;




  typedef date_time::date_itr<date_time::day_functor<date>,
                              date> day_iterator;



  typedef date_time::date_itr<date_time::week_functor<date>,
                              date> week_iterator;



  typedef date_time::date_itr<date_time::month_functor<date>,
                              date> month_iterator;



  typedef date_time::date_itr<date_time::year_functor<date>,
                              date> year_iterator;


  using date_time::days_until_weekday;
  using date_time::days_before_weekday;
  using date_time::next_weekday;
  using date_time::previous_weekday;

} }
# 19 "/usr/include/boost/date_time/posix_time/posix_time_config.hpp" 2 3 4



namespace boost {
namespace posix_time {
# 34 "/usr/include/boost/date_time/posix_time/posix_time_config.hpp" 3 4
  typedef date_time::time_resolution_traits<
    boost::date_time::time_resolution_traits_adapted64_impl, boost::date_time::micro,
                                            1000000, 6 > time_res_traits;







  class __attribute__((__visibility__("default"))) time_duration :
    public date_time::time_duration<time_duration, time_res_traits>
  {
  public:
    typedef time_res_traits rep_type;
    typedef time_res_traits::day_type day_type;
    typedef time_res_traits::hour_type hour_type;
    typedef time_res_traits::min_type min_type;
    typedef time_res_traits::sec_type sec_type;
    typedef time_res_traits::fractional_seconds_type fractional_seconds_type;
    typedef time_res_traits::tick_type tick_type;
    typedef time_res_traits::impl_type impl_type;
    constexpr time_duration(hour_type hour,
                                        min_type min,
                                        sec_type sec,
                                        fractional_seconds_type fs=0) :
      date_time::time_duration<time_duration, time_res_traits>(hour,min,sec,fs)
    {}
   constexpr time_duration() :
      date_time::time_duration<time_duration, time_res_traits>(0,0,0)
    {}

    constexpr time_duration(boost::date_time::special_values sv) :
      date_time::time_duration<time_duration, time_res_traits>(sv)
    {}

    friend class date_time::time_duration<time_duration, time_res_traits>;
  protected:
    constexpr explicit time_duration(impl_type tick_count) :
      date_time::time_duration<time_duration, time_res_traits>(tick_count)
    {}
  };
# 141 "/usr/include/boost/date_time/posix_time/posix_time_config.hpp" 3 4
  class millisec_posix_time_system_config
  {
   public:
    typedef boost::int64_t time_rep_type;

    typedef gregorian::date date_type;
    typedef gregorian::date_duration date_duration_type;
    typedef time_duration time_duration_type;
    typedef time_res_traits::tick_type int_type;
    typedef time_res_traits::impl_type impl_type;
    typedef time_res_traits resolution_traits;


    static const boost::int64_t tick_per_second = 1000000;

  };



} }
# 14 "/usr/include/boost/date_time/posix_time/posix_time_system.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/time_system_split.hpp" 1 3 4
# 14 "/usr/include/boost/date_time/time_system_split.hpp" 3 4
# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 15 "/usr/include/boost/date_time/time_system_split.hpp" 2 3 4





namespace boost {
namespace date_time {





  template<typename config>

  class split_timedate_system
  {
   public:
    typedef typename config::time_rep_type time_rep_type;
    typedef typename config::date_type date_type;
    typedef typename config::time_duration_type time_duration_type;
    typedef typename config::date_duration_type date_duration_type;
    typedef typename config::int_type int_type;
    typedef typename config::resolution_traits resolution_traits;





   private:
     static const int_type ticks_per_day = 86400L * config::tick_per_second;
   public:



    typedef date_time::wrapping_int<int_type, ticks_per_day> wrap_int_type;



    static
    constexpr
    time_rep_type get_time_rep(special_values sv)
    {
      switch (sv) {
      case not_a_date_time:
        return time_rep_type(date_type(not_a_date_time),
                             time_duration_type(not_a_date_time));
      case pos_infin:
        return time_rep_type(date_type(pos_infin),
                             time_duration_type(pos_infin));
      case neg_infin:
        return time_rep_type(date_type(neg_infin),
                             time_duration_type(neg_infin));
      case max_date_time: {
        time_duration_type td = time_duration_type(24,0,0,0) - time_duration_type(0,0,0,1);
        return time_rep_type(date_type(max_date_time), td);
      }
      case min_date_time:
        return time_rep_type(date_type(min_date_time), time_duration_type(0,0,0,0));

      default:
        return time_rep_type(date_type(not_a_date_time),
                             time_duration_type(not_a_date_time));

      }

    }

    static
    constexpr
    time_rep_type get_time_rep(const date_type& day,
                               const time_duration_type& tod,
                               date_time::dst_flags = not_dst)
    {
      if(day.is_special() || tod.is_special()) {
        if(day.is_not_a_date() || tod.is_not_a_date_time()) {
          return time_rep_type(date_type(not_a_date_time),
                               time_duration_type(not_a_date_time));
        }
        else if(day.is_pos_infinity()) {
          if(tod.is_neg_infinity()) {
            return time_rep_type(date_type(not_a_date_time),
                                 time_duration_type(not_a_date_time));
          }
          else {
            return time_rep_type(day, time_duration_type(pos_infin));
          }
        }
        else if(day.is_neg_infinity()) {
          if(tod.is_pos_infinity()) {
            return time_rep_type(date_type(not_a_date_time),
                                 time_duration_type(not_a_date_time));
          }
          else {
            return time_rep_type(day, time_duration_type(neg_infin));
          }
        }
        else if(tod.is_pos_infinity()) {
          if(day.is_neg_infinity()) {
            return time_rep_type(date_type(not_a_date_time),
                                 time_duration_type(not_a_date_time));
          }
          else {
            return time_rep_type(date_type(pos_infin), tod);
          }
        }
        else if(tod.is_neg_infinity()) {
          if(day.is_pos_infinity()) {
            return time_rep_type(date_type(not_a_date_time),
                                 time_duration_type(not_a_date_time));
          }
          else {
            return time_rep_type(date_type(neg_infin), tod);
          }
        }
      }
      return time_rep_type(day, tod);
    }
    static constexpr date_type get_date(const time_rep_type& val)
    {
      return date_type(val.day);
    }
    static constexpr time_duration_type get_time_of_day(const time_rep_type& val)
    {
      return time_duration_type(val.time_of_day);
    }
    static std::string zone_name(const time_rep_type&)
    {
      return std::string();
    }
    static constexpr
    bool is_equal(const time_rep_type& lhs, const time_rep_type& rhs)
    {
      return ((lhs.day == rhs.day) && (lhs.time_of_day == rhs.time_of_day));
    }
    static constexpr
    bool is_less(const time_rep_type& lhs, const time_rep_type& rhs)
    {
      if (lhs.day < rhs.day) return true;
      if (lhs.day > rhs.day) return false;
      return (lhs.time_of_day < rhs.time_of_day);
    }
    static constexpr
    time_rep_type add_days(const time_rep_type& base,
                           const date_duration_type& dd)
    {
      return time_rep_type(base.day+dd, base.time_of_day);
    }
    static constexpr
    time_rep_type subtract_days(const time_rep_type& base,
                                const date_duration_type& dd)
    {
      return split_timedate_system::get_time_rep(base.day-dd, base.time_of_day);
    }
    static constexpr
    time_rep_type subtract_time_duration(const time_rep_type& base,
                                         const time_duration_type& td)
    {
      if(base.day.is_special() || td.is_special())
      {
        return split_timedate_system::get_time_rep(base.day, -td);
      }
      if (td.is_negative()) {
        time_duration_type td1 = td.invert_sign();
        return add_time_duration(base,td1);
      }

      wrap_int_type day_offset(base.time_of_day.ticks());
      date_duration_type day_overflow(static_cast<typename date_duration_type::duration_rep_type>(day_offset.subtract(td.ticks())));

      return time_rep_type(base.day-day_overflow,
                           time_duration_type(0,0,0,day_offset.as_int()));
    }
    static constexpr
    time_rep_type add_time_duration(const time_rep_type& base,
                                    time_duration_type td)
    {
      if(base.day.is_special() || td.is_special()) {
        return split_timedate_system::get_time_rep(base.day, td);
      }
      if (td.is_negative()) {
        time_duration_type td1 = td.invert_sign();
        return subtract_time_duration(base,td1);
      }

      wrap_int_type day_offset(base.time_of_day.ticks());
      date_duration_type day_overflow(static_cast< typename date_duration_type::duration_rep_type >(day_offset.add(td.ticks())));

      return time_rep_type(base.day+day_overflow,
                           time_duration_type(0,0,0,day_offset.as_int()));
    }
    static constexpr
    time_duration_type subtract_times(const time_rep_type& lhs,
                                      const time_rep_type& rhs)
    {
      date_duration_type dd = lhs.day - rhs.day;
      if (__builtin_expect(!dd.is_special(), 1)) {
        time_duration_type td(dd.days()*24,0,0);
        time_duration_type td2 = lhs.time_of_day - rhs.time_of_day;
        return td+td2;
      } else {
        time_duration_type td(dd.as_special());
        time_duration_type td2 = lhs.time_of_day - rhs.time_of_day;
        return td+td2;
      }
    }

  };

} }
# 15 "/usr/include/boost/date_time/posix_time/posix_time_system.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/time_system_counted.hpp" 1 3 4
# 19 "/usr/include/boost/date_time/time_system_counted.hpp" 3 4
namespace boost {
namespace date_time {


  template<class config>
  struct counted_time_rep
  {
    typedef typename config::int_type int_type;
    typedef typename config::date_type date_type;
    typedef typename config::impl_type impl_type;
    typedef typename date_type::duration_type date_duration_type;
    typedef typename date_type::calendar_type calendar_type;
    typedef typename date_type::ymd_type ymd_type;
    typedef typename config::time_duration_type time_duration_type;
    typedef typename config::resolution_traits resolution_traits;

    constexpr
    counted_time_rep(const date_type& d, const time_duration_type& time_of_day)
      : time_count_(1)
    {
      if(d.is_infinity() || d.is_not_a_date() || time_of_day.is_special()) {
        time_count_ = time_of_day.get_rep() + d.day_count();

      }
      else {
        time_count_ = (d.day_number() * frac_sec_per_day()) + time_of_day.ticks();
      }
    }
    constexpr
    explicit counted_time_rep(int_type count) :
      time_count_(count)
    {}
    constexpr
    explicit counted_time_rep(impl_type count) :
      time_count_(count)
    {}
    constexpr
    date_type date() const
    {
      if(time_count_.is_special()) {
        return date_type(time_count_.as_special());
      }
      else {
        typename calendar_type::date_int_type dc = static_cast<typename calendar_type::date_int_type>(day_count());

        ymd_type ymd = calendar_type::from_day_number(dc);
        return date_type(ymd);
      }
    }

    constexpr
    unsigned long day_count() const
    {
# 84 "/usr/include/boost/date_time/time_system_counted.hpp" 3 4
      return static_cast<unsigned long>(resolution_traits::as_number(time_count_) / frac_sec_per_day());
    }
    constexpr int_type time_count() const
    {
      return resolution_traits::as_number(time_count_);
    }
    constexpr int_type tod() const
    {
      return resolution_traits::as_number(time_count_) % frac_sec_per_day();
    }
    static constexpr int_type frac_sec_per_day()
    {
      int_type seconds_per_day = 60*60*24;
      int_type fractional_sec_per_sec(resolution_traits::res_adjust());
      return seconds_per_day*fractional_sec_per_sec;
    }
    constexpr bool is_pos_infinity()const
    {
      return impl_type::is_pos_inf(time_count_.as_number());
    }
    constexpr bool is_neg_infinity()const
    {
      return impl_type::is_neg_inf(time_count_.as_number());
    }
    constexpr bool is_not_a_date_time()const
    {
      return impl_type::is_not_a_number(time_count_.as_number());
    }
    constexpr bool is_special()const
    {
      return time_count_.is_special();
    }
    constexpr impl_type get_rep()const
    {
      return time_count_;
    }
  private:
    impl_type time_count_;
  };


  template<class time_rep>
  class counted_time_system
  {
   public:
    typedef time_rep time_rep_type;
    typedef typename time_rep_type::impl_type impl_type;
    typedef typename time_rep_type::time_duration_type time_duration_type;
    typedef typename time_duration_type::fractional_seconds_type fractional_seconds_type;
    typedef typename time_rep_type::date_type date_type;
    typedef typename time_rep_type::date_duration_type date_duration_type;


    template<class T> static constexpr void unused_var(const T&) {}

    static constexpr
    time_rep_type get_time_rep(const date_type& day,
                               const time_duration_type& tod,
                               date_time::dst_flags dst=not_dst)
    {
      unused_var(dst);
      return time_rep_type(day, tod);
    }

    static constexpr time_rep_type get_time_rep(special_values sv)
    {
      switch (sv) {
      case not_a_date_time:
        return time_rep_type(date_type(not_a_date_time),
                             time_duration_type(not_a_date_time));
      case pos_infin:
        return time_rep_type(date_type(pos_infin),
                             time_duration_type(pos_infin));
      case neg_infin:
        return time_rep_type(date_type(neg_infin),
                             time_duration_type(neg_infin));
      case max_date_time: {
        time_duration_type td = time_duration_type(24,0,0,0) - time_duration_type(0,0,0,1);
        return time_rep_type(date_type(max_date_time), td);
      }
      case min_date_time:
        return time_rep_type(date_type(min_date_time), time_duration_type(0,0,0,0));

      default:
        return time_rep_type(date_type(not_a_date_time),
                             time_duration_type(not_a_date_time));

      }

    }

    static constexpr date_type
    get_date(const time_rep_type& val)
    {
      return val.date();
    }
    static constexpr
    time_duration_type get_time_of_day(const time_rep_type& val)
    {
      if(val.is_special()) {
        return time_duration_type(val.get_rep().as_special());
      }
      else{
        return time_duration_type(0,0,0,val.tod());
      }
    }
    static std::string zone_name(const time_rep_type&)
    {
      return "";
    }
    static constexpr bool is_equal(const time_rep_type& lhs, const time_rep_type& rhs)
    {
      return (lhs.time_count() == rhs.time_count());
    }
    static constexpr
    bool is_less(const time_rep_type& lhs, const time_rep_type& rhs)
    {
      return (lhs.time_count() < rhs.time_count());
    }
    static constexpr
    time_rep_type add_days(const time_rep_type& base,
                           const date_duration_type& dd)
    {
      if(base.is_special() || dd.is_special()) {
        return(time_rep_type(base.get_rep() + dd.get_rep()));
      }
      else {
        return time_rep_type(base.time_count() + (dd.days() * time_rep_type::frac_sec_per_day()));
      }
    }
    static constexpr
    time_rep_type subtract_days(const time_rep_type& base,
                                const date_duration_type& dd)
    {
      if(base.is_special() || dd.is_special()) {
        return(time_rep_type(base.get_rep() - dd.get_rep()));
      }
      else{
        return time_rep_type(base.time_count() - (dd.days() * time_rep_type::frac_sec_per_day()));
      }
    }
    static constexpr
    time_rep_type subtract_time_duration(const time_rep_type& base,
                                         const time_duration_type& td)
    {
      if(base.is_special() || td.is_special()) {
        return(time_rep_type(base.get_rep() - td.get_rep()));
      }
      else {
        return time_rep_type(base.time_count() - td.ticks());
      }
    }
    static constexpr
    time_rep_type add_time_duration(const time_rep_type& base,
                                    time_duration_type td)
    {
      if(base.is_special() || td.is_special()) {
        return(time_rep_type(base.get_rep() + td.get_rep()));
      }
      else {
        return time_rep_type(base.time_count() + td.ticks());
      }
    }
    static constexpr
    time_duration_type subtract_times(const time_rep_type& lhs,
                                      const time_rep_type& rhs)
    {
      if(lhs.is_special() || rhs.is_special()) {
        return(time_duration_type(
          impl_type::to_special((lhs.get_rep() - rhs.get_rep()).as_number())));
      }
      else {
        fractional_seconds_type fs = lhs.time_count() - rhs.time_count();
        return time_duration_type(0,0,0,fs);
      }
    }

  };


} }
# 16 "/usr/include/boost/date_time/posix_time/posix_time_system.hpp" 2 3 4



namespace boost {
namespace posix_time {
# 32 "/usr/include/boost/date_time/posix_time/posix_time_system.hpp" 3 4
  typedef date_time::counted_time_rep<millisec_posix_time_system_config> int64_time_rep;
  typedef date_time::counted_time_system<int64_time_rep> posix_time_system;



} }
# 13 "/usr/include/boost/date_time/posix_time/ptime.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/time.hpp" 1 3 4
# 21 "/usr/include/boost/date_time/time.hpp" 3 4
namespace boost {
namespace date_time {
# 45 "/usr/include/boost/date_time/time.hpp" 3 4
  template <class T, class time_system>
  class base_time : private
      boost::less_than_comparable<T
    , boost::equality_comparable<T
      > >
  {
  public:

    typedef void _is_boost_date_time_time_point;
    typedef T time_type;
    typedef typename time_system::time_rep_type time_rep_type;
    typedef typename time_system::date_type date_type;
    typedef typename time_system::date_duration_type date_duration_type;
    typedef typename time_system::time_duration_type time_duration_type;


    constexpr
    base_time(const date_type& day,
              const time_duration_type& td,
              dst_flags dst=not_dst) :
      time_(time_system::get_time_rep(day, td, dst))
    {}
    constexpr
    base_time(special_values sv) :
      time_(time_system::get_time_rep(sv))
    {}
    constexpr
    base_time(const time_rep_type& rhs) :
      time_(rhs)
    {}
    constexpr
    date_type date() const
    {
      return time_system::get_date(time_);
    }
    constexpr
    time_duration_type time_of_day() const
    {
      return time_system::get_time_of_day(time_);
    }



    std::string zone_name(bool =false) const
    {
      return time_system::zone_name(time_);
    }



    std::string zone_abbrev(bool =false) const
    {
      return time_system::zone_name(time_);
    }

    std::string zone_as_posix_string() const
    {
      return std::string();
    }


    constexpr
    bool is_not_a_date_time() const
    {
      return time_.is_not_a_date_time();
    }

    constexpr
    bool is_infinity() const
    {
      return (is_pos_infinity() || is_neg_infinity());
    }

    constexpr
    bool is_pos_infinity() const
    {
      return time_.is_pos_infinity();
    }

    constexpr
    bool is_neg_infinity() const
    {
      return time_.is_neg_infinity();
    }

    constexpr
    bool is_special() const
    {
      return(is_not_a_date_time() || is_infinity());
    }

    constexpr
    bool operator==(const time_type& rhs) const
    {
      return time_system::is_equal(time_,rhs.time_);
    }

    constexpr
    bool operator<(const time_type& rhs) const
    {
      return time_system::is_less(time_,rhs.time_);
    }

    constexpr
    time_duration_type operator-(const time_type& rhs) const
    {
      return time_system::subtract_times(time_, rhs.time_);
    }

    constexpr
    time_type operator+(const date_duration_type& dd) const
    {
      return time_system::add_days(time_, dd);
    }
    constexpr
    time_type operator+=(const date_duration_type& dd)
    {
      time_ = (time_system::get_time_rep(date() + dd, time_of_day()));
      return time_type(time_);
    }

    constexpr
    time_type operator-(const date_duration_type& dd) const
    {
      return time_system::subtract_days(time_, dd);
    }
    constexpr
    time_type operator-=(const date_duration_type& dd)
    {
      time_ = (time_system::get_time_rep(date() - dd, time_of_day()));
      return time_type(time_);
    }

    constexpr
    time_type operator+(const time_duration_type& td) const
    {
      return time_type(time_system::add_time_duration(time_, td));
    }
    constexpr
    time_type operator+=(const time_duration_type& td)
    {
      time_ = time_system::add_time_duration(time_,td);
      return time_type(time_);
    }

    constexpr
    time_type operator-(const time_duration_type& rhs) const
    {
      return time_system::subtract_time_duration(time_, rhs);
    }
    constexpr
    time_type operator-=(const time_duration_type& td)
    {
      time_ = time_system::subtract_time_duration(time_, td);
      return time_type(time_);
    }

  protected:
    time_rep_type time_;
  };





} }
# 14 "/usr/include/boost/date_time/posix_time/ptime.hpp" 2 3 4


namespace boost {

namespace posix_time {


  using date_time::special_values;
  using date_time::not_special;
  using date_time::neg_infin;
  using date_time::pos_infin;
  using date_time::not_a_date_time;
  using date_time::max_date_time;
  using date_time::min_date_time;




  class __attribute__((__visibility__("default"))) ptime : public date_time::base_time<ptime, posix_time_system>
  {
  public:
    typedef posix_time_system time_system_type;
    typedef time_system_type::time_rep_type time_rep_type;
    typedef time_system_type::time_duration_type time_duration_type;
    typedef ptime time_type;

    constexpr
    ptime(gregorian::date d,time_duration_type td) :
      date_time::base_time<time_type,time_system_type>(d,td)
    {}

    constexpr
    explicit ptime(gregorian::date d) :
      date_time::base_time<time_type,time_system_type>(d,time_duration_type(0,0,0))
    {}

    constexpr
    ptime(const time_rep_type& rhs):
      date_time::base_time<time_type,time_system_type>(rhs)
    {}

    constexpr
    ptime(const special_values sv) :
      date_time::base_time<time_type,time_system_type>(sv)
    {}


    constexpr
    ptime() :
      date_time::base_time<time_type,time_system_type>(gregorian::date(not_a_date_time),
                                                       time_duration_type(not_a_date_time))
    {}


    friend constexpr
    bool operator==(const ptime& lhs, const ptime& rhs);

  };

  inline constexpr
  bool operator==(const ptime& lhs, const ptime& rhs)
  {
    return ptime::time_system_type::is_equal(lhs.time_,rhs.time_);
  }


} }
# 13 "/usr/include/boost/date_time/posix_time/posix_time_types.hpp" 2 3 4

# 1 "/usr/include/boost/date_time/posix_time/date_duration_operators.hpp" 1 3 4
# 15 "/usr/include/boost/date_time/posix_time/date_duration_operators.hpp" 3 4
namespace boost {
namespace posix_time {
# 29 "/usr/include/boost/date_time/posix_time/date_duration_operators.hpp" 3 4
  inline constexpr
  ptime
  operator+(const ptime& t, const boost::gregorian::months& m)
  {
    return t + m.get_offset(t.date());
  }




  inline constexpr
  ptime
  operator+=(ptime& t, const boost::gregorian::months& m)
  {

    return t += m.get_offset(t.date());
  }




  inline constexpr
  ptime
  operator-(const ptime& t, const boost::gregorian::months& m)
  {

    return t + m.get_neg_offset(t.date());
  }




  inline constexpr
  ptime
  operator-=(ptime& t, const boost::gregorian::months& m)
  {
    return t += m.get_neg_offset(t.date());
  }






  inline constexpr
  ptime
  operator+(const ptime& t, const boost::gregorian::years& y)
  {
    return t + y.get_offset(t.date());
  }




  inline constexpr
  ptime
  operator+=(ptime& t, const boost::gregorian::years& y)
  {
    return t += y.get_offset(t.date());
  }




  inline constexpr
  ptime
  operator-(const ptime& t, const boost::gregorian::years& y)
  {

    return t + y.get_neg_offset(t.date());
  }




  inline constexpr
  ptime
  operator-=(ptime& t, const boost::gregorian::years& y)
  {

    return t += y.get_neg_offset(t.date());
  }

}}
# 15 "/usr/include/boost/date_time/posix_time/posix_time_types.hpp" 2 3 4

# 1 "/usr/include/boost/date_time/posix_time/posix_time_duration.hpp" 1 3 4
# 15 "/usr/include/boost/date_time/posix_time/posix_time_duration.hpp" 3 4
# 1 "/usr/include/boost/numeric/conversion/cast.hpp" 1 3 4
# 33 "/usr/include/boost/numeric/conversion/cast.hpp" 3 4
# 1 "/usr/include/boost/numeric/conversion/converter.hpp" 1 3 4
# 13 "/usr/include/boost/numeric/conversion/converter.hpp" 3 4
# 1 "/usr/include/boost/numeric/conversion/conversion_traits.hpp" 1 3 4
# 13 "/usr/include/boost/numeric/conversion/conversion_traits.hpp" 3 4
# 1 "/usr/include/boost/numeric/conversion/detail/conversion_traits.hpp" 1 3 4
# 17 "/usr/include/boost/numeric/conversion/detail/conversion_traits.hpp" 3 4
# 1 "/usr/include/boost/numeric/conversion/detail/meta.hpp" 1 3 4
# 17 "/usr/include/boost/numeric/conversion/detail/meta.hpp" 3 4
# 1 "/usr/include/boost/mpl/equal_to.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/equal_to.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 1 3 4
# 27 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 1 3 4
# 21 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 3 4
# 1 "/usr/include/boost/mpl/numeric_cast.hpp" 1 3 4
# 30 "/usr/include/boost/mpl/numeric_cast.hpp" 3 4
namespace boost { namespace mpl {



template< typename SourceTag, typename TargetTag > struct numeric_cast
{
    template< typename N > struct apply;
};

}}
# 22 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/apply_wrap.hpp" 1 3 4
# 23 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4


# 1 "/usr/include/boost/mpl/aux_/numeric_cast_utils.hpp" 1 3 4
# 18 "/usr/include/boost/mpl/aux_/numeric_cast_utils.hpp" 3 4
# 1 "/usr/include/boost/mpl/apply_wrap.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/aux_/numeric_cast_utils.hpp" 2 3 4


namespace boost { namespace mpl { namespace aux {

template<
      typename F
    , typename Tag1
    , typename Tag2
    >
struct cast1st_impl
{
    template< typename N1, typename N2 > struct apply

        : apply_wrap2<
              F
            , typename apply_wrap1< numeric_cast<Tag1,Tag2>,N1 >::type
            , N2
            >
    {
# 46 "/usr/include/boost/mpl/aux_/numeric_cast_utils.hpp" 3 4
    };
};

template<
      typename F
    , typename Tag1
    , typename Tag2
    >
struct cast2nd_impl
{
    template< typename N1, typename N2 > struct apply

        : apply_wrap2<
              F
            , N1
            , typename apply_wrap1< numeric_cast<Tag2,Tag1>,N2 >::type
            >
    {
# 72 "/usr/include/boost/mpl/aux_/numeric_cast_utils.hpp" 3 4
    };
};

}}}
# 26 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4
# 28 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 2 3 4







# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/equal_to.hpp" 1 3 4
# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/equal_to.hpp" 3 4
namespace boost { namespace mpl {

template<
      typename Tag1
    , typename Tag2
    >
struct equal_to_impl
    : if_c<
          ( Tag1::value
              > Tag2::value
            )

        , aux::cast2nd_impl< equal_to_impl< Tag1,Tag1 >,Tag1, Tag2 >
        , aux::cast1st_impl< equal_to_impl< Tag2,Tag2 >,Tag1, Tag2 >
        >::type
{
};


template<> struct equal_to_impl< na,na >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename Tag > struct equal_to_impl< na,Tag >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename Tag > struct equal_to_impl< Tag,na >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename T > struct equal_to_tag
{
    typedef typename T::tag type;
};

template<
      typename N1 = na
    , typename N2 = na
    >
struct equal_to

    : equal_to_impl<
          typename equal_to_tag<N1>::type
        , typename equal_to_tag<N2>::type
        >::template apply< N1,N2 >::type
{


};

template<> struct equal_to< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : equal_to< T1 , T2 > { }; }; template< typename Tag > struct lambda< equal_to< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef equal_to< na , na > result_; typedef equal_to< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< equal_to< T1 , T2 > > : int_<2> { }; template<> struct template_arity< equal_to< na , na > > : int_<-1> { }; }

}}

namespace boost { namespace mpl {

template<>
struct equal_to_impl< integral_c_tag,integral_c_tag >
{
    template< typename N1, typename N2 > struct apply

        : bool_< ( N1::value == N2::value ) >
    {
    };
};

}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 36 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 2 3 4
# 20 "/usr/include/boost/mpl/equal_to.hpp" 2 3 4
# 18 "/usr/include/boost/numeric/conversion/detail/meta.hpp" 2 3 4





namespace boost { namespace numeric { namespace convdetail
{
   template< class T1, class T2>
   struct equal_to
   {


       enum { x = ( T1::value == T2::value ) };

       static const bool value = x;

       typedef mpl::bool_<value> type;
# 48 "/usr/include/boost/numeric/conversion/detail/meta.hpp" 3 4
   };
# 59 "/usr/include/boost/numeric/conversion/detail/meta.hpp" 3 4
  template<class Value,
           class Case0Val,
           class Case1Val,
           class Case2Val,
           class Case0Type,
           class Case1Type,
           class Case2Type,
           class DefaultType
          >
  struct ct_switch4
  {
    typedef mpl::identity<Case0Type> Case0TypeQ ;
    typedef mpl::identity<Case1Type> Case1TypeQ ;

    typedef equal_to<Value,Case0Val> is_case0 ;
    typedef equal_to<Value,Case1Val> is_case1 ;
    typedef equal_to<Value,Case2Val> is_case2 ;

    typedef mpl::if_<is_case2,Case2Type,DefaultType> choose_2_3Q ;
    typedef mpl::eval_if<is_case1,Case1TypeQ,choose_2_3Q> choose_1_2_3Q ;

    typedef typename
      mpl::eval_if<is_case0,Case0TypeQ,choose_1_2_3Q>::type
        type ;
  } ;
# 97 "/usr/include/boost/numeric/conversion/detail/meta.hpp" 3 4
  template<class expr0, class expr1, class TT, class TF, class FT, class FF>
  struct for_both
  {
    typedef mpl::identity<TF> TF_Q ;
    typedef mpl::identity<TT> TT_Q ;

    typedef typename mpl::not_<expr0>::type not_expr0 ;
    typedef typename mpl::not_<expr1>::type not_expr1 ;

    typedef typename mpl::and_<expr0,expr1>::type caseTT ;
    typedef typename mpl::and_<expr0,not_expr1>::type caseTF ;
    typedef typename mpl::and_<not_expr0,expr1>::type caseFT ;

    typedef mpl::if_<caseFT,FT,FF> choose_FT_FF_Q ;
    typedef mpl::eval_if<caseTF,TF_Q,choose_FT_FF_Q> choose_TF_FT_FF_Q ;

    typedef typename mpl::eval_if<caseTT,TT_Q,choose_TF_FT_FF_Q>::type type ;
  } ;

} } }
# 18 "/usr/include/boost/numeric/conversion/detail/conversion_traits.hpp" 2 3 4
# 1 "/usr/include/boost/numeric/conversion/detail/int_float_mixture.hpp" 1 3 4
# 16 "/usr/include/boost/numeric/conversion/detail/int_float_mixture.hpp" 3 4
# 1 "/usr/include/boost/numeric/conversion/int_float_mixture_enum.hpp" 1 3 4
# 13 "/usr/include/boost/numeric/conversion/int_float_mixture_enum.hpp" 3 4
namespace boost { namespace numeric
{
  enum int_float_mixture_enum
  {
     integral_to_integral
    ,integral_to_float
    ,float_to_integral
    ,float_to_float
  } ;

} }
# 17 "/usr/include/boost/numeric/conversion/detail/int_float_mixture.hpp" 2 3 4




namespace boost { namespace numeric { namespace convdetail
{

  typedef boost::integral_constant<int_float_mixture_enum, integral_to_integral> int2int_c ;
  typedef boost::integral_constant<int_float_mixture_enum, integral_to_float> int2float_c ;
  typedef boost::integral_constant<int_float_mixture_enum, float_to_integral> float2int_c ;
  typedef boost::integral_constant<int_float_mixture_enum, float_to_float> float2float_c ;







  template<class T,class S>
  struct get_int_float_mixture
  {
    typedef mpl::bool_< ::std::numeric_limits<S>::is_integer > S_int ;
    typedef mpl::bool_< ::std::numeric_limits<T>::is_integer > T_int ;

    typedef typename
      for_both<S_int, T_int, int2int_c, int2float_c, float2int_c, float2float_c>::type
        type ;
  } ;
# 55 "/usr/include/boost/numeric/conversion/detail/int_float_mixture.hpp" 3 4
  template<class IntFloatMixture, class Int2Int, class Int2Float, class Float2Int, class Float2Float>
  struct for_int_float_mixture
  {
    typedef typename
      ct_switch4<IntFloatMixture
                 ,int2int_c, int2float_c, float2int_c
                 ,Int2Int , Int2Float , Float2Int , Float2Float
                >::type
        type ;
  } ;

} } }
# 19 "/usr/include/boost/numeric/conversion/detail/conversion_traits.hpp" 2 3 4
# 1 "/usr/include/boost/numeric/conversion/detail/sign_mixture.hpp" 1 3 4
# 16 "/usr/include/boost/numeric/conversion/detail/sign_mixture.hpp" 3 4
# 1 "/usr/include/boost/numeric/conversion/sign_mixture_enum.hpp" 1 3 4
# 13 "/usr/include/boost/numeric/conversion/sign_mixture_enum.hpp" 3 4
namespace boost { namespace numeric
{
  enum sign_mixture_enum
  {
     unsigned_to_unsigned
    ,signed_to_signed
    ,signed_to_unsigned
    ,unsigned_to_signed
  } ;

} }
# 17 "/usr/include/boost/numeric/conversion/detail/sign_mixture.hpp" 2 3 4




namespace boost { namespace numeric { namespace convdetail
{

  typedef boost::integral_constant<sign_mixture_enum, unsigned_to_unsigned> unsig2unsig_c ;
  typedef boost::integral_constant<sign_mixture_enum, signed_to_signed> sig2sig_c ;
  typedef boost::integral_constant<sign_mixture_enum, signed_to_unsigned> sig2unsig_c ;
  typedef boost::integral_constant<sign_mixture_enum, unsigned_to_signed> unsig2sig_c ;







  template<class T,class S>
  struct get_sign_mixture
  {
    typedef mpl::bool_< ::std::numeric_limits<S>::is_signed > S_signed ;
    typedef mpl::bool_< ::std::numeric_limits<T>::is_signed > T_signed ;

    typedef typename
      for_both<S_signed, T_signed, sig2sig_c, sig2unsig_c, unsig2sig_c, unsig2unsig_c>::type
        type ;
  } ;
# 55 "/usr/include/boost/numeric/conversion/detail/sign_mixture.hpp" 3 4
  template<class SignMixture, class Sig2Sig, class Sig2Unsig, class Unsig2Sig, class Unsig2Unsig>
  struct for_sign_mixture
  {
    typedef typename
      ct_switch4<SignMixture
                 , sig2sig_c, sig2unsig_c, unsig2sig_c
                 , Sig2Sig , Sig2Unsig , Unsig2Sig , Unsig2Unsig
                >::type
        type ;
  } ;

} } }
# 20 "/usr/include/boost/numeric/conversion/detail/conversion_traits.hpp" 2 3 4
# 1 "/usr/include/boost/numeric/conversion/detail/udt_builtin_mixture.hpp" 1 3 4
# 15 "/usr/include/boost/numeric/conversion/detail/udt_builtin_mixture.hpp" 3 4
# 1 "/usr/include/boost/numeric/conversion/udt_builtin_mixture_enum.hpp" 1 3 4
# 13 "/usr/include/boost/numeric/conversion/udt_builtin_mixture_enum.hpp" 3 4
namespace boost { namespace numeric
{
  enum udt_builtin_mixture_enum
  {
     builtin_to_builtin
    ,builtin_to_udt
    ,udt_to_builtin
    ,udt_to_udt
  } ;

} }
# 16 "/usr/include/boost/numeric/conversion/detail/udt_builtin_mixture.hpp" 2 3 4




namespace boost { namespace numeric { namespace convdetail
{

  typedef boost::integral_constant<udt_builtin_mixture_enum, builtin_to_builtin> builtin2builtin_c ;
  typedef boost::integral_constant<udt_builtin_mixture_enum, builtin_to_udt> builtin2udt_c ;
  typedef boost::integral_constant<udt_builtin_mixture_enum, udt_to_builtin> udt2builtin_c ;
  typedef boost::integral_constant<udt_builtin_mixture_enum, udt_to_udt> udt2udt_c ;
# 37 "/usr/include/boost/numeric/conversion/detail/udt_builtin_mixture.hpp" 3 4
  template<class UdtMixture, class BuiltIn2BuiltIn, class BuiltIn2Udt, class Udt2BuiltIn, class Udt2Udt>
  struct for_udt_builtin_mixture
  {
    typedef typename
      ct_switch4<UdtMixture
                 , builtin2builtin_c, builtin2udt_c, udt2builtin_c
                 , BuiltIn2BuiltIn , BuiltIn2Udt , Udt2BuiltIn , Udt2Udt
                >::type
        type ;
  } ;







  template<class T,class S>
  struct get_udt_builtin_mixture
  {
    typedef is_arithmetic<S> S_builtin ;
    typedef is_arithmetic<T> T_builtin ;

    typedef typename
      for_both<S_builtin, T_builtin, builtin2builtin_c, builtin2udt_c, udt2builtin_c, udt2udt_c>::type
        type ;
  } ;

} } }
# 21 "/usr/include/boost/numeric/conversion/detail/conversion_traits.hpp" 2 3 4
# 1 "/usr/include/boost/numeric/conversion/detail/is_subranged.hpp" 1 3 4
# 17 "/usr/include/boost/numeric/conversion/detail/is_subranged.hpp" 3 4
# 1 "/usr/include/boost/mpl/multiplies.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/multiplies.hpp" 3 4
# 1 "/usr/include/boost/mpl/times.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/times.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/arithmetic_op.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/aux_/arithmetic_op.hpp" 3 4
# 1 "/usr/include/boost/mpl/integral_c.hpp" 1 3 4
# 17 "/usr/include/boost/mpl/integral_c.hpp" 3 4
# 1 "/usr/include/boost/mpl/integral_c_fwd.hpp" 1 3 4
# 20 "/usr/include/boost/mpl/integral_c_fwd.hpp" 3 4
namespace mpl_ {





template< typename T, T N > struct integral_c;


}
namespace boost { namespace mpl { using ::mpl_::integral_c; } }
# 18 "/usr/include/boost/mpl/integral_c.hpp" 2 3 4
# 32 "/usr/include/boost/mpl/integral_c.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 1 3 4
# 40 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 3 4
namespace mpl_ {

template< typename T, T N >
struct integral_c
{
    static const T value = N;





    typedef integral_c type;

    typedef T value_type;
    typedef integral_c_tag tag;
# 72 "/usr/include/boost/mpl/aux_/integral_wrapper.hpp" 3 4
    typedef integral_c< T, static_cast<T>((value + 1)) > next;
    typedef integral_c< T, static_cast<T>((value - 1)) > prior;






    constexpr operator T() const { return static_cast<T>(this->value); }
};


template< typename T, T N >
T const integral_c< T, N >::value;


}
# 33 "/usr/include/boost/mpl/integral_c.hpp" 2 3 4




namespace mpl_ {

template< bool C >
struct integral_c<bool, C>
{
    static const bool value = C;
    typedef integral_c_tag tag;
    typedef integral_c type;
    typedef bool value_type;
    operator bool() const { return this->value; }
};
}
# 18 "/usr/include/boost/mpl/aux_/arithmetic_op.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/aux_/largest_int.hpp" 1 3 4
# 22 "/usr/include/boost/mpl/aux_/largest_int.hpp" 3 4
namespace boost { namespace mpl { namespace aux {

template< typename T > struct integral_rank;

template<> struct integral_rank<bool> : int_<1> {};
template<> struct integral_rank<signed char> : int_<2> {};
template<> struct integral_rank<char> : int_<3> {};
template<> struct integral_rank<unsigned char> : int_<4> {};

template<> struct integral_rank<wchar_t> : int_<5> {};

template<> struct integral_rank<short> : int_<6> {};
template<> struct integral_rank<unsigned short> : int_<7> {};
template<> struct integral_rank<int> : int_<8> {};
template<> struct integral_rank<unsigned int> : int_<9> {};
template<> struct integral_rank<long> : int_<10> {};
template<> struct integral_rank<unsigned long> : int_<11> {};


template<> struct integral_rank<long_long_type> : int_<12> {};
template<> struct integral_rank<ulong_long_type>: int_<13> {};


template< typename T1, typename T2 > struct largest_int

    : if_c<
          ( integral_rank<T1>::value >= integral_rank<T2>::value )
        , T1
        , T2
        >
{






};

}}}
# 19 "/usr/include/boost/mpl/aux_/arithmetic_op.hpp" 2 3 4







# 1 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 1 3 4
# 22 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 3 4
# 1 "/usr/include/boost/mpl/apply_wrap.hpp" 1 3 4
# 23 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4
# 27 "/usr/include/boost/mpl/aux_/arithmetic_op.hpp" 2 3 4







# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/times.hpp" 1 3 4
# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/times.hpp" 3 4
namespace boost { namespace mpl {

template<
      typename Tag1
    , typename Tag2
    >
struct times_impl
    : if_c<
          ( Tag1::value
              > Tag2::value
            )

        , aux::cast2nd_impl< times_impl< Tag1,Tag1 >,Tag1, Tag2 >
        , aux::cast1st_impl< times_impl< Tag2,Tag2 >,Tag1, Tag2 >
        >::type
{
};


template<> struct times_impl< na,na >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename Tag > struct times_impl< na,Tag >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename Tag > struct times_impl< Tag,na >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename T > struct times_tag
{
    typedef typename T::tag type;
};

template<
      typename N1 = na
    , typename N2 = na
    , typename N3 = na, typename N4 = na, typename N5 = na
    >
struct times
    : times< times< times< times< N1,N2 >, N3>, N4>, N5>
{





};

template<
      typename N1, typename N2, typename N3, typename N4
    >
struct times< N1,N2,N3,N4,na >

    : times< times< times< N1,N2 >, N3>, N4>
{





};

template<
      typename N1, typename N2, typename N3
    >
struct times< N1,N2,N3,na,na >

    : times< times< N1,N2 >, N3>
{





};

template<
      typename N1, typename N2
    >
struct times< N1,N2,na,na,na >
    : times_impl<
          typename times_tag<N1>::type
        , typename times_tag<N2>::type
        >::template apply< N1,N2 >::type
{






};

template<> struct times< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : times< T1 , T2 > { }; }; template< typename Tag > struct lambda< times< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef times< na , na > result_; typedef times< na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct template_arity< times< T1 , T2 , T3 , T4 , T5 > > : int_<5> { }; template<> struct template_arity< times< na , na > > : int_<-1> { }; }

}}

namespace boost { namespace mpl {
template<>
struct times_impl< integral_c_tag,integral_c_tag >
{
    template< typename N1, typename N2 > struct apply

        : integral_c<
              typename aux::largest_int<
                  typename N1::value_type
                , typename N2::value_type
                >::type
            , ( N1::value
                  * N2::value
                )
            >
    {
    };
};

}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 35 "/usr/include/boost/mpl/aux_/arithmetic_op.hpp" 2 3 4
# 20 "/usr/include/boost/mpl/times.hpp" 2 3 4
# 18 "/usr/include/boost/mpl/multiplies.hpp" 2 3 4








namespace boost { namespace mpl {







template<
      typename N1 = na , typename N2 = na , typename N3 = na , typename N4 = na , typename N5 = na
    >
struct multiplies
    : times< N1 , N2 , N3 , N4 , N5 >
{





};

template<> struct multiplies< na , na , na , na , na > { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct apply : multiplies< T1 , T2 , T3 , T4 , T5 > { }; }; template< typename Tag > struct lambda< multiplies< na , na , na , na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef multiplies< na , na , na , na , na > result_; typedef multiplies< na , na , na , na , na > type; }; namespace aux { template< typename T1 , typename T2 , typename T3 , typename T4 , typename T5 > struct template_arity< multiplies< T1 , T2 , T3 , T4 , T5 > > : int_<5> { }; template<> struct template_arity< multiplies< na , na , na , na , na > > : int_<-1> { }; }



}}
# 18 "/usr/include/boost/numeric/conversion/detail/is_subranged.hpp" 2 3 4
# 1 "/usr/include/boost/mpl/less.hpp" 1 3 4
# 19 "/usr/include/boost/mpl/less.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 1 3 4
# 27 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 1 3 4
# 22 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 3 4
# 1 "/usr/include/boost/mpl/apply_wrap.hpp" 1 3 4
# 23 "/usr/include/boost/mpl/aux_/numeric_op.hpp" 2 3 4
# 28 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 2 3 4







# 1 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 1 3 4
# 37 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/preprocessed/gcc/less.hpp" 1 3 4
# 12 "/usr/include/boost/mpl/aux_/preprocessed/gcc/less.hpp" 3 4
namespace boost { namespace mpl {

template<
      typename Tag1
    , typename Tag2
    >
struct less_impl
    : if_c<
          ( Tag1::value
              > Tag2::value
            )

        , aux::cast2nd_impl< less_impl< Tag1,Tag1 >,Tag1, Tag2 >
        , aux::cast1st_impl< less_impl< Tag2,Tag2 >,Tag1, Tag2 >
        >::type
{
};


template<> struct less_impl< na,na >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename Tag > struct less_impl< na,Tag >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename Tag > struct less_impl< Tag,na >
{
    template< typename U1, typename U2 > struct apply
    {
        typedef apply type;
        static const int value = 0;
    };
};

template< typename T > struct less_tag
{
    typedef typename T::tag type;
};

template<
      typename N1 = na
    , typename N2 = na
    >
struct less

    : less_impl<
          typename less_tag<N1>::type
        , typename less_tag<N2>::type
        >::template apply< N1,N2 >::type
{


};

template<> struct less< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : less< T1 , T2 > { }; }; template< typename Tag > struct lambda< less< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef less< na , na > result_; typedef less< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< less< T1 , T2 > > : int_<2> { }; template<> struct template_arity< less< na , na > > : int_<-1> { }; }

}}

namespace boost { namespace mpl {

template<>
struct less_impl< integral_c_tag,integral_c_tag >
{
    template< typename N1, typename N2 > struct apply

        : bool_< ( N2::value > N1::value ) >
    {
    };
};

}}
# 38 "/usr/include/boost/mpl/aux_/include_preprocessed.hpp" 2 3 4
# 36 "/usr/include/boost/mpl/aux_/comparison_op.hpp" 2 3 4
# 20 "/usr/include/boost/mpl/less.hpp" 2 3 4
# 19 "/usr/include/boost/numeric/conversion/detail/is_subranged.hpp" 2 3 4
# 28 "/usr/include/boost/numeric/conversion/detail/is_subranged.hpp" 3 4
namespace boost { namespace numeric { namespace convdetail
{





    template<class T,class S>
    struct subranged_Sig2Unsig
    {


      typedef mpl::true_ type ;
    } ;


    template<class T,class S>
    struct subranged_Unsig2Sig
    {
# 62 "/usr/include/boost/numeric/conversion/detail/is_subranged.hpp" 3 4
       typedef mpl::int_< ::std::numeric_limits<S>::digits > S_digits ;
       typedef mpl::int_< ::std::numeric_limits<T>::digits > T_digits ;


       typedef typename T_digits::next u_T_digits ;

       typedef mpl::int_<2> Two ;

       typedef typename mpl::multiplies<S_digits,Two>::type S_digits_times_2 ;

       typedef typename mpl::less<u_T_digits,S_digits_times_2>::type type ;
    } ;


    template<class T,class S>
    struct subranged_SameSign
    {


       typedef mpl::int_< ::std::numeric_limits<S>::digits > S_digits ;
       typedef mpl::int_< ::std::numeric_limits<T>::digits > T_digits ;

       typedef typename mpl::less<T_digits,S_digits>::type type ;
    } ;


    template<class T,class S>
    struct subranged_Int2Float
    {
      typedef mpl::false_ type ;
    } ;


    template<class T,class S>
    struct subranged_Float2Int
    {
      typedef mpl::true_ type ;
    } ;


    template<class T,class S>
    struct subranged_Float2Float
    {



      typedef mpl::int_< ::std::numeric_limits<S>::digits > S_mantisa ;
      typedef mpl::int_< ::std::numeric_limits<T>::digits > T_mantisa ;

      typedef mpl::int_< ::std::numeric_limits<S>::max_exponent > S_exponent ;
      typedef mpl::int_< ::std::numeric_limits<T>::max_exponent > T_exponent ;

      typedef typename mpl::less<T_exponent,S_exponent>::type T_smaller_exponent ;

      typedef typename mpl::equal_to<T_exponent,S_exponent>::type equal_exponents ;

      typedef mpl::less<T_mantisa,S_mantisa> T_smaller_mantisa ;

      typedef mpl::eval_if<equal_exponents,T_smaller_mantisa,mpl::false_> not_bigger_exponent_case ;

      typedef typename
        mpl::eval_if<T_smaller_exponent,mpl::true_,not_bigger_exponent_case>::type
          type ;
    } ;


    template<class T,class S>
    struct subranged_Udt2BuiltIn
    {
      typedef mpl::true_ type ;
    } ;


    template<class T,class S>
    struct subranged_BuiltIn2Udt
    {
      typedef mpl::false_ type ;
    } ;


    template<class T,class S>
    struct subranged_Udt2Udt
    {
      typedef mpl::false_ type ;
    } ;





    template<class T,class S>
    struct get_subranged_Int2Int
    {
      typedef subranged_SameSign<T,S> Sig2Sig ;
      typedef subranged_Sig2Unsig<T,S> Sig2Unsig ;
      typedef subranged_Unsig2Sig<T,S> Unsig2Sig ;
      typedef Sig2Sig Unsig2Unsig ;

      typedef typename get_sign_mixture<T,S>::type sign_mixture ;

      typedef typename
        for_sign_mixture<sign_mixture, Sig2Sig, Sig2Unsig, Unsig2Sig, Unsig2Unsig>::type
           type ;
    } ;

    template<class T,class S>
    struct get_subranged_BuiltIn2BuiltIn
    {
      typedef get_subranged_Int2Int<T,S> Int2IntQ ;

      typedef subranged_Int2Float <T,S> Int2Float ;
      typedef subranged_Float2Int <T,S> Float2Int ;
      typedef subranged_Float2Float<T,S> Float2Float ;

      typedef mpl::identity<Int2Float > Int2FloatQ ;
      typedef mpl::identity<Float2Int > Float2IntQ ;
      typedef mpl::identity<Float2Float> Float2FloatQ ;

      typedef typename get_int_float_mixture<T,S>::type int_float_mixture ;

      typedef for_int_float_mixture<int_float_mixture, Int2IntQ, Int2FloatQ, Float2IntQ, Float2FloatQ> for_ ;

      typedef typename for_::type selected ;

      typedef typename selected::type type ;
    } ;

    template<class T,class S>
    struct get_subranged
    {
      typedef get_subranged_BuiltIn2BuiltIn<T,S> BuiltIn2BuiltInQ ;

      typedef subranged_BuiltIn2Udt<T,S> BuiltIn2Udt ;
      typedef subranged_Udt2BuiltIn<T,S> Udt2BuiltIn ;
      typedef subranged_Udt2Udt<T,S> Udt2Udt ;

      typedef mpl::identity<BuiltIn2Udt> BuiltIn2UdtQ ;
      typedef mpl::identity<Udt2BuiltIn> Udt2BuiltInQ ;
      typedef mpl::identity<Udt2Udt > Udt2UdtQ ;

      typedef typename get_udt_builtin_mixture<T,S>::type udt_builtin_mixture ;

      typedef typename
        for_udt_builtin_mixture<udt_builtin_mixture, BuiltIn2BuiltInQ, BuiltIn2UdtQ, Udt2BuiltInQ, Udt2UdtQ>::type
          selected ;

      typedef typename selected::type selected2 ;

      typedef typename selected2::type type ;
    } ;





  template<class T, class S>
  struct get_is_subranged
  {
    typedef get_subranged<T,S> non_trivial_case ;
    typedef mpl::identity<mpl::false_> trivial_case ;

    typedef is_same<T,S> is_trivial ;

    typedef typename mpl::if_<is_trivial,trivial_case,non_trivial_case>::type selected ;

    typedef typename selected::type type ;
  } ;

} } }
# 22 "/usr/include/boost/numeric/conversion/detail/conversion_traits.hpp" 2 3 4

namespace boost { namespace numeric { namespace convdetail
{





  template<class T,class S>
  struct non_trivial_traits_impl
  {
    typedef typename get_int_float_mixture <T,S>::type int_float_mixture ;
    typedef typename get_sign_mixture <T,S>::type sign_mixture ;
    typedef typename get_udt_builtin_mixture <T,S>::type udt_builtin_mixture ;

    typedef typename get_is_subranged<T,S>::type subranged ;

    typedef mpl::false_ trivial ;

    typedef T target_type ;
    typedef S source_type ;
    typedef T result_type ;

    typedef typename mpl::if_< is_arithmetic<S>, S, S const&>::type argument_type ;

    typedef typename mpl::if_<subranged,S,T>::type supertype ;
    typedef typename mpl::if_<subranged,T,S>::type subtype ;
  } ;






  template<class N>
  struct trivial_traits_impl
  {
    typedef typename get_int_float_mixture <N,N>::type int_float_mixture ;
    typedef typename get_sign_mixture <N,N>::type sign_mixture ;
    typedef typename get_udt_builtin_mixture<N,N>::type udt_builtin_mixture ;

    typedef mpl::false_ subranged ;
    typedef mpl::true_ trivial ;

    typedef N target_type ;
    typedef N source_type ;
    typedef N const& result_type ;
    typedef N const& argument_type ;

    typedef N supertype ;
    typedef N subtype ;

  } ;




  template<class T, class S>
  struct get_conversion_traits
  {
    typedef typename remove_cv<T>::type target_type ;
    typedef typename remove_cv<S>::type source_type ;

    typedef typename is_same<target_type,source_type>::type is_trivial ;

    typedef trivial_traits_impl <target_type> trivial_imp ;
    typedef non_trivial_traits_impl<target_type,source_type> non_trivial_imp ;

    typedef typename mpl::if_<is_trivial,trivial_imp,non_trivial_imp>::type type ;
  } ;

} } }
# 14 "/usr/include/boost/numeric/conversion/conversion_traits.hpp" 2 3 4



namespace boost { namespace numeric
{

template<class T, class S>
struct conversion_traits
    : convdetail::get_conversion_traits<T,S>::type
{
} ;

} }
# 14 "/usr/include/boost/numeric/conversion/converter.hpp" 2 3 4
# 1 "/usr/include/boost/numeric/conversion/converter_policies.hpp" 1 3 4
# 25 "/usr/include/boost/numeric/conversion/converter_policies.hpp" 3 4
namespace boost { namespace numeric
{

template<class S>
struct Trunc
{
  typedef S source_type ;

  typedef typename mpl::if_< is_arithmetic<S>,S,S const&>::type argument_type ;

  static source_type nearbyint ( argument_type s )
  {

    using std::floor ;
    using std::ceil ;


    return s < static_cast<S>(0) ? ceil(s) : floor(s) ;
  }

  typedef mpl::integral_c< std::float_round_style, std::round_toward_zero> round_style ;
} ;



template<class S>
struct Floor
{
  typedef S source_type ;

  typedef typename mpl::if_< is_arithmetic<S>,S,S const&>::type argument_type ;

  static source_type nearbyint ( argument_type s )
  {

    using std::floor ;


    return floor(s) ;
  }

  typedef mpl::integral_c< std::float_round_style, std::round_toward_neg_infinity> round_style ;
} ;

template<class S>
struct Ceil
{
  typedef S source_type ;

  typedef typename mpl::if_< is_arithmetic<S>,S,S const&>::type argument_type ;

  static source_type nearbyint ( argument_type s )
  {

    using std::ceil ;


    return ceil(s) ;
  }

  typedef mpl::integral_c< std::float_round_style, std::round_toward_infinity> round_style ;
} ;

template<class S>
struct RoundEven
{
  typedef S source_type ;

  typedef typename mpl::if_< is_arithmetic<S>,S,S const&>::type argument_type ;

  static source_type nearbyint ( argument_type s )
  {



    using std::floor ;
    using std::ceil ;



    S prev = floor(s);
    S next = ceil(s);

    S rt = (s - prev) - (next - s);

    S const zero(0.0);
    S const two(2.0);

    if ( rt < zero )
      return prev;
    else if ( rt > zero )
      return next;
    else
    {
      bool is_prev_even = two * floor(prev / two) == prev ;
      return ( is_prev_even ? prev : next ) ;
    }
  }

  typedef mpl::integral_c< std::float_round_style, std::round_to_nearest> round_style ;
} ;


enum range_check_result
{
  cInRange = 0 ,
  cNegOverflow = 1 ,
  cPosOverflow = 2
} ;

class bad_numeric_cast : public std::bad_cast
{
  public:

    const char * what() const noexcept override
      { return "bad numeric conversion: overflow"; }
};

class negative_overflow : public bad_numeric_cast
{
  public:

    const char * what() const noexcept override
      { return "bad numeric conversion: negative overflow"; }
};
class positive_overflow : public bad_numeric_cast
{
  public:

    const char * what() const noexcept override
      { return "bad numeric conversion: positive overflow"; }
};

struct def_overflow_handler
{
  void operator() ( range_check_result r )
  {

    if ( r == cNegOverflow )
      throw negative_overflow() ;
    else if ( r == cPosOverflow )
           throw positive_overflow() ;






  }
} ;

struct silent_overflow_handler
{
  void operator() ( range_check_result ) {}
} ;

template<class Traits>
struct raw_converter
{
  typedef typename Traits::result_type result_type ;
  typedef typename Traits::argument_type argument_type ;

  static result_type low_level_convert ( argument_type s ) { return static_cast<result_type>(s) ; }
} ;

struct UseInternalRangeChecker {} ;

} }
# 15 "/usr/include/boost/numeric/conversion/converter.hpp" 2 3 4

# 1 "/usr/include/boost/numeric/conversion/detail/converter.hpp" 1 3 4
# 17 "/usr/include/boost/numeric/conversion/detail/converter.hpp" 3 4
# 1 "/usr/include/boost/numeric/conversion/bounds.hpp" 1 3 4
# 13 "/usr/include/boost/numeric/conversion/bounds.hpp" 3 4
# 1 "/usr/include/boost/numeric/conversion/detail/bounds.hpp" 1 3 4
# 17 "/usr/include/boost/numeric/conversion/detail/bounds.hpp" 3 4
namespace boost { namespace numeric { namespace boundsdetail
{
  template<class N>
  class Integral
  {
      typedef std::numeric_limits<N> limits ;

    public :

      static N lowest () { return limits::min (); }
      static N highest () { return limits::max (); }
      static N smallest() { return static_cast<N>(1); }
  } ;

  template<class N>
  class Float
  {
      typedef std::numeric_limits<N> limits ;

    public :

      static N lowest () { return static_cast<N>(-limits::max ()) ; }
      static N highest () { return limits::max (); }
      static N smallest() { return limits::min (); }
  } ;

  template<class N>
  struct get_impl
  {
    typedef mpl::bool_< ::std::numeric_limits<N>::is_integer > is_int ;

    typedef Integral<N> impl_int ;
    typedef Float <N> impl_float ;

    typedef typename mpl::if_<is_int,impl_int,impl_float>::type type ;
  } ;

} } }
# 14 "/usr/include/boost/numeric/conversion/bounds.hpp" 2 3 4

namespace boost { namespace numeric
{

template<class N>
struct bounds : boundsdetail::get_impl<N>::type
{} ;

} }
# 18 "/usr/include/boost/numeric/conversion/detail/converter.hpp" 2 3 4





namespace boost { namespace numeric { namespace convdetail
{

  typedef mpl::integral_c<std::float_round_style, std::round_toward_zero> round2zero_c ;
  typedef mpl::integral_c<std::float_round_style, std::round_to_nearest> round2nearest_c ;
  typedef mpl::integral_c<std::float_round_style, std::round_toward_infinity> round2inf_c ;
  typedef mpl::integral_c<std::float_round_style, std::round_toward_neg_infinity> round2neg_inf_c ;
# 40 "/usr/include/boost/numeric/conversion/detail/converter.hpp" 3 4
  template<class RoundStyle,class RoundToZero,class RoundToNearest,class RoundToInf,class RoundToNegInf>
  struct for_round_style
  {
    typedef ct_switch4<RoundStyle
                       , round2zero_c, round2nearest_c, round2inf_c
                       , RoundToZero , RoundToNearest , RoundToInf , RoundToNegInf
                      > selector ;

    typedef typename selector::type type ;
  } ;
# 81 "/usr/include/boost/numeric/conversion/detail/converter.hpp" 3 4
  struct non_applicable { typedef mpl::false_ do_apply ; } ;
  struct applicable { typedef mpl::true_ do_apply ; } ;
# 96 "/usr/include/boost/numeric/conversion/detail/converter.hpp" 3 4
    template<class Traits>
    struct LT_LoT : applicable
    {
      typedef typename Traits::target_type T ;
      typedef typename Traits::source_type S ;
      typedef typename Traits::argument_type argument_type ;

      static range_check_result apply ( argument_type s )
      {
        return s < static_cast<S>(bounds<T>::lowest()) ? cNegOverflow : cInRange ;
      }
    } ;



    template<class Traits>
    struct LT_Zero : applicable
    {
      typedef typename Traits::source_type S ;
      typedef typename Traits::argument_type argument_type ;

      static range_check_result apply ( argument_type s )
      {
        return s < static_cast<S>(0) ? cNegOverflow : cInRange ;
      }
    } ;



    template<class Traits>
    struct LE_PrevLoT : applicable
    {
      typedef typename Traits::target_type T ;
      typedef typename Traits::source_type S ;
      typedef typename Traits::argument_type argument_type ;

      static range_check_result apply ( argument_type s )
      {
        return s <= static_cast<S>(bounds<T>::lowest()) - static_cast<S>(1.0)
                 ? cNegOverflow : cInRange ;
      }
    } ;



    template<class Traits>
    struct LT_HalfPrevLoT : applicable
    {
      typedef typename Traits::target_type T ;
      typedef typename Traits::source_type S ;
      typedef typename Traits::argument_type argument_type ;

      static range_check_result apply ( argument_type s )
      {
        return s < static_cast<S>(bounds<T>::lowest()) - static_cast<S>(0.5)
                 ? cNegOverflow : cInRange ;
      }
    } ;



    template<class Traits>
    struct GT_HiT : applicable
    {
      typedef typename Traits::target_type T ;
      typedef typename Traits::source_type S ;
      typedef typename Traits::argument_type argument_type ;

      static range_check_result apply ( argument_type s )
      {
        return s > static_cast<S>(bounds<T>::highest())
                 ? cPosOverflow : cInRange ;
      }
    } ;



    template<class Traits>
    struct GE_SuccHiT : applicable
    {
      typedef typename Traits::target_type T ;
      typedef typename Traits::source_type S ;
      typedef typename Traits::argument_type argument_type ;

      static range_check_result apply ( argument_type s )
      {
        return s >= static_cast<S>(bounds<T>::highest()) + static_cast<S>(1.0)
                 ? cPosOverflow : cInRange ;
      }
    } ;



    template<class Traits>
    struct GT_HalfSuccHiT : applicable
    {
      typedef typename Traits::target_type T ;
      typedef typename Traits::source_type S ;
      typedef typename Traits::argument_type argument_type ;

      static range_check_result apply ( argument_type s )
      {
        return s >= static_cast<S>(bounds<T>::highest()) + static_cast<S>(0.5)
                 ? cPosOverflow : cInRange ;
      }
    } ;
# 215 "/usr/include/boost/numeric/conversion/detail/converter.hpp" 3 4
    template<class PredA, class PredB>
    struct applyBoth
    {
      typedef typename PredA::argument_type argument_type ;

      static range_check_result apply ( argument_type s )
      {
        range_check_result r = PredA::apply(s) ;
        if ( r == cInRange )
          r = PredB::apply(s);
        return r ;
      }
    } ;

    template<class PredA, class PredB>
    struct combine
    {
      typedef applyBoth<PredA,PredB> Both ;
      typedef void NNone ;

      typedef typename PredA::do_apply do_applyA ;
      typedef typename PredB::do_apply do_applyB ;

      typedef typename for_both<do_applyA, do_applyB, Both, PredA, PredB, NNone>::type type ;
    } ;
# 262 "/usr/include/boost/numeric/conversion/detail/converter.hpp" 3 4
  template<class Traits>
  struct dummy_range_checker
  {
    typedef typename Traits::argument_type argument_type ;

    static range_check_result out_of_range ( argument_type ) { return cInRange ; }
    static void validate_range ( argument_type ) {}
  } ;
# 279 "/usr/include/boost/numeric/conversion/detail/converter.hpp" 3 4
  template<class Traits, class IsNegOverflow, class IsPosOverflow, class OverflowHandler>
  struct generic_range_checker
  {
    typedef OverflowHandler overflow_handler ;

    typedef typename Traits::argument_type argument_type ;

    static range_check_result out_of_range ( argument_type s )
    {
      typedef typename combine<IsNegOverflow,IsPosOverflow>::type Predicate ;

      return Predicate::apply(s);
    }

    static void validate_range ( argument_type s )
      { OverflowHandler()( out_of_range(s) ) ; }
  } ;
# 305 "/usr/include/boost/numeric/conversion/detail/converter.hpp" 3 4
  template<class Traits,class OverflowHandler>
  struct GetRC_Sig2Sig_or_Unsig2Unsig
  {
    typedef dummy_range_checker<Traits> Dummy ;

    typedef LT_LoT<Traits> Pred1 ;
    typedef GT_HiT<Traits> Pred2 ;

    typedef generic_range_checker<Traits,Pred1,Pred2,OverflowHandler> Normal ;

    typedef typename Traits::subranged subranged ;

    typedef typename mpl::if_<subranged,Normal,Dummy>::type type ;
  } ;

  template<class Traits, class OverflowHandler>
  struct GetRC_Sig2Unsig
  {
    typedef LT_Zero<Traits> Pred1 ;
    typedef GT_HiT <Traits> Pred2 ;

    typedef generic_range_checker<Traits,Pred1,Pred2,OverflowHandler> ChoiceA ;

    typedef generic_range_checker<Traits,Pred1,non_applicable,OverflowHandler> ChoiceB ;

    typedef typename Traits::target_type T ;
    typedef typename Traits::source_type S ;

    typedef typename subranged_Unsig2Sig<S,T>::type oposite_subranged ;

    typedef typename mpl::not_<oposite_subranged>::type positively_subranged ;

    typedef typename mpl::if_<positively_subranged,ChoiceA,ChoiceB>::type type ;
  } ;

  template<class Traits, class OverflowHandler>
  struct GetRC_Unsig2Sig
  {
    typedef GT_HiT<Traits> Pred1 ;

    typedef generic_range_checker<Traits,non_applicable,Pred1,OverflowHandler> type ;
  } ;

  template<class Traits,class OverflowHandler>
  struct GetRC_Int2Int
  {
    typedef GetRC_Sig2Sig_or_Unsig2Unsig<Traits,OverflowHandler> Sig2SigQ ;
    typedef GetRC_Sig2Unsig <Traits,OverflowHandler> Sig2UnsigQ ;
    typedef GetRC_Unsig2Sig <Traits,OverflowHandler> Unsig2SigQ ;
    typedef Sig2SigQ Unsig2UnsigQ ;

    typedef typename Traits::sign_mixture sign_mixture ;

    typedef typename
      for_sign_mixture<sign_mixture,Sig2SigQ,Sig2UnsigQ,Unsig2SigQ,Unsig2UnsigQ>::type
        selector ;

    typedef typename selector::type type ;
  } ;

  template<class Traits>
  struct GetRC_Int2Float
  {
    typedef dummy_range_checker<Traits> type ;
  } ;

  template<class Traits, class OverflowHandler, class Float2IntRounder>
  struct GetRC_Float2Int
  {
    typedef LE_PrevLoT <Traits> Pred1 ;
    typedef GE_SuccHiT <Traits> Pred2 ;
    typedef LT_HalfPrevLoT<Traits> Pred3 ;
    typedef GT_HalfSuccHiT<Traits> Pred4 ;
    typedef GT_HiT <Traits> Pred5 ;
    typedef LT_LoT <Traits> Pred6 ;

    typedef generic_range_checker<Traits,Pred1,Pred2,OverflowHandler> ToZero ;
    typedef generic_range_checker<Traits,Pred3,Pred4,OverflowHandler> ToNearest ;
    typedef generic_range_checker<Traits,Pred1,Pred5,OverflowHandler> ToInf ;
    typedef generic_range_checker<Traits,Pred6,Pred2,OverflowHandler> ToNegInf ;

    typedef typename Float2IntRounder::round_style round_style ;

    typedef typename for_round_style<round_style,ToZero,ToNearest,ToInf,ToNegInf>::type type ;
  } ;

  template<class Traits, class OverflowHandler>
  struct GetRC_Float2Float
  {
    typedef dummy_range_checker<Traits> Dummy ;

    typedef LT_LoT<Traits> Pred1 ;
    typedef GT_HiT<Traits> Pred2 ;

    typedef generic_range_checker<Traits,Pred1,Pred2,OverflowHandler> Normal ;

    typedef typename Traits::subranged subranged ;

    typedef typename mpl::if_<subranged,Normal,Dummy>::type type ;
  } ;

  template<class Traits, class OverflowHandler, class Float2IntRounder>
  struct GetRC_BuiltIn2BuiltIn
  {
    typedef GetRC_Int2Int<Traits,OverflowHandler> Int2IntQ ;
    typedef GetRC_Int2Float<Traits> Int2FloatQ ;
    typedef GetRC_Float2Int<Traits,OverflowHandler,Float2IntRounder> Float2IntQ ;
    typedef GetRC_Float2Float<Traits,OverflowHandler> Float2FloatQ ;

    typedef typename Traits::int_float_mixture int_float_mixture ;

    typedef typename for_int_float_mixture<int_float_mixture, Int2IntQ, Int2FloatQ, Float2IntQ, Float2FloatQ>::type selector ;

    typedef typename selector::type type ;
  } ;

  template<class Traits, class OverflowHandler, class Float2IntRounder>
  struct GetRC
  {
    typedef GetRC_BuiltIn2BuiltIn<Traits,OverflowHandler,Float2IntRounder> BuiltIn2BuiltInQ ;

    typedef dummy_range_checker<Traits> Dummy ;

    typedef mpl::identity<Dummy> DummyQ ;

    typedef typename Traits::udt_builtin_mixture udt_builtin_mixture ;

    typedef typename for_udt_builtin_mixture<udt_builtin_mixture,BuiltIn2BuiltInQ,DummyQ,DummyQ,DummyQ>::type selector ;

    typedef typename selector::type type ;
  } ;
# 452 "/usr/include/boost/numeric/conversion/detail/converter.hpp" 3 4
  template<class Traits>
  struct trivial_converter_impl : public dummy_range_checker<Traits>
  {
    typedef Traits traits ;

    typedef typename Traits::source_type source_type ;
    typedef typename Traits::argument_type argument_type ;
    typedef typename Traits::result_type result_type ;

    static result_type low_level_convert ( argument_type s ) { return s ; }
    static source_type nearbyint ( argument_type s ) { return s ; }
    static result_type convert ( argument_type s ) { return s ; }
  } ;





  template<class Traits,class RangeChecker,class RawConverter,class Float2IntRounder>
  struct rounding_converter : public RangeChecker
                             ,public Float2IntRounder
                             ,public RawConverter
  {
    typedef RangeChecker RangeCheckerBase ;
    typedef Float2IntRounder Float2IntRounderBase ;
    typedef RawConverter RawConverterBase ;

    typedef Traits traits ;

    typedef typename Traits::source_type source_type ;
    typedef typename Traits::argument_type argument_type ;
    typedef typename Traits::result_type result_type ;

    static result_type convert ( argument_type s )
    {
      RangeCheckerBase::validate_range(s);
      source_type s1 = Float2IntRounderBase::nearbyint(s);
      return RawConverterBase::low_level_convert(s1);
    }
  } ;





  template<class Traits,class RangeChecker,class RawConverter>
  struct non_rounding_converter : public RangeChecker
                                 ,public RawConverter
  {
    typedef RangeChecker RangeCheckerBase ;
    typedef RawConverter RawConverterBase ;

    typedef Traits traits ;

    typedef typename Traits::source_type source_type ;
    typedef typename Traits::argument_type argument_type ;
    typedef typename Traits::result_type result_type ;

    static source_type nearbyint ( argument_type s ) { return s ; }

    static result_type convert ( argument_type s )
    {
      RangeCheckerBase::validate_range(s);
      return RawConverterBase::low_level_convert(s);
    }
  } ;
# 528 "/usr/include/boost/numeric/conversion/detail/converter.hpp" 3 4
  template<class Traits,class OverflowHandler,class Float2IntRounder,class RawConverter, class UserRangeChecker>
  struct get_non_trivial_converter
  {
    typedef GetRC<Traits,OverflowHandler,Float2IntRounder> InternalRangeCheckerQ ;

    typedef is_same<UserRangeChecker,UseInternalRangeChecker> use_internal_RC ;

    typedef mpl::identity<UserRangeChecker> UserRangeCheckerQ ;

    typedef typename
      mpl::eval_if<use_internal_RC,InternalRangeCheckerQ,UserRangeCheckerQ>::type
        RangeChecker ;

    typedef non_rounding_converter<Traits,RangeChecker,RawConverter> NonRounding ;
    typedef rounding_converter<Traits,RangeChecker,RawConverter,Float2IntRounder> Rounding ;

    typedef mpl::identity<NonRounding> NonRoundingQ ;
    typedef mpl::identity<Rounding> RoundingQ ;

    typedef typename Traits::int_float_mixture int_float_mixture ;

    typedef typename
      for_int_float_mixture<int_float_mixture, NonRoundingQ, NonRoundingQ, RoundingQ, NonRoundingQ>::type
        selector ;

    typedef typename selector::type type ;
  } ;

  template< class Traits
           ,class OverflowHandler
           ,class Float2IntRounder
           ,class RawConverter
           ,class UserRangeChecker
          >
  struct get_converter_impl
  {
# 574 "/usr/include/boost/numeric/conversion/detail/converter.hpp" 3 4
    typedef trivial_converter_impl<Traits> Trivial ;
    typedef mpl::identity <Trivial> TrivialQ ;

    typedef get_non_trivial_converter< Traits
                                      ,OverflowHandler
                                      ,Float2IntRounder
                                      ,RawConverter
                                      ,UserRangeChecker
                                     > NonTrivialQ ;

    typedef typename Traits::trivial trivial ;

    typedef typename mpl::eval_if<trivial,TrivialQ,NonTrivialQ>::type type ;
  } ;

} } }
# 17 "/usr/include/boost/numeric/conversion/converter.hpp" 2 3 4

namespace boost { namespace numeric
{

template<class T,
         class S,
         class Traits = conversion_traits<T,S>,
         class OverflowHandler = def_overflow_handler,
         class Float2IntRounder = Trunc< typename Traits::source_type> ,
         class RawConverter = raw_converter<Traits>,
         class UserRangeChecker = UseInternalRangeChecker
        >
struct converter : convdetail::get_converter_impl<Traits,
                                                  OverflowHandler,
                                                  Float2IntRounder,
                                                  RawConverter,
                                                  UserRangeChecker
                                                 >::type
{
  typedef Traits traits ;

  typedef typename Traits::argument_type argument_type ;
  typedef typename Traits::result_type result_type ;

  result_type operator() ( argument_type s ) const { return this->convert(s) ; }
} ;



template<class S,
         class OverflowHandler = def_overflow_handler,
         class Float2IntRounder = Trunc<S> ,
         class UserRangeChecker = UseInternalRangeChecker
        >
struct make_converter_from
{
  template<class T,
           class Traits = conversion_traits<T,S>,
           class RawConverter = raw_converter<Traits>
          >
  struct to
  {
    typedef converter<T,S,Traits,OverflowHandler,Float2IntRounder,RawConverter,UserRangeChecker> type ;
  } ;

} ;

} }
# 34 "/usr/include/boost/numeric/conversion/cast.hpp" 2 3 4
# 1 "/usr/include/boost/numeric/conversion/numeric_cast_traits.hpp" 1 3 4
# 14 "/usr/include/boost/numeric/conversion/numeric_cast_traits.hpp" 3 4
namespace boost { namespace numeric {

    template <typename Target, typename Source, typename EnableIf = void>
    struct numeric_cast_traits
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<Source> rounding_policy;
    };

}}


# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 28 "/usr/include/boost/numeric/conversion/numeric_cast_traits.hpp" 2 3 4
# 1 "/usr/include/boost/numeric/conversion/detail/numeric_cast_traits.hpp" 1 3 4
# 12 "/usr/include/boost/numeric/conversion/detail/numeric_cast_traits.hpp" 3 4
# 1 "/usr/include/boost/numeric/conversion/detail/preprocessed/numeric_cast_traits_common.hpp" 1 3 4
# 12 "/usr/include/boost/numeric/conversion/detail/preprocessed/numeric_cast_traits_common.hpp" 3 4
namespace boost { namespace numeric {

    template <>
    struct numeric_cast_traits
        <
            char
          , char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            char
          , signed char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<signed char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            char
          , unsigned char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            char
          , short
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<short> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            char
          , unsigned short
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned short> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            char
          , int
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<int> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            char
          , unsigned int
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned int> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            char
          , long
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            char
          , unsigned long
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned long> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            char
          , float
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<float> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            char
          , double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            char
          , long double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            signed char
          , char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            signed char
          , signed char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<signed char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            signed char
          , unsigned char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            signed char
          , short
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<short> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            signed char
          , unsigned short
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned short> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            signed char
          , int
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<int> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            signed char
          , unsigned int
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned int> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            signed char
          , long
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            signed char
          , unsigned long
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned long> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            signed char
          , float
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<float> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            signed char
          , double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            signed char
          , long double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned char
          , char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned char
          , signed char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<signed char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned char
          , unsigned char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned char
          , short
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<short> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned char
          , unsigned short
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned short> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned char
          , int
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<int> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned char
          , unsigned int
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned int> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned char
          , long
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned char
          , unsigned long
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned long> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned char
          , float
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<float> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned char
          , double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned char
          , long double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            short
          , char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            short
          , signed char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<signed char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            short
          , unsigned char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            short
          , short
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<short> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            short
          , unsigned short
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned short> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            short
          , int
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<int> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            short
          , unsigned int
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned int> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            short
          , long
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            short
          , unsigned long
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned long> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            short
          , float
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<float> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            short
          , double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            short
          , long double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned short
          , char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned short
          , signed char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<signed char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned short
          , unsigned char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned short
          , short
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<short> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned short
          , unsigned short
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned short> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned short
          , int
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<int> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned short
          , unsigned int
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned int> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned short
          , long
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned short
          , unsigned long
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned long> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned short
          , float
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<float> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned short
          , double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned short
          , long double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            int
          , char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            int
          , signed char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<signed char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            int
          , unsigned char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            int
          , short
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<short> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            int
          , unsigned short
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned short> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            int
          , int
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<int> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            int
          , unsigned int
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned int> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            int
          , long
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            int
          , unsigned long
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned long> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            int
          , float
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<float> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            int
          , double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            int
          , long double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned int
          , char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned int
          , signed char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<signed char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned int
          , unsigned char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned int
          , short
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<short> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned int
          , unsigned short
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned short> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned int
          , int
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<int> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned int
          , unsigned int
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned int> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned int
          , long
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned int
          , unsigned long
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned long> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned int
          , float
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<float> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned int
          , double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned int
          , long double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long
          , char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long
          , signed char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<signed char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long
          , unsigned char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long
          , short
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<short> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long
          , unsigned short
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned short> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long
          , int
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<int> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long
          , unsigned int
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned int> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long
          , long
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long
          , unsigned long
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned long> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long
          , float
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<float> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long
          , double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long
          , long double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned long
          , char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned long
          , signed char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<signed char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned long
          , unsigned char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned long
          , short
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<short> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned long
          , unsigned short
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned short> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned long
          , int
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<int> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned long
          , unsigned int
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned int> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned long
          , long
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned long
          , unsigned long
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned long> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned long
          , float
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<float> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned long
          , double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned long
          , long double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            float
          , char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            float
          , signed char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<signed char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            float
          , unsigned char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            float
          , short
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<short> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            float
          , unsigned short
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned short> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            float
          , int
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<int> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            float
          , unsigned int
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned int> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            float
          , long
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            float
          , unsigned long
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned long> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            float
          , float
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<float> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            float
          , double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            float
          , long double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            double
          , char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            double
          , signed char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<signed char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            double
          , unsigned char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            double
          , short
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<short> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            double
          , unsigned short
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned short> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            double
          , int
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<int> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            double
          , unsigned int
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned int> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            double
          , long
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            double
          , unsigned long
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned long> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            double
          , float
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<float> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            double
          , double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            double
          , long double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long double
          , char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long double
          , signed char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<signed char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long double
          , unsigned char
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned char> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long double
          , short
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<short> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long double
          , unsigned short
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned short> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long double
          , int
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<int> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long double
          , unsigned int
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned int> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long double
          , long
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long double
          , unsigned long
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<unsigned long> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long double
          , float
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<float> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long double
          , double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<double> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long double
          , long double
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<long double> rounding_policy;
    };
}}
# 13 "/usr/include/boost/numeric/conversion/detail/numeric_cast_traits.hpp" 2 3 4


# 1 "/usr/include/boost/numeric/conversion/detail/preprocessed/numeric_cast_traits_long_long.hpp" 1 3 4








namespace boost { namespace numeric {


    template <>
    struct numeric_cast_traits
        <
            char
          , boost::long_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::long_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            char
          , boost::ulong_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::ulong_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            signed char
          , boost::long_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::long_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            signed char
          , boost::ulong_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::ulong_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned char
          , boost::long_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::long_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned char
          , boost::ulong_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::ulong_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            short
          , boost::long_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::long_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            short
          , boost::ulong_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::ulong_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned short
          , boost::long_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::long_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned short
          , boost::ulong_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::ulong_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            int
          , boost::long_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::long_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            int
          , boost::ulong_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::ulong_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned int
          , boost::long_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::long_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned int
          , boost::ulong_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::ulong_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long
          , boost::long_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::long_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long
          , boost::ulong_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::ulong_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned long
          , boost::long_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::long_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            unsigned long
          , boost::ulong_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::ulong_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            float
          , boost::long_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::long_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            float
          , boost::ulong_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::ulong_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            double
          , boost::long_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::long_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            double
          , boost::ulong_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::ulong_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long double
          , boost::long_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::long_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            long double
          , boost::ulong_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::ulong_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::long_long_type
          , boost::long_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::long_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::long_long_type
          , boost::ulong_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::ulong_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::ulong_long_type
          , boost::long_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::long_long_type> rounding_policy;
    };

    template <>
    struct numeric_cast_traits
        <
            boost::ulong_long_type
          , boost::ulong_long_type
        >
    {
        typedef def_overflow_handler overflow_policy;
        typedef UseInternalRangeChecker range_checking_policy;
        typedef Trunc<boost::ulong_long_type> rounding_policy;
    };
}}
# 16 "/usr/include/boost/numeric/conversion/detail/numeric_cast_traits.hpp" 2 3 4
# 29 "/usr/include/boost/numeric/conversion/numeric_cast_traits.hpp" 2 3 4
# 35 "/usr/include/boost/numeric/conversion/cast.hpp" 2 3 4

namespace boost
{
    template <typename Target, typename Source>
    inline Target numeric_cast( Source arg )
    {
        typedef numeric::conversion_traits<Target, Source> conv_traits;
        typedef numeric::numeric_cast_traits<Target, Source> cast_traits;
        typedef boost::numeric::converter
            <
                Target,
                Source,
                conv_traits,
                typename cast_traits::overflow_policy,
                typename cast_traits::rounding_policy,
                boost::numeric::raw_converter< conv_traits >,
                typename cast_traits::range_checking_policy
            > converter;
        return converter::convert(arg);
    }

    using numeric::bad_numeric_cast;
}
# 16 "/usr/include/boost/date_time/posix_time/posix_time_duration.hpp" 2 3 4


namespace boost {
namespace posix_time {





  class __attribute__((__visibility__("default"))) hours : public time_duration
  {
  public:
      template <typename T>
      constexpr explicit hours(T const& h,
          typename boost::enable_if<boost::is_integral<T>, void>::type* = nullptr) :
      time_duration(numeric_cast<hour_type>(h), 0, 0)
    {}
  };





  class __attribute__((__visibility__("default"))) minutes : public time_duration
  {
  public:
      template <typename T>
      constexpr explicit minutes(T const& m,
          typename boost::enable_if<boost::is_integral<T>, void>::type* = nullptr) :
      time_duration(0, numeric_cast<min_type>(m),0)
    {}
  };





  class __attribute__((__visibility__("default"))) seconds : public time_duration
  {
  public:
      template <typename T>
      constexpr explicit seconds(T const& s,
          typename boost::enable_if<boost::is_integral<T>, void>::type* = nullptr) :
      time_duration(0,0, numeric_cast<sec_type>(s))
    {}
  };





  typedef date_time::subsecond_duration<time_duration,1000> millisec;
  typedef date_time::subsecond_duration<time_duration,1000> milliseconds;




  typedef date_time::subsecond_duration<time_duration,1000000> microsec;
  typedef date_time::subsecond_duration<time_duration,1000000> microseconds;
# 87 "/usr/include/boost/date_time/posix_time/posix_time_duration.hpp" 3 4
} }
# 17 "/usr/include/boost/date_time/posix_time/posix_time_types.hpp" 2 3 4

# 1 "/usr/include/boost/date_time/posix_time/time_period.hpp" 1 3 4
# 16 "/usr/include/boost/date_time/posix_time/time_period.hpp" 3 4
namespace boost {
namespace posix_time {




  typedef date_time::period<ptime, time_duration> time_period;


} }
# 19 "/usr/include/boost/date_time/posix_time/posix_time_types.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/time_iterator.hpp" 1 3 4
# 13 "/usr/include/boost/date_time/time_iterator.hpp" 3 4
namespace boost {
namespace date_time {



  template<class time_type>
  class time_itr {
  public:
    typedef typename time_type::time_duration_type time_duration_type;
    time_itr(time_type t, time_duration_type d) : current_(t), offset_(d) {}
    time_itr& operator++()
    {
      current_ = current_ + offset_;
      return *this;
    }
    time_itr& operator--()
    {
      current_ = current_ - offset_;
      return *this;
    }
    const time_type& operator*() const {return current_;}
    const time_type* operator->() const {return &current_;}
    bool operator< (const time_type& t) const {return current_ < t;}
    bool operator<= (const time_type& t) const {return current_ <= t;}
    bool operator!= (const time_type& t) const {return current_ != t;}
    bool operator== (const time_type& t) const {return current_ == t;}
    bool operator> (const time_type& t) const {return current_ > t;}
    bool operator>= (const time_type& t) const {return current_ >= t;}

  private:
    time_type current_;
    time_duration_type offset_;
  };



} }
# 20 "/usr/include/boost/date_time/posix_time/posix_time_types.hpp" 2 3 4
# 1 "/usr/include/boost/date_time/dst_rules.hpp" 1 3 4
# 21 "/usr/include/boost/date_time/dst_rules.hpp" 3 4
namespace boost {
  namespace date_time {

    enum time_is_dst_result {is_not_in_dst, is_in_dst,
                             ambiguous, invalid_time_label};



    template<class date_type_,
             class time_duration_type_>
    class dst_calculator
    {
    public:
      typedef time_duration_type_ time_duration_type;
      typedef date_type_ date_type;
# 47 "/usr/include/boost/date_time/dst_rules.hpp" 3 4
      static time_is_dst_result
      process_local_dst_start_day(const time_duration_type& time_of_day,
                                  unsigned int dst_start_offset_minutes,
                                  long dst_length_minutes)
      {

        if (time_of_day < time_duration_type(0,dst_start_offset_minutes,0)) {
          return is_not_in_dst;
        }
        long offset = dst_start_offset_minutes + dst_length_minutes;
        if (time_of_day >= time_duration_type(0,offset,0)) {
          return is_in_dst;
        }
        return invalid_time_label;
      }
# 72 "/usr/include/boost/date_time/dst_rules.hpp" 3 4
      static time_is_dst_result
      process_local_dst_end_day(const time_duration_type& time_of_day,
                                unsigned int dst_end_offset_minutes,
                                long dst_length_minutes)
      {

        int offset = dst_end_offset_minutes-dst_length_minutes;
        if (time_of_day < time_duration_type(0,offset,0)) {
          return is_in_dst;
        }
        if (time_of_day >= time_duration_type(0,dst_end_offset_minutes,0)) {
          return is_not_in_dst;
        }
        return ambiguous;
      }
# 100 "/usr/include/boost/date_time/dst_rules.hpp" 3 4
      static time_is_dst_result
      local_is_dst(const date_type& current_day,
                   const time_duration_type& time_of_day,
                   const date_type& dst_start_day,
                   const time_duration_type& dst_start_offset,
                   const date_type& dst_end_day,
                   const time_duration_type& dst_end_offset,
                   const time_duration_type& dst_length)
      {
        unsigned int start_minutes = static_cast<unsigned>(
          dst_start_offset.hours() * 60 + dst_start_offset.minutes());
        unsigned int end_minutes = static_cast<unsigned>(
          dst_end_offset.hours() * 60 + dst_end_offset.minutes());
        long length_minutes = static_cast<long>(
          dst_length.hours() * 60 + dst_length.minutes());

        return local_is_dst(current_day, time_of_day,
                            dst_start_day, start_minutes,
                            dst_end_day, end_minutes,
                            length_minutes);
      }
# 136 "/usr/include/boost/date_time/dst_rules.hpp" 3 4
      static time_is_dst_result
      local_is_dst(const date_type& current_day,
                   const time_duration_type& time_of_day,
                   const date_type& dst_start_day,
                   unsigned int dst_start_offset_minutes,
                   const date_type& dst_end_day,
                   unsigned int dst_end_offset_minutes,
                   long dst_length_minutes)
      {

        if (dst_start_day < dst_end_day) {
          if ((current_day > dst_start_day) && (current_day < dst_end_day)) {
            return is_in_dst;
          }
          if ((current_day < dst_start_day) || (current_day > dst_end_day)) {
            return is_not_in_dst;
          }
        }
        else {
          if ((current_day < dst_start_day) && (current_day > dst_end_day)) {
            return is_not_in_dst;
          }
          if ((current_day > dst_start_day) || (current_day < dst_end_day)) {
            return is_in_dst;
          }
        }

        if (current_day == dst_start_day) {
          return process_local_dst_start_day(time_of_day,
                                             dst_start_offset_minutes,
                                             dst_length_minutes);
        }

        if (current_day == dst_end_day) {
          return process_local_dst_end_day(time_of_day,
                                           dst_end_offset_minutes,
                                           dst_length_minutes);
        }

        return invalid_time_label;
      }

    };
# 208 "/usr/include/boost/date_time/dst_rules.hpp" 3 4
    template<class date_type,
             class time_duration_type,
             class dst_traits>
    class dst_calc_engine
    {
    public:
      typedef typename date_type::year_type year_type;
      typedef typename date_type::calendar_type calendar_type;
      typedef dst_calculator<date_type, time_duration_type> dstcalc;






      static time_is_dst_result local_is_dst(const date_type& d,
                                             const time_duration_type& td)
      {

        year_type y = d.year();
        date_type dst_start = local_dst_start_day(y);
        date_type dst_end = local_dst_end_day(y);
        return dstcalc::local_is_dst(d,td,
                                     dst_start,
                                     dst_traits::dst_start_offset_minutes(),
                                     dst_end,
                                     dst_traits::dst_end_offset_minutes(),
                                     dst_traits::dst_shift_length_minutes());

      }

      static bool is_dst_boundary_day(date_type d)
      {
        year_type y = d.year();
        return ((d == local_dst_start_day(y)) ||
                (d == local_dst_end_day(y)));
      }


      static time_duration_type dst_offset()
      {
        return time_duration_type(0,dst_traits::dst_shift_length_minutes(),0);
      }

      static date_type local_dst_start_day(year_type year)
      {
        return dst_traits::local_dst_start_day(year);
      }

      static date_type local_dst_end_day(year_type year)
      {
        return dst_traits::local_dst_end_day(year);
      }


    };






    template<class date_type_,
             class time_duration_type_,
             unsigned int dst_start_offset_minutes=120,
             short dst_length_minutes=60>
    class us_dst_rules
    {
    public:
      typedef time_duration_type_ time_duration_type;
      typedef date_type_ date_type;
      typedef typename date_type::year_type year_type;
      typedef typename date_type::calendar_type calendar_type;
      typedef date_time::last_kday_of_month<date_type> lkday;
      typedef date_time::first_kday_of_month<date_type> fkday;
      typedef date_time::nth_kday_of_month<date_type> nkday;
      typedef dst_calculator<date_type, time_duration_type> dstcalc;






      static time_is_dst_result local_is_dst(const date_type& d,
                                             const time_duration_type& td)
      {

        year_type y = d.year();
        date_type dst_start = local_dst_start_day(y);
        date_type dst_end = local_dst_end_day(y);
        return dstcalc::local_is_dst(d,td,
                                     dst_start,dst_start_offset_minutes,
                                     dst_end, dst_start_offset_minutes,
                                     dst_length_minutes);

      }


      static bool is_dst_boundary_day(date_type d)
      {
        year_type y = d.year();
        return ((d == local_dst_start_day(y)) ||
                (d == local_dst_end_day(y)));
      }

      static date_type local_dst_start_day(year_type year)
      {
        if (year >= year_type(2007)) {

          nkday ssim(nkday::second, Sunday, date_time::Mar);
          return ssim.get_date(year);
        } else {

          fkday fsia(Sunday, date_time::Apr);
          return fsia.get_date(year);
        }
      }

      static date_type local_dst_end_day(year_type year)
      {
        if (year >= year_type(2007)) {

          fkday fsin(Sunday, date_time::Nov);
          return fsin.get_date(year);
        } else {

          lkday lsio(Sunday, date_time::Oct);
          return lsio.get_date(year);
        }
      }

      static time_duration_type dst_offset()
      {
        return time_duration_type(0,dst_length_minutes,0);
      }

     private:


    };


    template<class date_type_, class time_duration_type_>
    class null_dst_rules
    {
    public:
      typedef time_duration_type_ time_duration_type;
      typedef date_type_ date_type;





      static time_is_dst_result local_is_dst(const date_type&,
                                             const time_duration_type&)
      {
        return is_not_in_dst;
      }


      static time_is_dst_result utc_is_dst(const date_type&,
                                           const time_duration_type&)
      {
        return is_not_in_dst;
      }

      static bool is_dst_boundary_day(date_type )
      {
        return false;
      }

      static time_duration_type dst_offset()
      {
        return time_duration_type(0,0,0);
      }

    };


  } }
# 21 "/usr/include/boost/date_time/posix_time/posix_time_types.hpp" 2 3 4

namespace boost {


namespace posix_time {




  typedef date_time::time_itr<ptime> time_iterator;



  typedef date_time::second_clock<ptime> second_clock;





  typedef date_time::microsec_clock<ptime> microsec_clock;



  typedef date_time::null_dst_rules<ptime::date_type, time_duration> no_dst;

  typedef date_time::us_dst_rules<ptime::date_type, time_duration> us_dst;


} }
# 12 "/usr/include/boost/thread/thread_time.hpp" 2 3 4

# 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
# 14 "/usr/include/boost/thread/thread_time.hpp" 2 3 4

namespace boost
{
    typedef boost::posix_time::ptime system_time;

    inline system_time get_system_time()
    {

        return boost::date_time::microsec_clock<system_time>::universal_time();



    }

    namespace detail
    {
        inline system_time get_system_time_sentinel()
        {
            return system_time(boost::posix_time::pos_infin);
        }

        inline unsigned long get_milliseconds_until(system_time const& target_time)
        {
            if(target_time.is_pos_infinity())
            {
                return ~(unsigned long)0;
            }
            system_time const now=get_system_time();
            if(target_time<=now)
            {
                return 0;
            }
            return static_cast<unsigned long>((target_time-now).total_milliseconds()+1);
        }

    }

}

# 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
# 54 "/usr/include/boost/thread/thread_time.hpp" 2 3 4
# 19 "/usr/include/boost/thread/lock_types.hpp" 2 3 4

# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 58 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 59 "/usr/include/boost/assert.hpp" 2 3 4
# 21 "/usr/include/boost/thread/lock_types.hpp" 2 3 4

# 1 "/usr/include/boost/chrono/time_point.hpp" 1 3 4
# 33 "/usr/include/boost/chrono/time_point.hpp" 3 4
# 1 "/usr/include/boost/chrono/duration.hpp" 1 3 4
# 33 "/usr/include/boost/chrono/duration.hpp" 3 4
# 1 "/usr/include/boost/chrono/config.hpp" 1 3 4
# 15 "/usr/include/boost/chrono/config.hpp" 3 4
# 1 "/usr/include/boost/chrono/detail/requires_cxx11.hpp" 1 3 4
# 16 "/usr/include/boost/chrono/config.hpp" 2 3 4

# 1 "/usr/include/boost/predef.h" 1 3 4
# 18 "/usr/include/boost/chrono/config.hpp" 2 3 4
# 213 "/usr/include/boost/chrono/config.hpp" 3 4
# 1 "/usr/include/boost/config/auto_link.hpp" 1 3 4
# 214 "/usr/include/boost/chrono/config.hpp" 2 3 4
# 34 "/usr/include/boost/chrono/duration.hpp" 2 3 4
# 1 "/usr/include/boost/chrono/detail/static_assert.hpp" 1 3 4
# 35 "/usr/include/boost/chrono/duration.hpp" 2 3 4

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/climits" 1 3 4
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/climits" 3
# 37 "/usr/include/boost/chrono/duration.hpp" 2 3 4




# 1 "/usr/include/boost/ratio/ratio.hpp" 1 3 4
# 35 "/usr/include/boost/ratio/ratio.hpp" 3 4
# 1 "/usr/include/boost/ratio/config.hpp" 1 3 4
# 12 "/usr/include/boost/ratio/config.hpp" 3 4
# 1 "/usr/include/boost/ratio/detail/requires_cxx11.hpp" 1 3 4
# 13 "/usr/include/boost/ratio/config.hpp" 2 3 4


# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 16 "/usr/include/boost/ratio/config.hpp" 2 3 4
# 36 "/usr/include/boost/ratio/ratio.hpp" 2 3 4
# 1 "/usr/include/boost/ratio/detail/mpl/abs.hpp" 1 3 4
# 32 "/usr/include/boost/ratio/detail/mpl/abs.hpp" 3 4
namespace boost { namespace mpl {

template< typename Tag > struct abs_impl;

template< typename T > struct abs_tag
{
    typedef typename T::tag type;
};

template<
      typename N = na
    >
struct abs
    : abs_impl<
          typename abs_tag<N>::type
        >::template apply<N>::type
{

};

template<> struct abs< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : abs< T1 > { }; }; template< typename Tag > struct lambda< abs< na > , Tag , int_<-1> > { typedef false_ is_le; typedef abs< na > result_; typedef abs< na > type; }; namespace aux { template< typename T1 > struct template_arity< abs< T1 > > : int_<1> { }; template<> struct template_arity< abs< na > > : int_<-1> { }; }

template<
      typename T
    , T n1
    >
struct abs_c
    : abs<integral_c<T,n1> >
{
};
# 73 "/usr/include/boost/ratio/detail/mpl/abs.hpp" 3 4
template<>
struct abs_impl<integral_c_tag>
{




    template< typename N > struct apply
        : integral_c< typename N::value_type, ((N::value < 0) ? (-N::value) : N::value ) >

    {
    };
};

}}
# 37 "/usr/include/boost/ratio/ratio.hpp" 2 3 4
# 1 "/usr/include/boost/ratio/detail/mpl/sign.hpp" 1 3 4
# 32 "/usr/include/boost/ratio/detail/mpl/sign.hpp" 3 4
namespace boost { namespace mpl {

template< typename Tag > struct sign_impl;

template< typename T > struct sign_tag
{
    typedef typename T::tag type;
};

template<
      typename N = na
    >
struct sign
    : sign_impl<
          typename sign_tag<N>::type
        >::template apply<N>::type
{

};

template<> struct sign< na > { template< typename T1 , typename T2 =na , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : sign< T1 > { }; }; template< typename Tag > struct lambda< sign< na > , Tag , int_<-1> > { typedef false_ is_le; typedef sign< na > result_; typedef sign< na > type; }; namespace aux { template< typename T1 > struct template_arity< sign< T1 > > : int_<1> { }; template<> struct template_arity< sign< na > > : int_<-1> { }; }

template<
      typename T
    , T n1
    >
struct sign_c
    : sign<integral_c<T,n1> >
{
};
# 73 "/usr/include/boost/ratio/detail/mpl/sign.hpp" 3 4
template<>
struct sign_impl<integral_c_tag>
{




    template< typename N > struct apply
        : integral_c< typename N::value_type, (N::value == 0 ? 0 : (N::value < 0 ? -1 : 1)) >

    {
    };
};

}}
# 38 "/usr/include/boost/ratio/ratio.hpp" 2 3 4
# 1 "/usr/include/boost/ratio/detail/mpl/gcd.hpp" 1 3 4
# 22 "/usr/include/boost/ratio/detail/mpl/gcd.hpp" 3 4
# 1 "/usr/include/boost/mpl/aux_/config/dependent_nttp.hpp" 1 3 4
# 23 "/usr/include/boost/ratio/detail/mpl/gcd.hpp" 2 3 4
# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 24 "/usr/include/boost/ratio/detail/mpl/gcd.hpp" 2 3 4
# 36 "/usr/include/boost/ratio/detail/mpl/gcd.hpp" 3 4
namespace boost { namespace mpl {

template< typename Tag1, typename Tag2 > struct gcd_impl;

template< typename T > struct gcd_tag
{
    typedef typename T::tag type;
};

template<
      typename N1 = na
    , typename N2 = na
    >
struct gcd
    : gcd_impl<
          typename gcd_tag<N1>::type
        , typename gcd_tag<N2>::type
        >::template apply<N1, N2>::type
{

};

template<> struct gcd< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : gcd< T1 , T2 > { }; }; template< typename Tag > struct lambda< gcd< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef gcd< na , na > result_; typedef gcd< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< gcd< T1 , T2 > > : int_<2> { }; template<> struct template_arity< gcd< na , na > > : int_<-1> { }; }

template<
      typename T
    , T n1
    , T n2
    >
struct gcd_c
    : gcd<integral_c<T,n1>,integral_c<T,n2> >
{
};

namespace aux {






  template< typename T1, boost::intmax_t n1, bool n1_is_0
                  , typename T2, boost::intmax_t n2, bool n2_is_0 >
      struct gcd_aux
          : gcd_aux<T2, n2, n2==0, T1, (n1 % n2), (n1 % n2)==0>
      {};

      template <typename T1, boost::intmax_t n1, typename T2, boost::intmax_t n2>
      struct gcd_aux<T1, n1, false, T2, n2, true> : integral_c<T1, n1>
      {};

      template <typename T1, boost::intmax_t n1, typename T2, boost::intmax_t n2, bool C>
      struct gcd_aux<T1, n1, true, T2, n2, C> : integral_c<T2, n2>
      {};
# 110 "/usr/include/boost/ratio/detail/mpl/gcd.hpp" 3 4
}

template<>
struct gcd_impl<integral_c_tag, integral_c_tag>
{
    template< typename N1, typename N2 > struct apply
        : abs<aux::gcd_aux< typename N1::value_type, N1::value, N1::value==0,
                        typename N2::value_type, N2::value, N2::value==0 > >
    {
    };
};

}}
# 39 "/usr/include/boost/ratio/ratio.hpp" 2 3 4
# 1 "/usr/include/boost/ratio/detail/mpl/lcm.hpp" 1 3 4
# 23 "/usr/include/boost/ratio/detail/mpl/lcm.hpp" 3 4
# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 24 "/usr/include/boost/ratio/detail/mpl/lcm.hpp" 2 3 4
# 36 "/usr/include/boost/ratio/detail/mpl/lcm.hpp" 3 4
namespace boost { namespace mpl {

template< typename Tag1, typename Tag2 > struct lcm_impl;

template< typename T > struct lcm_tag
{
    typedef typename T::tag type;
};

template<
      typename N1 = na
    , typename N2 = na
    >
struct lcm
    : lcm_impl<
          typename lcm_tag<N1>::type
        , typename lcm_tag<N2>::type
        >::template apply<N1, N2>::type
{

};

template<> struct lcm< na , na > { template< typename T1 , typename T2 , typename T3 =na , typename T4 =na , typename T5 =na > struct apply : lcm< T1 , T2 > { }; }; template< typename Tag > struct lambda< lcm< na , na > , Tag , int_<-1> > { typedef false_ is_le; typedef lcm< na , na > result_; typedef lcm< na , na > type; }; namespace aux { template< typename T1 , typename T2 > struct template_arity< lcm< T1 , T2 > > : int_<2> { }; template<> struct template_arity< lcm< na , na > > : int_<-1> { }; }

template<
      typename T
    , T n1
    , T n2
    >
struct lcm_c
    : lcm<integral_c<T,n1>,integral_c<T,n2> >
{
};


namespace aux {




  template< typename T1, boost::intmax_t n1, bool n1_is_0
                          , typename T2, boost::intmax_t n2, bool n2_is_0 >
      struct lcm_aux
          : abs<integral_c< typename aux::largest_int<T1, T2>::type,
              ( n1 / gcd<integral_c<T1,n1>, integral_c<T2,n2> >::value * n2 )
          > >
      {};

      template <typename T1, boost::intmax_t n1, typename T2, boost::intmax_t n2>
      struct lcm_aux<T1, n1, false, T2, n2, true> : integral_c<T2, 0>
      {};

      template <typename T1, boost::intmax_t n1, typename T2, boost::intmax_t n2, bool C>
      struct lcm_aux<T1, n1, true, T2, n2, C> : integral_c<T1, 0>
      {};
# 112 "/usr/include/boost/ratio/detail/mpl/lcm.hpp" 3 4
}

template<>
struct lcm_impl<integral_c_tag, integral_c_tag>
{
    template< typename N1, typename N2 > struct apply
        : abs<aux::lcm_aux< typename N1::value_type, N1::value, N1::value==0,
                        typename N2::value_type, N2::value, N2::value==0 > >
    {
    };
};

}}
# 40 "/usr/include/boost/ratio/ratio.hpp" 2 3 4
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdlib" 1 3 4
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdlib" 3
# 41 "/usr/include/boost/ratio/ratio.hpp" 2 3 4
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/climits" 1 3 4
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/climits" 3
# 42 "/usr/include/boost/ratio/ratio.hpp" 2 3 4

# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 44 "/usr/include/boost/ratio/ratio.hpp" 2 3 4


# 1 "/usr/include/boost/integer_traits.hpp" 1 3 4
# 40 "/usr/include/boost/integer_traits.hpp" 3


namespace boost {
template<class T>
class integer_traits : public std::numeric_limits<T>
{
public:
  static const bool is_integral = false;
};

namespace detail {
template<class T, T min_val, T max_val>
class integer_traits_base
{
public:
  static const bool is_integral = true;
  static const T const_min = min_val;
  static const T const_max = max_val;
};



template<class T, T min_val, T max_val>
const bool integer_traits_base<T, min_val, max_val>::is_integral;

template<class T, T min_val, T max_val>
const T integer_traits_base<T, min_val, max_val>::const_min;

template<class T, T min_val, T max_val>
const T integer_traits_base<T, min_val, max_val>::const_max;


}

template<>
class integer_traits<bool>
  : public std::numeric_limits<bool>,
    public detail::integer_traits_base<bool, false, true>
{ };

template<>
class integer_traits<char>
  : public std::numeric_limits<char>,
    public detail::integer_traits_base<char, (-127 -1), 127>
{ };

template<>
class integer_traits<signed char>
  : public std::numeric_limits<signed char>,
    public detail::integer_traits_base<signed char, (-127 -1), 127>
{ };

template<>
class integer_traits<unsigned char>
  : public std::numeric_limits<unsigned char>,
    public detail::integer_traits_base<unsigned char, 0, (127*2 +1)>
{ };


template<>
class integer_traits<wchar_t>
  : public std::numeric_limits<wchar_t>,



    public detail::integer_traits_base<wchar_t, (-2147483647 - 1), 2147483647>
# 125 "/usr/include/boost/integer_traits.hpp" 3
{ };


template<>
class integer_traits<short>
  : public std::numeric_limits<short>,
    public detail::integer_traits_base<short, (-32767 -1), 32767>
{ };

template<>
class integer_traits<unsigned short>
  : public std::numeric_limits<unsigned short>,
    public detail::integer_traits_base<unsigned short, 0, (32767 * 2 + 1)>
{ };

template<>
class integer_traits<int>
  : public std::numeric_limits<int>,
    public detail::integer_traits_base<int, (-2147483647 -1), 2147483647>
{ };

template<>
class integer_traits<unsigned int>
  : public std::numeric_limits<unsigned int>,
    public detail::integer_traits_base<unsigned int, 0, (2147483647 *2U +1U)>
{ };

template<>
class integer_traits<long>
  : public std::numeric_limits<long>,
    public detail::integer_traits_base<long, (-9223372036854775807L -1L), 9223372036854775807L>
{ };

template<>
class integer_traits<unsigned long>
  : public std::numeric_limits<unsigned long>,
    public detail::integer_traits_base<unsigned long, 0, (9223372036854775807L *2UL+1UL)>
{ };




template<>
class integer_traits< ::boost::long_long_type>
  : public std::numeric_limits< ::boost::long_long_type>,
    public detail::integer_traits_base< ::boost::long_long_type, (-9223372036854775807LL -1LL), 9223372036854775807LL>
{ };

template<>
class integer_traits< ::boost::ulong_long_type>
  : public std::numeric_limits< ::boost::ulong_long_type>,
    public detail::integer_traits_base< ::boost::ulong_long_type, 0, (9223372036854775807LL*2ULL+1ULL)>
{ };
# 251 "/usr/include/boost/integer_traits.hpp" 3
}
# 47 "/usr/include/boost/ratio/ratio.hpp" 2 3 4
# 1 "/usr/include/boost/ratio/ratio_fwd.hpp" 1 3 4
# 39 "/usr/include/boost/ratio/ratio_fwd.hpp" 3


namespace boost
{
# 51 "/usr/include/boost/ratio/ratio_fwd.hpp" 3
template <boost::intmax_t N, boost::intmax_t D = 1> class ratio;


template <class R1, class R2> struct ratio_add;
template <class R1, class R2> struct ratio_subtract;
template <class R1, class R2> struct ratio_multiply;
template <class R1, class R2> struct ratio_divide;
# 68 "/usr/include/boost/ratio/ratio_fwd.hpp" 3
template <class R1, class R2> struct ratio_equal;
template <class R1, class R2> struct ratio_not_equal;
template <class R1, class R2> struct ratio_less;
template <class R1, class R2> struct ratio_less_equal;
template <class R1, class R2> struct ratio_greater;
template <class R1, class R2> struct ratio_greater_equal;


typedef ratio<1L, 1000000000000000000L> atto;
typedef ratio<1L, 1000000000000000L> femto;
typedef ratio<1L, 1000000000000L> pico;
typedef ratio<1L, 1000000000L> nano;
typedef ratio<1L, 1000000L> micro;
typedef ratio<1L, 1000L> milli;
typedef ratio<1L, 100L> centi;
typedef ratio<1L, 10L> deci;
typedef ratio< 10L, 1L> deca;
typedef ratio< 100L, 1L> hecto;
typedef ratio< 1000L, 1L> kilo;
typedef ratio< 1000000L, 1L> mega;
typedef ratio< 1000000000L, 1L> giga;
typedef ratio< 1000000000000L, 1L> tera;
typedef ratio< 1000000000000000L, 1L> peta;
typedef ratio<1000000000000000000L, 1L> exa;
# 106 "/usr/include/boost/ratio/ratio_fwd.hpp" 3
}
# 48 "/usr/include/boost/ratio/ratio.hpp" 2 3 4
# 1 "/usr/include/boost/ratio/detail/overflow_helpers.hpp" 1 3 4
# 38 "/usr/include/boost/ratio/detail/overflow_helpers.hpp" 3 4
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdlib" 1 3 4
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdlib" 3
# 39 "/usr/include/boost/ratio/detail/overflow_helpers.hpp" 2 3 4
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/climits" 1 3 4
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/climits" 3
# 40 "/usr/include/boost/ratio/detail/overflow_helpers.hpp" 2 3 4

# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 42 "/usr/include/boost/ratio/detail/overflow_helpers.hpp" 2 3 4
# 56 "/usr/include/boost/ratio/detail/overflow_helpers.hpp" 3


namespace boost
{





namespace ratio_detail
{

  template <boost::intmax_t X, boost::intmax_t Y, boost::intmax_t = mpl::sign_c<boost::intmax_t, Y>::value>
  class br_add;

  template <boost::intmax_t X, boost::intmax_t Y>
  class br_add<X, Y, 1>
  {
      static const boost::intmax_t min = boost::integer_traits<boost::intmax_t>::const_min;
      static const boost::intmax_t max = boost::integer_traits<boost::intmax_t>::const_max;

      static_assert(X <= max - Y,"overflow in ratio add");
  public:
      static const boost::intmax_t value = X + Y;
  };

  template <boost::intmax_t X, boost::intmax_t Y>
  class br_add<X, Y, 0>
  {
  public:
      static const boost::intmax_t value = X;
  };

  template <boost::intmax_t X, boost::intmax_t Y>
  class br_add<X, Y, -1>
  {
      static const boost::intmax_t min = boost::integer_traits<boost::intmax_t>::const_min;
      static const boost::intmax_t max = boost::integer_traits<boost::intmax_t>::const_max;

      static_assert(min - Y <= X,"overflow in ratio add");
  public:
      static const boost::intmax_t value = X + Y;
  };

  template <boost::intmax_t X, boost::intmax_t Y, boost::intmax_t = mpl::sign_c<boost::intmax_t, Y>::value>
  class br_sub;

  template <boost::intmax_t X, boost::intmax_t Y>
  class br_sub<X, Y, 1>
  {
      static const boost::intmax_t min = boost::integer_traits<boost::intmax_t>::const_min;
      static const boost::intmax_t max = boost::integer_traits<boost::intmax_t>::const_max;

      static_assert(min + Y <= X,"overflow in ratio sub");
  public:
      static const boost::intmax_t value = X - Y;
  };

  template <boost::intmax_t X, boost::intmax_t Y>
  class br_sub<X, Y, 0>
  {
  public:
      static const boost::intmax_t value = X;
  };

  template <boost::intmax_t X, boost::intmax_t Y>
  class br_sub<X, Y, -1>
  {
      static const boost::intmax_t min = boost::integer_traits<boost::intmax_t>::const_min;
      static const boost::intmax_t max = boost::integer_traits<boost::intmax_t>::const_max;

      static_assert(X <= max + Y,"overflow in ratio sub");
  public:
      static const boost::intmax_t value = X - Y;
  };

  template <boost::intmax_t X, boost::intmax_t Y>
  class br_mul
  {
      static const boost::intmax_t nan =
          boost::intmax_t(1UL << (sizeof(boost::intmax_t) * 8 - 1));
      static const boost::intmax_t min = boost::integer_traits<boost::intmax_t>::const_min;
      static const boost::intmax_t max = boost::integer_traits<boost::intmax_t>::const_max;

      static const boost::intmax_t a_x = mpl::abs_c<boost::intmax_t, X>::value;
      static const boost::intmax_t a_y = mpl::abs_c<boost::intmax_t, Y>::value;

      static_assert(X != nan,"overflow in ratio mul");
      static_assert(Y != nan,"overflow in ratio mul");
      static_assert(a_x <= max / a_y,"overflow in ratio mul");
  public:
      static const boost::intmax_t value = X * Y;
  };

  template <boost::intmax_t Y>
  class br_mul<0, Y>
  {
  public:
      static const boost::intmax_t value = 0;
  };

  template <boost::intmax_t X>
  class br_mul<X, 0>
  {
  public:
      static const boost::intmax_t value = 0;
  };

  template <>
  class br_mul<0, 0>
  {
  public:
      static const boost::intmax_t value = 0;
  };


  template <boost::intmax_t X, boost::intmax_t Y>
  class br_div
  {
      static const boost::intmax_t nan = boost::intmax_t(1UL << (sizeof(boost::intmax_t) * 8 - 1));
      static const boost::intmax_t min = boost::integer_traits<boost::intmax_t>::const_min;
      static const boost::intmax_t max = boost::integer_traits<boost::intmax_t>::const_max;

      static_assert(X != nan,"overflow in ratio div");
      static_assert(Y != nan,"overflow in ratio div");
      static_assert(Y != 0,"ratio divide by 0");
  public:
      static const boost::intmax_t value = X / Y;
  };


  template <class R1, class R2> struct ratio_add;
  template <class R1, class R2> struct ratio_subtract;
  template <class R1, class R2> struct ratio_multiply;
  template <class R1, class R2> struct ratio_divide;

  template <class R1, class R2>
  struct ratio_add
  {



  private:
      static const boost::intmax_t gcd_n1_n2 = mpl::gcd_c<boost::intmax_t, R1::num, R2::num>::value;
      static const boost::intmax_t gcd_d1_d2 = mpl::gcd_c<boost::intmax_t, R1::den, R2::den>::value;
  public:

      typedef typename ratio_multiply
         <
             ratio<gcd_n1_n2, R1::den / gcd_d1_d2>,
             ratio
             <
                 boost::ratio_detail::br_add
                 <
                     boost::ratio_detail::br_mul<R1::num / gcd_n1_n2, R2::den / gcd_d1_d2>::value,
                     boost::ratio_detail::br_mul<R2::num / gcd_n1_n2, R1::den / gcd_d1_d2>::value
                 >::value,
                 R2::den
             >
         >::type type;
  };
  template <class R, boost::intmax_t D>
  struct ratio_add<R, ratio<0,D> >
  {
    typedef R type;
  };

  template <class R1, class R2>
  struct ratio_subtract
  {



  private:
      static const boost::intmax_t gcd_n1_n2 = mpl::gcd_c<boost::intmax_t, R1::num, R2::num>::value;
      static const boost::intmax_t gcd_d1_d2 = mpl::gcd_c<boost::intmax_t, R1::den, R2::den>::value;
  public:

      typedef typename ratio_multiply
         <
             ratio<gcd_n1_n2, R1::den / gcd_d1_d2>,
             ratio
             <
                 boost::ratio_detail::br_sub
                 <
                     boost::ratio_detail::br_mul<R1::num / gcd_n1_n2, R2::den / gcd_d1_d2>::value,
                     boost::ratio_detail::br_mul<R2::num / gcd_n1_n2, R1::den / gcd_d1_d2>::value
                 >::value,
                 R2::den
             >
         >::type type;
  };

  template <class R, boost::intmax_t D>
  struct ratio_subtract<R, ratio<0,D> >
  {
    typedef R type;
  };

  template <class R1, class R2>
  struct ratio_multiply
  {


  private:
     static const boost::intmax_t gcd_n1_d2 = mpl::gcd_c<boost::intmax_t, R1::num, R2::den>::value;
     static const boost::intmax_t gcd_d1_n2 = mpl::gcd_c<boost::intmax_t, R1::den, R2::num>::value;
  public:
      typedef typename ratio
         <
             boost::ratio_detail::br_mul<R1::num / gcd_n1_d2, R2::num / gcd_d1_n2>::value,
             boost::ratio_detail::br_mul<R2::den / gcd_n1_d2, R1::den / gcd_d1_n2>::value
         >::type type;
  };

  template <class R1, class R2>
  struct ratio_divide
  {


  private:
      static const boost::intmax_t gcd_n1_n2 = mpl::gcd_c<boost::intmax_t, R1::num, R2::num>::value;
      static const boost::intmax_t gcd_d1_d2 = mpl::gcd_c<boost::intmax_t, R1::den, R2::den>::value;
  public:
      typedef typename ratio
         <
             boost::ratio_detail::br_mul<R1::num / gcd_n1_n2, R2::den / gcd_d1_d2>::value,
             boost::ratio_detail::br_mul<R2::num / gcd_n1_n2, R1::den / gcd_d1_d2>::value
         >::type type;
  };
  template <class R1, class R2>
  struct is_evenly_divisible_by
  {
  private:
      static const boost::intmax_t gcd_n1_n2 = mpl::gcd_c<boost::intmax_t, R1::num, R2::num>::value;
      static const boost::intmax_t gcd_d1_d2 = mpl::gcd_c<boost::intmax_t, R1::den, R2::den>::value;
  public:
      typedef integral_constant<bool,
             ((R2::num / gcd_n1_n2 ==1) && (R1::den / gcd_d1_d2)==1)
      > type;
  };

  template <class T>
  struct is_ratio : public boost::false_type
  {};
  template <boost::intmax_t N, boost::intmax_t D>
  struct is_ratio<ratio<N, D> > : public boost::true_type
  {};

  template <class R1, class R2,
            boost::intmax_t Q1 = R1::num / R1::den, boost::intmax_t M1 = R1::num % R1::den,
            boost::intmax_t Q2 = R2::num / R2::den, boost::intmax_t M2 = R2::num % R2::den>
  struct ratio_less1
  {
    static const bool value = Q1 < Q2;
  };

  template <class R1, class R2, boost::intmax_t Q>
  struct ratio_less1<R1, R2, Q, 0, Q, 0>
  {
    static const bool value = false;
  };

  template <class R1, class R2, boost::intmax_t Q, boost::intmax_t M2>
  struct ratio_less1<R1, R2, Q, 0, Q, M2>
  {
    static const bool value = true;
  };

  template <class R1, class R2, boost::intmax_t Q, boost::intmax_t M1>
  struct ratio_less1<R1, R2, Q, M1, Q, 0>
  {
    static const bool value = false;
  };

  template <class R1, class R2, boost::intmax_t Q, boost::intmax_t M1, boost::intmax_t M2>
  struct ratio_less1<R1, R2, Q, M1, Q, M2>
  {
    static const bool value = ratio_less1<ratio<R2::den, M2>, ratio<R1::den, M1>
                                            >::value;
  };

  template <
      class R1,
      class R2,
      boost::intmax_t S1 = mpl::sign_c<boost::intmax_t, R1::num>::value,
    boost::intmax_t S2 = mpl::sign_c<boost::intmax_t, R2::num>::value
>
  struct ratio_less
  {
      static const bool value = S1 < S2;
  };

  template <class R1, class R2>
  struct ratio_less<R1, R2, 1LL, 1LL>
  {
      static const bool value = ratio_less1<R1, R2>::value;
  };

  template <class R1, class R2>
  struct ratio_less<R1, R2, -1LL, -1LL>
  {
      static const bool value = ratio_less1<ratio<-R2::num, R2::den>,
                                            ratio<-R1::num, R1::den> >::value;
  };


}

}
# 49 "/usr/include/boost/ratio/ratio.hpp" 2 3 4
# 64 "/usr/include/boost/ratio/ratio.hpp" 3


namespace boost
{
# 76 "/usr/include/boost/ratio/ratio.hpp" 3
template <boost::intmax_t N, boost::intmax_t D>
class ratio
{
    static const boost::intmax_t ABS_N = mpl::abs_c<boost::intmax_t, N>::value;
    static const boost::intmax_t ABS_D = mpl::abs_c<boost::intmax_t, D>::value;
    static_assert(ABS_N >= 0,"ratio numerator is out of range");
    static_assert(ABS_D > 0,"ratio denominator is out of range");
    static_assert(D != 0,"ratio divide by 0");
    static const boost::intmax_t SIGN_N = mpl::sign_c<boost::intmax_t,N>::value
      * mpl::sign_c<boost::intmax_t,D>::value;
    static const boost::intmax_t GCD = mpl::gcd_c<boost::intmax_t, ABS_N, ABS_D>::value;
public:
    static constexpr boost::intmax_t num = SIGN_N * ABS_N / GCD;
    static constexpr boost::intmax_t den = ABS_D / GCD;
# 119 "/usr/include/boost/ratio/ratio.hpp" 3
    typedef ratio<num, den> type;
};
# 135 "/usr/include/boost/ratio/ratio.hpp" 3
template <class R1, class R2>
struct ratio_add
: boost::ratio_detail::ratio_add<R1, R2>::type
{
};

template <class R1, class R2>
struct ratio_subtract
: boost::ratio_detail::ratio_subtract<R1, R2>::type
{
};

template <class R1, class R2>
struct ratio_multiply
: boost::ratio_detail::ratio_multiply<R1, R2>::type
{
};

template <class R1, class R2>
struct ratio_divide
: boost::ratio_detail::ratio_divide<R1, R2>::type
{
};
# 167 "/usr/include/boost/ratio/ratio.hpp" 3
template <class R1, class R2>
struct ratio_equal
    : public boost::integral_constant<bool,
                               (R1::num == R2::num && R1::den == R2::den)>
{};

template <class R1, class R2>
struct ratio_not_equal
    : public boost::integral_constant<bool, !ratio_equal<R1, R2>::value>
{};



template <class R1, class R2>
struct ratio_less
    : boost::integral_constant<bool, boost::ratio_detail::ratio_less<R1, R2>::value>
{};

template <class R1, class R2>
struct ratio_less_equal
    : boost::integral_constant<bool, !ratio_less<R2, R1>::value>
{};

template <class R1, class R2>
struct ratio_greater
    : boost::integral_constant<bool, ratio_less<R2, R1>::value>
{};

template <class R1, class R2>
struct ratio_greater_equal
    : boost::integral_constant<bool, !ratio_less<R1, R2>::value>
{};

template <class R1, class R2>
struct ratio_gcd :
    ratio<mpl::gcd_c<boost::intmax_t, R1::num, R2::num>::value,
        mpl::lcm_c<boost::intmax_t, R1::den, R2::den>::value>::type
{
};
# 290 "/usr/include/boost/ratio/ratio.hpp" 3
}
# 42 "/usr/include/boost/chrono/duration.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/common_type.hpp" 1 3 4
# 26 "/usr/include/boost/type_traits/common_type.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/mp_defer.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/detail/mp_defer.hpp" 3 4
namespace boost
{

namespace type_traits_detail
{




template<template<class...> class F, class... T>
struct mp_valid_impl
{
    template<template<class...> class G, class = G<T...>>
    static boost::true_type check_s(int);

    template<template<class...> class>
    static boost::false_type check_s(...);

    using type = decltype(check_s<F>(0));
};

template<template<class...> class F, class... T>
using mp_valid = typename mp_valid_impl<F, T...>::type;



struct mp_empty
{
};

template<template<class...> class F, class... T> struct mp_defer_impl
{
    using type = F<T...>;
};

template<template<class...> class F, class... T> using mp_defer = typename boost::conditional<mp_valid<F, T...>::value, mp_defer_impl<F, T...>, mp_empty>::type;

}

}
# 27 "/usr/include/boost/type_traits/common_type.hpp" 2 3 4


namespace boost
{





template<class... T> struct common_type
{
};



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

namespace type_traits_detail
{

template<class T1, class T2, class... T> using common_type_fold = common_type_t<common_type_t<T1, T2>, T...>;

}

template<class T1, class T2, class... T>
struct common_type<T1, T2, T...>: type_traits_detail::mp_defer<type_traits_detail::common_type_fold, T1, T2, T...>
{
};
# 80 "/usr/include/boost/type_traits/common_type.hpp" 3 4
template<class T> struct common_type<T>: boost::decay<T>
{
   static_assert(::boost::is_complete<T>::value || ::boost::is_void<T>::value || ::boost::is_array<T>::value, "Arguments to common_type must both be complete types");
};



namespace type_traits_detail
{
# 100 "/usr/include/boost/type_traits/common_type.hpp" 3 4
template<class T1, class T2> using builtin_common_type = typename boost::decay<decltype( boost::declval<bool>()? boost::declval<T1>(): boost::declval<T2>() )>::type;

template<class T1, class T2> struct common_type_impl: mp_defer<builtin_common_type, T1, T2>
{
};
# 134 "/usr/include/boost/type_traits/common_type.hpp" 3 4
template<class T1, class T2, class T1d = typename boost::decay<T1>::type, class T2d = typename boost::decay<T2>::type> struct common_type_decay_helper: boost::common_type<T1d, T2d>
{
};

template<class T1, class T2> struct common_type_decay_helper<T1, T2, T1, T2>: common_type_impl<T1, T2>
{
};

}

template<class T1, class T2> struct common_type<T1, T2>: type_traits_detail::common_type_decay_helper<T1, T2>
{
   static_assert(::boost::is_complete<T1>::value || ::boost::is_void<T1>::value || ::boost::is_array<T1>::value, "Arguments to common_type must both be complete types");
   static_assert(::boost::is_complete<T2>::value || ::boost::is_void<T2>::value || ::boost::is_array<T2>::value, "Arguments to common_type must both be complete types");
};

}
# 43 "/usr/include/boost/chrono/duration.hpp" 2 3 4




# 1 "/usr/include/boost/chrono/detail/is_evenly_divisible_by.hpp" 1 3 4
# 16 "/usr/include/boost/chrono/detail/is_evenly_divisible_by.hpp" 3 4
namespace boost {
namespace chrono {
namespace chrono_detail {




  template <class R1, class R2>
  struct is_evenly_divisible_by : public boost::ratio_detail::is_evenly_divisible_by<R1, R2>
  {};

}
}
}
# 48 "/usr/include/boost/chrono/duration.hpp" 2 3 4

# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 50 "/usr/include/boost/chrono/duration.hpp" 2 3 4
# 63 "/usr/include/boost/chrono/duration.hpp" 3 4
# 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
# 64 "/usr/include/boost/chrono/duration.hpp" 2 3 4
# 73 "/usr/include/boost/chrono/duration.hpp" 3 4
namespace boost {
namespace chrono {

    template <class Rep, class Period = ratio<1> >
    class duration;

    namespace detail
    {
    template <class T>
      struct is_duration
        : boost::false_type {};

    template <class Rep, class Period>
      struct is_duration<duration<Rep, Period> >
        : boost::true_type {};

    template <class Duration, class Rep, bool = is_duration<Rep>::value>
    struct duration_divide_result
    {
    };

    template <class Duration, class Rep2,
        bool = (
                    ((boost::is_convertible<typename Duration::rep,
                        typename common_type<typename Duration::rep, Rep2>::type>::value))
                && ((boost::is_convertible<Rep2,
                        typename common_type<typename Duration::rep, Rep2>::type>::value))
                )
        >
    struct duration_divide_imp
    {
    };

    template <class Rep1, class Period, class Rep2>
    struct duration_divide_imp<duration<Rep1, Period>, Rep2, true>
    {
        typedef duration<typename common_type<Rep1, Rep2>::type, Period> type;
    };

    template <class Rep1, class Period, class Rep2>
    struct duration_divide_result<duration<Rep1, Period>, Rep2, false>
        : duration_divide_imp<duration<Rep1, Period>, Rep2>
    {
    };


    template <class Rep, class Duration, bool = is_duration<Rep>::value>
    struct duration_divide_result2
    {
    };

    template <class Rep, class Duration,
        bool = (
                    ((boost::is_convertible<typename Duration::rep,
                        typename common_type<typename Duration::rep, Rep>::type>::value))
                && ((boost::is_convertible<Rep,
                        typename common_type<typename Duration::rep, Rep>::type>::value))
                )
        >
    struct duration_divide_imp2
    {
    };

    template <class Rep1, class Rep2, class Period >
    struct duration_divide_imp2<Rep1, duration<Rep2, Period>, true>
    {

        typedef double type;
    };

    template <class Rep1, class Rep2, class Period >
    struct duration_divide_result2<Rep1, duration<Rep2, Period>, false>
        : duration_divide_imp2<Rep1, duration<Rep2, Period> >
    {
    };


    template <class Duration, class Rep, bool = is_duration<Rep>::value>
    struct duration_modulo_result
    {
    };

    template <class Duration, class Rep2,
        bool = (



    boost::is_convertible<Rep2,
                        typename common_type<typename Duration::rep, Rep2>::type>::value
                )
        >
    struct duration_modulo_imp
    {
    };

    template <class Rep1, class Period, class Rep2>
    struct duration_modulo_imp<duration<Rep1, Period>, Rep2, true>
    {
        typedef duration<typename common_type<Rep1, Rep2>::type, Period> type;
    };

    template <class Rep1, class Period, class Rep2>
    struct duration_modulo_result<duration<Rep1, Period>, Rep2, false>
        : duration_modulo_imp<duration<Rep1, Period>, Rep2>
    {
    };

}
}




template <class Rep1, class Period1, class Rep2, class Period2>
struct common_type<chrono::duration<Rep1, Period1>,
                     chrono::duration<Rep2, Period2> >;


namespace chrono {


    template <class Rep> struct treat_as_floating_point;
    template <class Rep> struct duration_values;


    typedef duration<boost::int_least64_t, nano> nanoseconds;
    typedef duration<boost::int_least64_t, micro> microseconds;
    typedef duration<boost::int_least64_t, milli> milliseconds;
    typedef duration<boost::int_least64_t> seconds;
    typedef duration<boost::int_least32_t, ratio< 60> > minutes;
    typedef duration<boost::int_least32_t, ratio<3600> > hours;





namespace detail
{
# 223 "/usr/include/boost/chrono/duration.hpp" 3 4
    template <class FromDuration, class ToDuration,
              class Period,
              bool PeriodNumEq1,
              bool PeriodDenEq1>
    struct duration_cast_aux;





    template <class FromDuration, class ToDuration, class Period>
    struct duration_cast_aux<FromDuration, ToDuration, Period, true, true>
    {
        constexpr ToDuration operator()(const FromDuration& fd) const
        {
            return ToDuration(static_cast<typename ToDuration::rep>(fd.count()));
        }
    };







    template <class FromDuration, class ToDuration, class Period>
    struct duration_cast_aux<FromDuration, ToDuration, Period, true, false>
    {
        constexpr ToDuration operator()(const FromDuration& fd) const
        {
            typedef typename common_type<
                typename ToDuration::rep,
                typename FromDuration::rep,
                boost::intmax_t>::type C;
            return ToDuration(static_cast<typename ToDuration::rep>(
                              static_cast<C>(fd.count()) / static_cast<C>(Period::den)));
        }
    };






    template <class FromDuration, class ToDuration, class Period>
    struct duration_cast_aux<FromDuration, ToDuration, Period, false, true>
    {
        constexpr ToDuration operator()(const FromDuration& fd) const
        {
            typedef typename common_type<
              typename ToDuration::rep,
              typename FromDuration::rep,
              boost::intmax_t>::type C;
            return ToDuration(static_cast<typename ToDuration::rep>(
                              static_cast<C>(fd.count()) * static_cast<C>(Period::num)));
        }
    };







    template <class FromDuration, class ToDuration, class Period>
    struct duration_cast_aux<FromDuration, ToDuration, Period, false, false>
    {
        constexpr ToDuration operator()(const FromDuration& fd) const
        {
            typedef typename common_type<
              typename ToDuration::rep,
              typename FromDuration::rep,
              boost::intmax_t>::type C;
            return ToDuration(static_cast<typename ToDuration::rep>(
               static_cast<C>(fd.count()) * static_cast<C>(Period::num)
                 / static_cast<C>(Period::den)));
        }
    };

    template <class FromDuration, class ToDuration>
    struct duration_cast {
        typedef typename ratio_divide<typename FromDuration::period,
              typename ToDuration::period>::type Period;
        typedef duration_cast_aux<
            FromDuration,
            ToDuration,
            Period,
            Period::num == 1,
            Period::den == 1
        > Aux;
        constexpr ToDuration operator()(const FromDuration& fd) const
        {
            return Aux()(fd);
        }
    };

}
# 333 "/usr/include/boost/chrono/duration.hpp" 3 4
    template <class Rep>
    struct treat_as_floating_point : boost::is_floating_point<Rep> {};





namespace detail {
    template <class T, bool = is_arithmetic<T>::value>
    struct chrono_numeric_limits {
        static constexpr T lowest() noexcept {return (std::numeric_limits<T>::min) ();}
    };

    template <class T>
    struct chrono_numeric_limits<T,true> {
        static constexpr T lowest() noexcept {return (std::numeric_limits<T>::min) ();}
    };

    template <>
    struct chrono_numeric_limits<float,true> {
        static constexpr float lowest() noexcept
        {
            return -(std::numeric_limits<float>::max) ();
        }
    };

    template <>
    struct chrono_numeric_limits<double,true> {
        static constexpr double lowest() noexcept
        {
            return -(std::numeric_limits<double>::max) ();
        }
    };

    template <>
    struct chrono_numeric_limits<long double,true> {
        static constexpr long double lowest() noexcept
        {
            return -(std::numeric_limits<long double>::max)();
        }
    };

    template <class T>
    struct numeric_limits : chrono_numeric_limits<typename remove_cv<T>::type>
    {};

}
template <class Rep>
struct duration_values
{
    static constexpr Rep zero() {return Rep(0);}
    static constexpr Rep max ()
    {
        return (std::numeric_limits<Rep>::max)();
    }

    static constexpr Rep min ()
    {
        return detail::numeric_limits<Rep>::lowest();
    }
};

}





template <class Rep1, class Period1, class Rep2, class Period2>
struct common_type<chrono::duration<Rep1, Period1>,
                   chrono::duration<Rep2, Period2> >
{
  typedef chrono::duration<typename common_type<Rep1, Rep2>::type,
                      typename boost::ratio_gcd<Period1, Period2>::type> type;
};
# 417 "/usr/include/boost/chrono/duration.hpp" 3 4
namespace chrono {

    template <class Rep, class Period>
    class __attribute__((__visibility__("default"))) duration
    {

    static_assert(!boost::chrono::detail::is_duration<Rep>::value,"A duration representation can not be a duration");

    static_assert(boost::ratio_detail::is_ratio<typename Period::type>::value,"Second template parameter of duration must be a boost::ratio");

    static_assert(Period::num>0,"duration period must be positive");

    public:
        typedef Rep rep;
        typedef Period period;
    private:
        rep rep_;
    public:







        constexpr duration() = default;

        template <class Rep2>
        __attribute__((__visibility__("default"))) inline __attribute__ ((__always_inline__)) constexpr
        explicit duration(const Rep2& r
        , typename boost::enable_if <
                    mpl::and_ <
                        boost::is_convertible<Rep2, rep>,
                        mpl::or_ <
                            treat_as_floating_point<rep>,
                            mpl::and_ <
                                mpl::not_ < treat_as_floating_point<rep> >,
                                mpl::not_ < treat_as_floating_point<Rep2> >
                            >
                        >
                    >
                >::type* = nullptr
            ) : rep_(r) { }
# 468 "/usr/include/boost/chrono/duration.hpp" 3 4
        duration& operator=(const duration& rhs) = default;
        duration(const duration&) = default;



        template <class Rep2, class Period2>
        inline __attribute__ ((__always_inline__)) constexpr
        duration(const duration<Rep2, Period2>& d
        , typename boost::enable_if <
                    mpl::or_ <
                        treat_as_floating_point<rep>,
                        mpl::and_ <
                            chrono_detail::is_evenly_divisible_by<Period2, period>,
                            mpl::not_ < treat_as_floating_point<Rep2> >
                        >
                    >
                >::type* = nullptr
        )
            : rep_(chrono::detail::duration_cast<duration<Rep2, Period2>, duration>()(d).count()) {}



        constexpr
        rep count() const {return rep_;}



        constexpr
        duration operator+() const {return duration(rep_);}
        constexpr
        duration operator-() const {return duration(-rep_);}
        duration& operator++() {++rep_; return *this;}
        duration operator++(int) {return duration(rep_++);}
        duration& operator--() {--rep_; return *this;}
        duration operator--(int) {return duration(rep_--);}

        duration& operator+=(const duration& d)
        {
            rep_ += d.count(); return *this;
        }
        duration& operator-=(const duration& d)
        {
            rep_ -= d.count(); return *this;
        }

        duration& operator*=(const rep& rhs) {rep_ *= rhs; return *this;}
        duration& operator/=(const rep& rhs) {rep_ /= rhs; return *this;}
        duration& operator%=(const rep& rhs) {rep_ %= rhs; return *this;}
        duration& operator%=(const duration& rhs)
        {
            rep_ %= rhs.count(); return *this;
        }


        static constexpr duration zero()
        {
            return duration(duration_values<rep>::zero());
        }
        static constexpr duration min ()
        {
            return duration((duration_values<rep>::min)());
        }
        static constexpr duration max ()
        {
            return duration((duration_values<rep>::max)());
        }
    };







    template <class Rep1, class Period1, class Rep2, class Period2>
    inline constexpr
    typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2> >::type
    operator+(const duration<Rep1, Period1>& lhs,
          const duration<Rep2, Period2>& rhs)
    {
      typedef typename common_type<duration<Rep1, Period1>,
        duration<Rep2, Period2> >::type common_duration;
      return common_duration(common_duration(lhs).count()+common_duration(rhs).count());
    }



    template <class Rep1, class Period1, class Rep2, class Period2>
    inline constexpr
    typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2> >::type
    operator-(const duration<Rep1, Period1>& lhs,
          const duration<Rep2, Period2>& rhs)
    {
      typedef typename common_type<duration<Rep1, Period1>,
            duration<Rep2, Period2> >::type common_duration;
      return common_duration(common_duration(lhs).count()-common_duration(rhs).count());
    }



    template <class Rep1, class Period, class Rep2>
    inline constexpr
    typename boost::enable_if <
        mpl::and_ <
        boost::is_convertible<Rep1, typename common_type<Rep1, Rep2>::type>,
        boost::is_convertible<Rep2, typename common_type<Rep1, Rep2>::type>
        >,
        duration<typename common_type<Rep1, Rep2>::type, Period>
    >::type
    operator*(const duration<Rep1, Period>& d, const Rep2& s)
    {
      typedef typename common_type<Rep1, Rep2>::type common_rep;
      typedef duration<common_rep, Period> common_duration;
      return common_duration(common_duration(d).count()*static_cast<common_rep>(s));
    }

    template <class Rep1, class Period, class Rep2>
    inline constexpr
    typename boost::enable_if <
        mpl::and_ <
        boost::is_convertible<Rep1, typename common_type<Rep1, Rep2>::type>,
        boost::is_convertible<Rep2, typename common_type<Rep1, Rep2>::type>
        >,
        duration<typename common_type<Rep1, Rep2>::type, Period>
    >::type
    operator*(const Rep1& s, const duration<Rep2, Period>& d)
    {
        return d * s;
    }



    template <class Rep1, class Period, class Rep2>
    inline constexpr
    typename boost::disable_if <boost::chrono::detail::is_duration<Rep2>,
      typename boost::chrono::detail::duration_divide_result<
        duration<Rep1, Period>, Rep2>::type
    >::type
    operator/(const duration<Rep1, Period>& d, const Rep2& s)
    {
      typedef typename common_type<Rep1, Rep2>::type common_rep;
      typedef duration<common_rep, Period> common_duration;
      return common_duration(common_duration(d).count()/static_cast<common_rep>(s));
    }

    template <class Rep1, class Period1, class Rep2, class Period2>
    inline constexpr
    typename common_type<Rep1, Rep2>::type
    operator/(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs)
    {
        typedef typename common_type<duration<Rep1, Period1>,
                                   duration<Rep2, Period2> >::type common_duration;
        return common_duration(lhs).count() / common_duration(rhs).count();
    }
# 639 "/usr/include/boost/chrono/duration.hpp" 3 4
    template <class Rep1, class Period, class Rep2>
    inline constexpr
    typename boost::disable_if <boost::chrono::detail::is_duration<Rep2>,
      typename boost::chrono::detail::duration_modulo_result<
        duration<Rep1, Period>, Rep2>::type
    >::type
    operator%(const duration<Rep1, Period>& d, const Rep2& s)
    {
      typedef typename common_type<Rep1, Rep2>::type common_rep;
      typedef duration<common_rep, Period> common_duration;
      return common_duration(common_duration(d).count()%static_cast<common_rep>(s));
    }

    template <class Rep1, class Period1, class Rep2, class Period2>
    inline constexpr
    typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2> >::type
    operator%(const duration<Rep1, Period1>& lhs,
          const duration<Rep2, Period2>& rhs) {
        typedef typename common_type<duration<Rep1, Period1>,
                                 duration<Rep2, Period2> >::type common_duration;

      return common_duration(common_duration(lhs).count()%common_duration(rhs).count());
    }






namespace detail
{
    template <class LhsDuration, class RhsDuration>
    struct duration_eq
    {
      constexpr bool operator()(const LhsDuration& lhs, const RhsDuration& rhs) const
        {
            typedef typename common_type<LhsDuration, RhsDuration>::type common_duration;
            return common_duration(lhs).count() == common_duration(rhs).count();
        }
    };

    template <class LhsDuration>
    struct duration_eq<LhsDuration, LhsDuration>
    {
      constexpr bool operator()(const LhsDuration& lhs, const LhsDuration& rhs) const
        {
            return lhs.count() == rhs.count();
        }
    };

    template <class LhsDuration, class RhsDuration>
    struct duration_lt
    {
      constexpr bool operator()(const LhsDuration& lhs, const RhsDuration& rhs) const
        {
            typedef typename common_type<LhsDuration, RhsDuration>::type common_duration;
            return common_duration(lhs).count() < common_duration(rhs).count();
        }
    };

    template <class LhsDuration>
    struct duration_lt<LhsDuration, LhsDuration>
    {
      constexpr bool operator()(const LhsDuration& lhs, const LhsDuration& rhs) const
        {
            return lhs.count() < rhs.count();
        }
    };

}



    template <class Rep1, class Period1, class Rep2, class Period2>
    inline constexpr
    bool
    operator==(const duration<Rep1, Period1>& lhs,
          const duration<Rep2, Period2>& rhs)
    {
        return boost::chrono::detail::duration_eq<
            duration<Rep1, Period1>, duration<Rep2, Period2> >()(lhs, rhs);
    }



    template <class Rep1, class Period1, class Rep2, class Period2>
    inline constexpr
    bool
    operator!=(const duration<Rep1, Period1>& lhs,
          const duration<Rep2, Period2>& rhs)
    {
        return !(lhs == rhs);
    }



    template <class Rep1, class Period1, class Rep2, class Period2>
    inline constexpr
    bool
    operator< (const duration<Rep1, Period1>& lhs,
          const duration<Rep2, Period2>& rhs)
    {
        return boost::chrono::detail::duration_lt<
          duration<Rep1, Period1>, duration<Rep2, Period2> >()(lhs, rhs);
    }



    template <class Rep1, class Period1, class Rep2, class Period2>
    inline constexpr
    bool
    operator> (const duration<Rep1, Period1>& lhs,
          const duration<Rep2, Period2>& rhs)
    {
        return rhs < lhs;
    }



    template <class Rep1, class Period1, class Rep2, class Period2>
    inline constexpr
    bool
    operator<=(const duration<Rep1, Period1>& lhs,
          const duration<Rep2, Period2>& rhs)
    {
        return !(rhs < lhs);
    }



    template <class Rep1, class Period1, class Rep2, class Period2>
    inline constexpr
    bool
    operator>=(const duration<Rep1, Period1>& lhs,
          const duration<Rep2, Period2>& rhs)
    {
        return !(lhs < rhs);
    }






    template <class ToDuration, class Rep, class Period>
    inline constexpr
    typename boost::enable_if <
      boost::chrono::detail::is_duration<ToDuration>, ToDuration>::type
    duration_cast(const duration<Rep, Period>& fd)
    {
        return boost::chrono::detail::duration_cast<
          duration<Rep, Period>, ToDuration>()(fd);
    }

}
}



# 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
# 799 "/usr/include/boost/chrono/duration.hpp" 2 3 4
# 34 "/usr/include/boost/chrono/time_point.hpp" 2 3 4



# 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
# 38 "/usr/include/boost/chrono/time_point.hpp" 2 3 4
# 47 "/usr/include/boost/chrono/time_point.hpp" 3 4
namespace boost {
namespace chrono {

  template <class Clock, class Duration = typename Clock::duration>
    class time_point;


}




template <class Clock, class Duration1, class Duration2>
  struct common_type<chrono::time_point<Clock, Duration1>,
                     chrono::time_point<Clock, Duration2> >;







template <class Clock, class Duration1, class Duration2>
struct common_type<chrono::time_point<Clock, Duration1>,
                   chrono::time_point<Clock, Duration2> >
{
  typedef chrono::time_point<Clock,
    typename common_type<Duration1, Duration2>::type> type;
};



namespace chrono {


    template <class Clock, class Duration1, class Rep2, class Period2>
    inline constexpr
    time_point<Clock,
        typename common_type<Duration1, duration<Rep2, Period2> >::type>
    operator+(
            const time_point<Clock, Duration1>& lhs,
            const duration<Rep2, Period2>& rhs);
    template <class Rep1, class Period1, class Clock, class Duration2>
    inline constexpr
    time_point<Clock,
        typename common_type<duration<Rep1, Period1>, Duration2>::type>
    operator+(
            const duration<Rep1, Period1>& lhs,
            const time_point<Clock, Duration2>& rhs);
    template <class Clock, class Duration1, class Rep2, class Period2>
    inline constexpr
    time_point<Clock,
        typename common_type<Duration1, duration<Rep2, Period2> >::type>
    operator-(
            const time_point<Clock, Duration1>& lhs,
            const duration<Rep2, Period2>& rhs);
    template <class Clock, class Duration1, class Duration2>
    inline constexpr
    typename common_type<Duration1, Duration2>::type
    operator-(
            const time_point<Clock, Duration1>& lhs,
            const time_point<Clock,
            Duration2>& rhs);


    template <class Clock, class Duration1, class Duration2>
    inline constexpr
    bool operator==(
          const time_point<Clock, Duration1>& lhs,
          const time_point<Clock, Duration2>& rhs);
    template <class Clock, class Duration1, class Duration2>
    inline constexpr
    bool operator!=(
          const time_point<Clock, Duration1>& lhs,
          const time_point<Clock, Duration2>& rhs);
    template <class Clock, class Duration1, class Duration2>
    inline constexpr
    bool operator< (
          const time_point<Clock, Duration1>& lhs,
          const time_point<Clock, Duration2>& rhs);
    template <class Clock, class Duration1, class Duration2>
    inline constexpr
    bool operator<=(
          const time_point<Clock, Duration1>& lhs,
          const time_point<Clock, Duration2>& rhs);
    template <class Clock, class Duration1, class Duration2>
    inline constexpr
    bool operator> (
          const time_point<Clock, Duration1>& lhs,
          const time_point<Clock, Duration2>& rhs);
    template <class Clock, class Duration1, class Duration2>
    inline constexpr
    bool operator>=(
          const time_point<Clock, Duration1>& lhs,
          const time_point<Clock, Duration2>& rhs);


    template <class ToDuration, class Clock, class Duration>
    inline constexpr
    time_point<Clock, ToDuration> time_point_cast(const time_point<Clock, Duration>& t);







    template <class Clock, class Duration>
    class time_point
    {
        static_assert(boost::chrono::detail::is_duration<Duration>::value,"Second template parameter of time_point must be a boost::chrono::duration");

    public:
        typedef Clock clock;
        typedef Duration duration;
        typedef typename duration::rep rep;
        typedef typename duration::period period;
        typedef Duration difference_type;

    private:
        duration d_;

    public:
        inline __attribute__ ((__always_inline__)) constexpr
        time_point() : d_(duration::zero())
        {}
        inline __attribute__ ((__always_inline__)) constexpr
        explicit time_point(const duration& d)
            : d_(d)
        {}


        template <class Duration2>
        inline __attribute__ ((__always_inline__)) constexpr
        time_point(const time_point<clock, Duration2>& t
                , typename boost::enable_if
                <
                    boost::is_convertible<Duration2, duration>
                >::type* = nullptr
        )
            : d_(t.time_since_epoch())
        {
        }


        constexpr
        duration time_since_epoch() const
        {
            return d_;
        }
# 215 "/usr/include/boost/chrono/time_point.hpp" 3 4
        time_point& operator+=(const duration& d) {d_ += d; return *this;}
        time_point& operator-=(const duration& d) {d_ -= d; return *this;}



        static constexpr time_point
        min ()
        {
            return time_point((duration::min)());
        }
        static constexpr time_point
        max ()
        {
            return time_point((duration::max)());
        }
    };







    template <class Clock, class Duration1, class Rep2, class Period2>
    inline constexpr
    time_point<Clock,
        typename common_type<Duration1, duration<Rep2, Period2> >::type>
    operator+(const time_point<Clock, Duration1>& lhs,
            const duration<Rep2, Period2>& rhs)
    {
      typedef typename common_type<Duration1, duration<Rep2, Period2> >::type CDuration;
      typedef time_point<
          Clock,
          CDuration
      > TimeResult;
        return TimeResult(lhs.time_since_epoch() + CDuration(rhs));
    }



    template <class Rep1, class Period1, class Clock, class Duration2>
    inline constexpr
    time_point<Clock,
        typename common_type<duration<Rep1, Period1>, Duration2>::type>
    operator+(const duration<Rep1, Period1>& lhs,
            const time_point<Clock, Duration2>& rhs)
    {
        return rhs + lhs;
    }



    template <class Clock, class Duration1, class Rep2, class Period2>
    inline constexpr
    time_point<Clock,
        typename common_type<Duration1, duration<Rep2, Period2> >::type>
    operator-(const time_point<Clock, Duration1>& lhs,
            const duration<Rep2, Period2>& rhs)
    {
        return lhs + (-rhs);
    }



    template <class Clock, class Duration1, class Duration2>
    inline constexpr
    typename common_type<Duration1, Duration2>::type
    operator-(const time_point<Clock, Duration1>& lhs,
            const time_point<Clock, Duration2>& rhs)
    {
        return lhs.time_since_epoch() - rhs.time_since_epoch();
    }







    template <class Clock, class Duration1, class Duration2>
    inline constexpr
    bool
    operator==(const time_point<Clock, Duration1>& lhs,
             const time_point<Clock, Duration2>& rhs)
    {
        return lhs.time_since_epoch() == rhs.time_since_epoch();
    }



    template <class Clock, class Duration1, class Duration2>
    inline constexpr
    bool
    operator!=(const time_point<Clock, Duration1>& lhs,
             const time_point<Clock, Duration2>& rhs)
    {
        return !(lhs == rhs);
    }



    template <class Clock, class Duration1, class Duration2>
    inline constexpr
    bool
    operator<(const time_point<Clock, Duration1>& lhs,
            const time_point<Clock, Duration2>& rhs)
    {
        return lhs.time_since_epoch() < rhs.time_since_epoch();
    }



    template <class Clock, class Duration1, class Duration2>
    inline constexpr
    bool
    operator>(const time_point<Clock, Duration1>& lhs,
            const time_point<Clock, Duration2>& rhs)
    {
        return rhs < lhs;
    }



    template <class Clock, class Duration1, class Duration2>
    inline constexpr
    bool
    operator<=(const time_point<Clock, Duration1>& lhs,
             const time_point<Clock, Duration2>& rhs)
    {
        return !(rhs < lhs);
    }



    template <class Clock, class Duration1, class Duration2>
    inline constexpr
    bool
    operator>=(const time_point<Clock, Duration1>& lhs,
             const time_point<Clock, Duration2>& rhs)
    {
        return !(lhs < rhs);
    }





    template <class ToDuration, class Clock, class Duration>
    inline constexpr
    time_point<Clock, ToDuration>
    time_point_cast(const time_point<Clock, Duration>& t)
    {
        return time_point<Clock, ToDuration>(
                duration_cast<ToDuration>(t.time_since_epoch()));
    }

}
}



# 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
# 377 "/usr/include/boost/chrono/time_point.hpp" 2 3 4
# 23 "/usr/include/boost/thread/lock_types.hpp" 2 3 4




# 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
# 28 "/usr/include/boost/thread/lock_types.hpp" 2 3 4

namespace boost
{
  struct xtime;

  template <typename Mutex>
  class shared_lock;

  template <typename Mutex>
  class upgrade_lock;

  template <typename Mutex>
  class unique_lock;

  namespace detail
  {
    template <typename Mutex>
    class try_lock_wrapper;
  }
# 98 "/usr/include/boost/thread/lock_types.hpp" 3 4
  template <typename Mutex>
  class unique_lock
  {
  private:
    Mutex* m;
    bool is_locked;

  private:
    explicit unique_lock(upgrade_lock<Mutex>&);
    unique_lock& operator=(upgrade_lock<Mutex>& other);
  public:
    typedef Mutex mutex_type;
    unique_lock(unique_lock const&) = delete; unique_lock& operator=(unique_lock const&) = delete; typedef int boost_move_no_copy_constructor_or_assign;






    unique_lock()noexcept :
    m(0),is_locked(false)
    {}

    explicit unique_lock(Mutex& m_) :
      m(&m_), is_locked(false)
    {
      lock();
    }
    unique_lock(Mutex& m_, adopt_lock_t) :
      m(&m_), is_locked(true)
    {



    }
    unique_lock(Mutex& m_, defer_lock_t)noexcept:
    m(&m_),is_locked(false)
    {}
    unique_lock(Mutex& m_, try_to_lock_t) :
      m(&m_), is_locked(false)
    {
      try_lock();
    }

    template<typename TimeDuration>
    unique_lock(Mutex& m_,TimeDuration const& target_time):
    m(&m_),is_locked(false)
    {
      timed_lock(target_time);
    }
    unique_lock(Mutex& m_,system_time const& target_time):
    m(&m_),is_locked(false)
    {
      timed_lock(target_time);
    }


    template <class Clock, class Duration>
    unique_lock(Mutex& mtx, const chrono::time_point<Clock, Duration>& t)
    : m(&mtx), is_locked(mtx.try_lock_until(t))
    {
    }
    template <class Rep, class Period>
    unique_lock(Mutex& mtx, const chrono::duration<Rep, Period>& d)
    : m(&mtx), is_locked(mtx.try_lock_for(d))
    {
    }


    unique_lock(unique_lock && other) noexcept:
    m(other.m),is_locked(other.is_locked)
    {
      other.is_locked=false;
      other.m=0;
    }

                                          unique_lock( upgrade_lock<Mutex> && other);



    unique_lock& operator=( upgrade_lock<Mutex> && other)
    {
      unique_lock temp(::boost::move(other));
      swap(temp);
      return *this;
    }



    unique_lock& operator=(unique_lock && other)
    {
      unique_lock temp(::boost::move(other));
      swap(temp);
      return *this;
    }
# 204 "/usr/include/boost/thread/lock_types.hpp" 3 4
    unique_lock( upgrade_lock<mutex_type> && ul, try_to_lock_t)
    : m(0),is_locked(false)
    {
      if (ul.owns_lock())
      {
        if (ul.mutex()->try_unlock_upgrade_and_lock())
        {
          m = ul.release();
          is_locked = true;
        }
      }
      else
      {
        m = ul.release();
      }
    }


    template <class Clock, class Duration>
    unique_lock( upgrade_lock<mutex_type> && ul,
        const chrono::time_point<Clock, Duration>& abs_time)
    : m(0),is_locked(false)
    {
      if (ul.owns_lock())
      {
        if (ul.mutex()->try_unlock_upgrade_and_lock_until(abs_time))
        {
          m = ul.release();
          is_locked = true;
        }
      }
      else
      {
        m = ul.release();
      }
    }

    template <class Rep, class Period>
    unique_lock( upgrade_lock<mutex_type> && ul,
        const chrono::duration<Rep, Period>& rel_time)
    : m(0),is_locked(false)
    {
      if (ul.owns_lock())
      {
        if (ul.mutex()->try_unlock_upgrade_and_lock_for(rel_time))
        {
          m = ul.release();
          is_locked = true;
        }
      }
      else
      {
        m = ul.release();
      }
    }
# 321 "/usr/include/boost/thread/lock_types.hpp" 3 4
    void swap(unique_lock& other)noexcept
    {
      std::swap(m,other.m);
      std::swap(is_locked,other.is_locked);
    }

    ~unique_lock()
    {
      if (owns_lock())
      {
        m->unlock();
      }
    }
    void lock()
    {
      if (m == 0)
      {
        boost::throw_exception(
            boost::lock_error(static_cast<int>(system::errc::operation_not_permitted), "boost unique_lock has no mutex"));
      }
      if (owns_lock())
      {
        boost::throw_exception(
            boost::lock_error(static_cast<int>(system::errc::resource_deadlock_would_occur), "boost unique_lock owns already the mutex"));
      }
      m->lock();
      is_locked = true;
    }
    bool try_lock()
    {
      if (m == 0)
      {
        boost::throw_exception(
            boost::lock_error(static_cast<int>(system::errc::operation_not_permitted), "boost unique_lock has no mutex"));
      }
      if (owns_lock())
      {
        boost::throw_exception(
            boost::lock_error(static_cast<int>(system::errc::resource_deadlock_would_occur), "boost unique_lock owns already the mutex"));
      }
      is_locked = m->try_lock();
      return is_locked;
    }

    template<typename TimeDuration>
    bool timed_lock(TimeDuration const& relative_time)
    {
      if(m==0)
      {
        boost::throw_exception(boost::lock_error(static_cast<int>(system::errc::operation_not_permitted), "boost unique_lock has no mutex"));
      }
      if(owns_lock())
      {
        boost::throw_exception(boost::lock_error(static_cast<int>(system::errc::resource_deadlock_would_occur), "boost unique_lock owns already the mutex"));
      }
      is_locked=m->timed_lock(relative_time);
      return is_locked;
    }

    bool timed_lock(::boost::system_time const& absolute_time)
    {
      if(m==0)
      {
        boost::throw_exception(boost::lock_error(static_cast<int>(system::errc::operation_not_permitted), "boost unique_lock has no mutex"));
      }
      if(owns_lock())
      {
        boost::throw_exception(boost::lock_error(static_cast<int>(system::errc::resource_deadlock_would_occur), "boost unique_lock owns already the mutex"));
      }
      is_locked=m->timed_lock(absolute_time);
      return is_locked;
    }
    bool timed_lock(::boost::xtime const& absolute_time)
    {
      if(m==0)
      {
        boost::throw_exception(boost::lock_error(static_cast<int>(system::errc::operation_not_permitted), "boost unique_lock has no mutex"));
      }
      if(owns_lock())
      {
        boost::throw_exception(boost::lock_error(static_cast<int>(system::errc::resource_deadlock_would_occur), "boost unique_lock owns already the mutex"));
      }
      is_locked=m->timed_lock(absolute_time);
      return is_locked;
    }



    template <class Rep, class Period>
    bool try_lock_for(const chrono::duration<Rep, Period>& rel_time)
    {
      if(m==0)
      {
        boost::throw_exception(boost::lock_error(static_cast<int>(system::errc::operation_not_permitted), "boost unique_lock has no mutex"));
      }
      if(owns_lock())
      {
        boost::throw_exception(boost::lock_error(static_cast<int>(system::errc::resource_deadlock_would_occur), "boost unique_lock owns already the mutex"));
      }
      is_locked=m->try_lock_for(rel_time);
      return is_locked;
    }
    template <class Clock, class Duration>
    bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time)
    {
      if(m==0)
      {
        boost::throw_exception(boost::lock_error(static_cast<int>(system::errc::operation_not_permitted), "boost unique_lock has no mutex"));
      }
      if(owns_lock())
      {
        boost::throw_exception(boost::lock_error(static_cast<int>(system::errc::resource_deadlock_would_occur), "boost unique_lock owns already the mutex"));
      }
      is_locked=m->try_lock_until(abs_time);
      return is_locked;
    }


    void unlock()
    {
      if (m == 0)
      {
        boost::throw_exception(
            boost::lock_error(static_cast<int>(system::errc::operation_not_permitted), "boost unique_lock has no mutex"));
      }
      if (!owns_lock())
      {
        boost::throw_exception(
            boost::lock_error(static_cast<int>(system::errc::operation_not_permitted), "boost unique_lock doesn't own the mutex"));
      }
      m->unlock();
      is_locked = false;
    }
# 466 "/usr/include/boost/thread/lock_types.hpp" 3 4
    explicit operator bool() const noexcept
    {
      return owns_lock();
    }

    bool owns_lock() const noexcept
    {
      return is_locked;
    }

    Mutex* mutex() const noexcept
    {
      return m;
    }

    Mutex* release()noexcept
    {
      Mutex* const res=m;
      m=0;
      is_locked=false;
      return res;
    }

    friend class shared_lock<Mutex> ;
    friend class upgrade_lock<Mutex> ;
  };

  template<typename Mutex>
  void swap(unique_lock<Mutex>& lhs, unique_lock<Mutex>& rhs)
  noexcept
  {
    lhs.swap(rhs);
  }

  namespace detail { template <typename Mutex> struct enable_move_utility_emulation_dummy_specialization< unique_lock<Mutex> > : integral_constant<bool, false> {}; }

  template<typename Mutex>
  class shared_lock
  {
  protected:
    Mutex* m;
    bool is_locked;

  public:
    typedef Mutex mutex_type;
    shared_lock(shared_lock const&) = delete; shared_lock& operator=(shared_lock const&) = delete; typedef int boost_move_no_copy_constructor_or_assign;

    shared_lock() noexcept:
    m(0),is_locked(false)
    {}

    explicit shared_lock(Mutex& m_):
    m(&m_),is_locked(false)
    {
      lock();
    }
    shared_lock(Mutex& m_,adopt_lock_t):
    m(&m_),is_locked(true)
    {



    }
    shared_lock(Mutex& m_,defer_lock_t) noexcept:
    m(&m_),is_locked(false)
    {}
    shared_lock(Mutex& m_,try_to_lock_t):
    m(&m_),is_locked(false)
    {
      try_lock();
    }

    shared_lock(Mutex& m_,system_time const& target_time):
    m(&m_),is_locked(false)
    {
      timed_lock(target_time);
    }


    template <class Clock, class Duration>
    shared_lock(Mutex& mtx, const chrono::time_point<Clock, Duration>& t)
    : m(&mtx), is_locked(mtx.try_lock_shared_until(t))
    {
    }
    template <class Rep, class Period>
    shared_lock(Mutex& mtx, const chrono::duration<Rep, Period>& d)
    : m(&mtx), is_locked(mtx.try_lock_shared_for(d))
    {
    }


    shared_lock( shared_lock<Mutex> && other) noexcept:
    m(other.m),is_locked(other.is_locked)
    {
      other.is_locked=false;
      other.m=0;
    }

                                          shared_lock( unique_lock<Mutex> && other):
    m(other.m),is_locked(other.is_locked)
    {
      if(is_locked)
      {
        m->unlock_and_lock_shared();
      }
      other.is_locked=false;
      other.m=0;
    }

                                          shared_lock( upgrade_lock<Mutex> && other):
    m(other.m),is_locked(other.is_locked)
    {
      if(is_locked)
      {
        m->unlock_upgrade_and_lock_shared();
      }
      other.is_locked=false;
      other.m=0;
    }


    shared_lock& operator=( shared_lock<Mutex> && other)
    {
      shared_lock temp(::boost::move(other));
      swap(temp);
      return *this;
    }

    shared_lock& operator=( unique_lock<Mutex> && other)
    {
      shared_lock temp(::boost::move(other));
      swap(temp);
      return *this;
    }

    shared_lock& operator=( upgrade_lock<Mutex> && other)
    {
      shared_lock temp(::boost::move(other));
      swap(temp);
      return *this;
    }


    void swap(shared_lock& other) noexcept
    {
      std::swap(m,other.m);
      std::swap(is_locked,other.is_locked);
    }

    Mutex* mutex() const noexcept
    {
      return m;
    }

    Mutex* release() noexcept
    {
      Mutex* const res=m;
      m=0;
      is_locked=false;
      return res;
    }

    ~shared_lock()
    {
      if(owns_lock())
      {
        m->unlock_shared();
      }
    }
    void lock()
    {
      if(m==0)
      {
        boost::throw_exception(boost::lock_error(static_cast<int>(system::errc::operation_not_permitted), "boost shared_lock has no mutex"));
      }
      if(owns_lock())
      {
        boost::throw_exception(boost::lock_error(static_cast<int>(system::errc::resource_deadlock_would_occur), "boost shared_lock owns already the mutex"));
      }
      m->lock_shared();
      is_locked=true;
    }
    bool try_lock()
    {
      if(m==0)
      {
        boost::throw_exception(boost::lock_error(static_cast<int>(system::errc::operation_not_permitted), "boost shared_lock has no mutex"));
      }
      if(owns_lock())
      {
        boost::throw_exception(boost::lock_error(static_cast<int>(system::errc::resource_deadlock_would_occur), "boost shared_lock owns already the mutex"));
      }
      is_locked=m->try_lock_shared();
      return is_locked;
    }

    bool timed_lock(boost::system_time const& target_time)
    {
      if(m==0)
      {
        boost::throw_exception(boost::lock_error(static_cast<int>(system::errc::operation_not_permitted), "boost shared_lock has no mutex"));
      }
      if(owns_lock())
      {
        boost::throw_exception(boost::lock_error(static_cast<int>(system::errc::resource_deadlock_would_occur), "boost shared_lock owns already the mutex"));
      }
      is_locked=m->timed_lock_shared(target_time);
      return is_locked;
    }
    template<typename Duration>
    bool timed_lock(Duration const& target_time)
    {
      if(m==0)
      {
        boost::throw_exception(boost::lock_error(static_cast<int>(system::errc::operation_not_permitted), "boost shared_lock has no mutex"));
      }
      if(owns_lock())
      {
        boost::throw_exception(boost::lock_error(static_cast<int>(system::errc::resource_deadlock_would_occur), "boost shared_lock owns already the mutex"));
      }
      is_locked=m->timed_lock_shared(target_time);
      return is_locked;
    }


    template <class Rep, class Period>
    bool try_lock_for(const chrono::duration<Rep, Period>& rel_time)
    {
      if(m==0)
      {
        boost::throw_exception(boost::lock_error(static_cast<int>(system::errc::operation_not_permitted), "boost shared_lock has no mutex"));
      }
      if(owns_lock())
      {
        boost::throw_exception(boost::lock_error(static_cast<int>(system::errc::resource_deadlock_would_occur), "boost shared_lock owns already the mutex"));
      }
      is_locked=m->try_lock_shared_for(rel_time);
      return is_locked;
    }
    template <class Clock, class Duration>
    bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time)
    {
      if(m==0)
      {
        boost::throw_exception(boost::lock_error(static_cast<int>(system::errc::operation_not_permitted), "boost shared_lock has no mutex"));
      }
      if(owns_lock())
      {
        boost::throw_exception(boost::lock_error(static_cast<int>(system::errc::resource_deadlock_would_occur), "boost shared_lock owns already the mutex"));
      }
      is_locked=m->try_lock_shared_until(abs_time);
      return is_locked;
    }

    void unlock()
    {
      if(m==0)
      {
        boost::throw_exception(boost::lock_error(static_cast<int>(system::errc::operation_not_permitted), "boost shared_lock has no mutex"));
      }
      if(!owns_lock())
      {
        boost::throw_exception(boost::lock_error(static_cast<int>(system::errc::operation_not_permitted), "boost shared_lock doesn't own the mutex"));
      }
      m->unlock_shared();
      is_locked=false;
    }
# 745 "/usr/include/boost/thread/lock_types.hpp" 3 4
    explicit operator bool() const noexcept
    {
      return owns_lock();
    }

    bool owns_lock() const noexcept
    {
      return is_locked;
    }

  };

  namespace detail { template <typename Mutex> struct enable_move_utility_emulation_dummy_specialization< shared_lock<Mutex> > : integral_constant<bool, false> {}; }

  template<typename Mutex>
  void swap(shared_lock<Mutex>& lhs,shared_lock<Mutex>& rhs) noexcept
  {
    lhs.swap(rhs);
  }

  template <typename Mutex>
  class upgrade_lock
  {
  protected:
    Mutex* m;
    bool is_locked;

  public:
    typedef Mutex mutex_type;
    upgrade_lock(upgrade_lock const&) = delete; upgrade_lock& operator=(upgrade_lock const&) = delete; typedef int boost_move_no_copy_constructor_or_assign;

    upgrade_lock()noexcept:
    m(0),is_locked(false)
    {}

    explicit upgrade_lock(Mutex& m_) :
      m(&m_), is_locked(false)
    {
      lock();
    }
    upgrade_lock(Mutex& m_, adopt_lock_t) :
      m(&m_), is_locked(true)
    {



    }
    upgrade_lock(Mutex& m_, defer_lock_t)noexcept:
    m(&m_),is_locked(false)
    {}
    upgrade_lock(Mutex& m_, try_to_lock_t) :
      m(&m_), is_locked(false)
    {
      try_lock();
    }


    template <class Clock, class Duration>
    upgrade_lock(Mutex& mtx, const chrono::time_point<Clock, Duration>& t)
    : m(&mtx), is_locked(mtx.try_lock_upgrade_until(t))
    {
    }
    template <class Rep, class Period>
    upgrade_lock(Mutex& mtx, const chrono::duration<Rep, Period>& d)
    : m(&mtx), is_locked(mtx.try_lock_upgrade_for(d))
    {
    }


    upgrade_lock( upgrade_lock<Mutex> && other) noexcept:
    m(other.m),is_locked(other.is_locked)
    {
      other.is_locked=false;
      other.m=0;
    }

                                          upgrade_lock( unique_lock<Mutex> && other):
    m(other.m),is_locked(other.is_locked)
    {
      if(is_locked)
      {
        m->unlock_and_lock_upgrade();
      }
      other.is_locked=false;
      other.m=0;
    }


    upgrade_lock& operator=( upgrade_lock<Mutex> && other)
    {
      upgrade_lock temp(::boost::move(other));
      swap(temp);
      return *this;
    }


    upgrade_lock& operator=( unique_lock<Mutex> && other)
    {
      upgrade_lock temp(::boost::move(other));
      swap(temp);
      return *this;
    }
# 908 "/usr/include/boost/thread/lock_types.hpp" 3 4
    void swap(upgrade_lock& other)noexcept
    {
      std::swap(m,other.m);
      std::swap(is_locked,other.is_locked);
    }
    Mutex* mutex() const noexcept
    {
      return m;
    }

    Mutex* release()noexcept
    {
      Mutex* const res=m;
      m=0;
      is_locked=false;
      return res;
    }
    ~upgrade_lock()
    {
      if (owns_lock())
      {
        m->unlock_upgrade();
      }
    }
    void lock()
    {
      if (m == 0)
      {
        boost::throw_exception(
            boost::lock_error(static_cast<int>(system::errc::operation_not_permitted), "boost upgrade_lock has no mutex"));
      }
      if (owns_lock())
      {
        boost::throw_exception(
            boost::lock_error(static_cast<int>(system::errc::resource_deadlock_would_occur), "boost upgrade_lock owns already the mutex"));
      }
      m->lock_upgrade();
      is_locked = true;
    }
    bool try_lock()
    {
      if (m == 0)
      {
        boost::throw_exception(
            boost::lock_error(static_cast<int>(system::errc::operation_not_permitted), "boost upgrade_lock has no mutex"));
      }
      if (owns_lock())
      {
        boost::throw_exception(
            boost::lock_error(static_cast<int>(system::errc::resource_deadlock_would_occur), "boost upgrade_lock owns already the mutex"));
      }
      is_locked = m->try_lock_upgrade();
      return is_locked;
    }
    void unlock()
    {
      if (m == 0)
      {
        boost::throw_exception(
            boost::lock_error(static_cast<int>(system::errc::operation_not_permitted), "boost upgrade_lock has no mutex"));
      }
      if (!owns_lock())
      {
        boost::throw_exception(
            boost::lock_error(static_cast<int>(system::errc::operation_not_permitted), "boost upgrade_lock doesn't own the mutex"));
      }
      m->unlock_upgrade();
      is_locked = false;
    }

    template <class Rep, class Period>
    bool try_lock_for(const chrono::duration<Rep, Period>& rel_time)
    {
      if(m==0)
      {
        boost::throw_exception(boost::lock_error(static_cast<int>(system::errc::operation_not_permitted), "boost upgrade_lock has no mutex"));
      }
      if(owns_lock())
      {
        boost::throw_exception(boost::lock_error(static_cast<int>(system::errc::resource_deadlock_would_occur), "boost upgrade_lock owns already the mutex"));
      }
      is_locked=m->try_lock_upgrade_for(rel_time);
      return is_locked;
    }
    template <class Clock, class Duration>
    bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time)
    {
      if(m==0)
      {
        boost::throw_exception(boost::lock_error(static_cast<int>(system::errc::operation_not_permitted), "boost upgrade_lock has no mutex"));
      }
      if(owns_lock())
      {
        boost::throw_exception(boost::lock_error(static_cast<int>(system::errc::resource_deadlock_would_occur), "boost upgrade_lock owns already the mutex"));
      }
      is_locked=m->try_lock_upgrade_until(abs_time);
      return is_locked;
    }
# 1018 "/usr/include/boost/thread/lock_types.hpp" 3 4
    explicit operator bool() const noexcept
    {
      return owns_lock();
    }

    bool owns_lock() const noexcept
    {
      return is_locked;
    }
    friend class shared_lock<Mutex> ;
    friend class unique_lock<Mutex> ;
  };

  template<typename Mutex>
  void swap(upgrade_lock<Mutex>& lhs, upgrade_lock<Mutex>& rhs)
  noexcept
  {
    lhs.swap(rhs);
  }

  namespace detail { template <typename Mutex> struct enable_move_utility_emulation_dummy_specialization< upgrade_lock<Mutex> > : integral_constant<bool, false> {}; }

  template<typename Mutex>
  unique_lock<Mutex>::unique_lock( upgrade_lock<Mutex> && other):
  m(other.m),is_locked(other.is_locked)
  {
    if(is_locked)
    {
      m->unlock_upgrade_and_lock();
    }
    other.release();
  }

  template <class Mutex>
  class upgrade_to_unique_lock
  {
  private:
    upgrade_lock<Mutex>* source;
    unique_lock<Mutex> exclusive;

  public:
    typedef Mutex mutex_type;
    upgrade_to_unique_lock(upgrade_to_unique_lock const&) = delete; upgrade_to_unique_lock& operator=(upgrade_to_unique_lock const&) = delete; typedef int boost_move_no_copy_constructor_or_assign;

    explicit upgrade_to_unique_lock(upgrade_lock<Mutex>& m_) :
      source(&m_), exclusive(::boost::move(*source))
    {
    }
    ~upgrade_to_unique_lock()
    {
      if (source)
      {
        *source = upgrade_lock<Mutex> (::boost::move(exclusive));
      }
    }

    upgrade_to_unique_lock( upgrade_to_unique_lock<Mutex> && other) noexcept:
    source(other.source),exclusive(::boost::move(other.exclusive))
    {
      other.source=0;
    }


    upgrade_to_unique_lock& operator=( upgrade_to_unique_lock<Mutex> && other)
    {
      upgrade_to_unique_lock temp(::boost::move(other));
      swap(temp);
      return *this;
    }

    void swap(upgrade_to_unique_lock& other)noexcept
    {
      std::swap(source,other.source);
      exclusive.swap(other.exclusive);
    }
# 1105 "/usr/include/boost/thread/lock_types.hpp" 3 4
    explicit operator bool() const noexcept
    {
      return owns_lock();
    }


    bool owns_lock() const noexcept
    {
      return exclusive.owns_lock();
    }
    Mutex* mutex() const noexcept
    {
      return exclusive.mutex();
    }
  };

namespace detail { template <typename Mutex> struct enable_move_utility_emulation_dummy_specialization< upgrade_to_unique_lock<Mutex> > : integral_constant<bool, false> {}; }

namespace detail
{
  template<typename Mutex>
  class try_lock_wrapper:
private unique_lock<Mutex>
  {
    typedef unique_lock<Mutex> base;
  public:
    try_lock_wrapper(try_lock_wrapper const&) = delete; try_lock_wrapper& operator=(try_lock_wrapper const&) = delete; typedef int boost_move_no_copy_constructor_or_assign;

    try_lock_wrapper()
    {}

    explicit try_lock_wrapper(Mutex& m):
    base(m,try_to_lock)
    {}

    try_lock_wrapper(Mutex& m_,adopt_lock_t):
    base(m_,adopt_lock)
    {



    }
    try_lock_wrapper(Mutex& m_,defer_lock_t):
    base(m_,defer_lock)
    {}
    try_lock_wrapper(Mutex& m_,try_to_lock_t):
    base(m_,try_to_lock)
    {}

    try_lock_wrapper(try_lock_wrapper && other):
    base(::boost::move(other))
    {}
# 1168 "/usr/include/boost/thread/lock_types.hpp" 3 4
    try_lock_wrapper& operator=( try_lock_wrapper<Mutex> && other)
    {
      try_lock_wrapper temp(::boost::move(other));
      swap(temp);
      return *this;
    }
    void swap(try_lock_wrapper& other)
    {
      base::swap(other);
    }
    void lock()
    {
      base::lock();
    }
    bool try_lock()
    {
      return base::try_lock();
    }
    void unlock()
    {
      base::unlock();
    }
    bool owns_lock() const
    {
      return base::owns_lock();
    }
    Mutex* mutex() const noexcept
    {
      return base::mutex();
    }
    Mutex* release()
    {
      return base::release();
    }
# 1214 "/usr/include/boost/thread/lock_types.hpp" 3 4
    explicit operator bool() const
    {
      return owns_lock();
    }

  };

  template<typename Mutex>
  void swap(try_lock_wrapper<Mutex>& lhs,try_lock_wrapper<Mutex>& rhs)
  {
    lhs.swap(rhs);
  }
}
}
# 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
# 1229 "/usr/include/boost/thread/lock_types.hpp" 2 3 4
# 17 "/usr/include/boost/thread/pthread/mutex.hpp" 2 3 4



# 1 "/usr/include/boost/thread/xtime.hpp" 1 3 4
# 14 "/usr/include/boost/thread/xtime.hpp" 3 4
# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 15 "/usr/include/boost/thread/xtime.hpp" 2 3 4

# 1 "/usr/include/boost/date_time/posix_time/conversion.hpp" 1 3 4
# 12 "/usr/include/boost/date_time/posix_time/conversion.hpp" 3 4
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 1 3 4
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 3


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 43 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 2 3
# 13 "/usr/include/boost/date_time/posix_time/conversion.hpp" 2 3 4
# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 14 "/usr/include/boost/date_time/posix_time/conversion.hpp" 2 3 4


# 1 "/usr/include/boost/date_time/filetime_functions.hpp" 1 3 4
# 17 "/usr/include/boost/date_time/posix_time/conversion.hpp" 2 3 4


# 1 "/usr/include/boost/date_time/gregorian/conversion.hpp" 1 3 4
# 12 "/usr/include/boost/date_time/gregorian/conversion.hpp" 3 4
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 1 3 4
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 3


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 43 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 2 3
# 13 "/usr/include/boost/date_time/gregorian/conversion.hpp" 2 3 4







namespace boost {

namespace gregorian {


  inline
  std::tm to_tm(const date& d)
  {
    if (d.is_special())
    {
        std::string s = "tm unable to handle ";
        switch (d.as_special())
        {
        case date_time::not_a_date_time:
            s += "not-a-date-time value"; break;
        case date_time::neg_infin:
            s += "-infinity date value"; break;
        case date_time::pos_infin:
            s += "+infinity date value"; break;
        default:
            s += "a special date value"; break;
        }
        boost::throw_exception(std::out_of_range(s));
    }

    std::tm datetm;
    std::memset(&datetm, 0, sizeof(datetm));
    boost::gregorian::date::ymd_type ymd = d.year_month_day();
    datetm.tm_year = ymd.year - 1900;
    datetm.tm_mon = ymd.month - 1;
    datetm.tm_mday = ymd.day;
    datetm.tm_wday = d.day_of_week();
    datetm.tm_yday = d.day_of_year() - 1;
    datetm.tm_isdst = -1;
    return datetm;
  }


  inline
  date date_from_tm(const std::tm& datetm)
  {
    return date(static_cast<unsigned short>(datetm.tm_year+1900),
                static_cast<unsigned short>(datetm.tm_mon+1),
                static_cast<unsigned short>(datetm.tm_mday));
  }

} }
# 20 "/usr/include/boost/date_time/posix_time/conversion.hpp" 2 3 4

namespace boost {

namespace posix_time {


  inline
  ptime from_time_t(std::time_t t)
  {
    return ptime(gregorian::date(1970,1,1)) + seconds(t);
  }


  inline
  std::time_t to_time_t(ptime pt)
  {
    return (pt - ptime(gregorian::date(1970,1,1))).total_seconds();
  }


  inline
  std::tm to_tm(const boost::posix_time::ptime& t) {
    std::tm timetm = boost::gregorian::to_tm(t.date());
    boost::posix_time::time_duration td = t.time_of_day();
    timetm.tm_hour = static_cast<int>(td.hours());
    timetm.tm_min = static_cast<int>(td.minutes());
    timetm.tm_sec = static_cast<int>(td.seconds());
    timetm.tm_isdst = -1;
    return timetm;
  }

  inline
  std::tm to_tm(const boost::posix_time::time_duration& td) {
    std::tm timetm;
    std::memset(&timetm, 0, sizeof(timetm));
    timetm.tm_hour = static_cast<int>(date_time::absolute_value(td.hours()));
    timetm.tm_min = static_cast<int>(date_time::absolute_value(td.minutes()));
    timetm.tm_sec = static_cast<int>(date_time::absolute_value(td.seconds()));
    timetm.tm_isdst = -1;
    return timetm;
  }


  inline
  ptime ptime_from_tm(const std::tm& timetm) {
    boost::gregorian::date d = boost::gregorian::date_from_tm(timetm);
    return ptime(d, time_duration(timetm.tm_hour, timetm.tm_min, timetm.tm_sec));
  }
# 94 "/usr/include/boost/date_time/posix_time/conversion.hpp" 3 4
} }
# 17 "/usr/include/boost/thread/xtime.hpp" 2 3 4

# 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
# 19 "/usr/include/boost/thread/xtime.hpp" 2 3 4

namespace boost {

enum xtime_clock_types
{
    TIME_UTC_=1







};

struct xtime
{



    typedef int_fast64_t xtime_sec_t;


    typedef int_fast32_t xtime_nsec_t;

    xtime_sec_t sec;
    xtime_nsec_t nsec;

    operator system_time() const
    {
        return boost::posix_time::from_time_t(0)+
            boost::posix_time::seconds(static_cast<long>(sec))+



        boost::posix_time::microseconds((nsec+500)/1000);

    }

};

inline ::boost::xtime get_xtime(boost::system_time const& abs_time)
{
    ::boost::xtime res;
    boost::posix_time::time_duration const time_since_epoch=abs_time-boost::posix_time::from_time_t(0);

    res.sec=static_cast< ::boost::xtime::xtime_sec_t>(time_since_epoch.total_seconds());
    res.nsec=static_cast< ::boost::xtime::xtime_nsec_t>(time_since_epoch.fractional_seconds()*(1000000000/time_since_epoch.ticks_per_second()));
    return res;
}

inline int xtime_get(struct ::boost::xtime* xtp, int clock_type)
{
    if (clock_type == TIME_UTC_)
    {
        *xtp=get_xtime(get_system_time());
        return clock_type;
    }
    return 0;
}


inline int xtime_cmp(const ::boost::xtime& xt1, const ::boost::xtime& xt2)
{
    if (xt1.sec == xt2.sec)
        return (int)(xt1.nsec - xt2.nsec);
    else
        return (xt1.sec > xt2.sec) ? 1 : -1;
}

}

# 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
# 92 "/usr/include/boost/thread/xtime.hpp" 2 3 4
# 21 "/usr/include/boost/thread/pthread/mutex.hpp" 2 3 4

# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 58 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 59 "/usr/include/boost/assert.hpp" 2 3 4
# 23 "/usr/include/boost/thread/pthread/mutex.hpp" 2 3 4

# 1 "/usr/include/boost/thread/detail/platform_time.hpp" 1 3 4
# 20 "/usr/include/boost/thread/detail/platform_time.hpp" 3 4
# 1 "/usr/include/boost/chrono/system_clocks.hpp" 1 3 4
# 64 "/usr/include/boost/chrono/system_clocks.hpp" 3 4
# 1 "/usr/include/boost/chrono/detail/system.hpp" 1 3 4
# 13 "/usr/include/boost/chrono/detail/system.hpp" 3 4
namespace boost {
namespace chrono {
    inline bool is_throws(system::error_code & ec) { return (&ec==&boost::throws()); }
}
}
# 65 "/usr/include/boost/chrono/system_clocks.hpp" 2 3 4
# 1 "/usr/include/boost/chrono/clock_string.hpp" 1 3 4
# 13 "/usr/include/boost/chrono/clock_string.hpp" 3 4
namespace boost
{
  namespace chrono
  {

    template<class Clock, class CharT>
    struct clock_string;

  }

}
# 66 "/usr/include/boost/chrono/system_clocks.hpp" 2 3 4

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ctime" 1 3 4
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/ctime" 3
# 68 "/usr/include/boost/chrono/system_clocks.hpp" 2 3 4
# 84 "/usr/include/boost/chrono/system_clocks.hpp" 3 4
# 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
# 85 "/usr/include/boost/chrono/system_clocks.hpp" 2 3 4
# 95 "/usr/include/boost/chrono/system_clocks.hpp" 3 4
namespace boost {
namespace chrono {


  class system_clock;

  class steady_clock;



  typedef steady_clock high_resolution_clock;
# 127 "/usr/include/boost/chrono/system_clocks.hpp" 3 4
  class system_clock
  {
  public:
      typedef boost::chrono::nanoseconds duration;
      typedef duration::rep rep;
      typedef duration::period period;
      typedef chrono::time_point<system_clock> time_point;
      static constexpr bool is_steady = false;

      static time_point now() noexcept;

      static time_point now(system::error_code & ec);


      static std::time_t to_time_t(const time_point& t) noexcept;
      static time_point from_time_t(std::time_t t) noexcept;
  };
# 153 "/usr/include/boost/chrono/system_clocks.hpp" 3 4
  class steady_clock
  {
  public:
      typedef nanoseconds duration;
      typedef duration::rep rep;
      typedef duration::period period;
      typedef chrono::time_point<steady_clock> time_point;
      static constexpr bool is_steady = true;

      static time_point now() noexcept;

      static time_point now(system::error_code & ec);

  };
# 176 "/usr/include/boost/chrono/system_clocks.hpp" 3 4
  template<class CharT>
  struct clock_string<system_clock, CharT>
  {
    static std::basic_string<CharT> name()
    {
      static const CharT u[] =
      { 's', 'y', 's', 't', 'e', 'm', '_', 'c', 'l', 'o', 'c', 'k' };
      static const std::basic_string<CharT> str(u, u + sizeof(u)
          / sizeof(u[0]));
      return str;
    }
    static std::basic_string<CharT> since()
    {
      static const CharT
          u[] =
              { ' ', 's', 'i', 'n', 'c', 'e', ' ', 'J', 'a', 'n', ' ', '1', ',', ' ', '1', '9', '7', '0' };
      static const std::basic_string<CharT> str(u, u + sizeof(u)
          / sizeof(u[0]));
      return str;
    }
  };



  template<class CharT>
  struct clock_string<steady_clock, CharT>
  {
    static std::basic_string<CharT> name()
    {
      static const CharT
          u[] =
              { 's', 't', 'e', 'a', 'd', 'y', '_', 'c', 'l', 'o', 'c', 'k' };
      static const std::basic_string<CharT> str(u, u + sizeof(u)
          / sizeof(u[0]));
      return str;
    }
    static std::basic_string<CharT> since()
    {
      const CharT u[] =
      { ' ', 's', 'i', 'n', 'c', 'e', ' ', 'b', 'o', 'o', 't' };
      const std::basic_string<CharT> str(u, u + sizeof(u) / sizeof(u[0]));
      return str;
    }
  };



}
}



# 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
# 229 "/usr/include/boost/chrono/system_clocks.hpp" 2 3 4
# 21 "/usr/include/boost/thread/detail/platform_time.hpp" 2 3 4
# 1 "/usr/include/boost/chrono/ceil.hpp" 1 3 4
# 16 "/usr/include/boost/chrono/ceil.hpp" 3 4
namespace boost
{
  namespace chrono
  {




    template <class To, class Rep, class Period>
    To ceil(const duration<Rep, Period>& d)
    {
        To t = duration_cast<To>(d);
        if (t < d)
            ++t;
        return t;
    }

  }
}
# 22 "/usr/include/boost/thread/detail/platform_time.hpp" 2 3 4
# 38 "/usr/include/boost/thread/detail/platform_time.hpp" 3 4
# 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
# 39 "/usr/include/boost/thread/detail/platform_time.hpp" 2 3 4

namespace boost
{

typedef boost::intmax_t time_max_t;
# 114 "/usr/include/boost/thread/detail/platform_time.hpp" 3 4
  namespace detail
  {

    inline timespec ns_to_timespec(boost::time_max_t const& ns)
    {
      boost::time_max_t s = ns / 1000000000l;
      timespec ts;
      ts.tv_sec = static_cast<long> (s);
      ts.tv_nsec = static_cast<long> (ns - s * 1000000000l);
      return ts;
    }
    inline boost::time_max_t timespec_to_ns(timespec const& ts)
    {
      return static_cast<boost::time_max_t>(ts.tv_sec) * 1000000000l + ts.tv_nsec;
    }


    struct platform_duration
    {

      explicit platform_duration(timespec const& v) : ts_val(v) {}
      timespec const& getTs() const { return ts_val; }

      explicit platform_duration(boost::time_max_t const& ns = 0) : ts_val(ns_to_timespec(ns)) {}
      boost::time_max_t getNs() const { return timespec_to_ns(ts_val); }






      platform_duration(boost::posix_time::time_duration const& rel_time)
      {

        ts_val.tv_sec = rel_time.total_seconds();
        ts_val.tv_nsec = static_cast<long>(rel_time.fractional_seconds() * (1000000000l / rel_time.ticks_per_second()));




      }



      template <class Rep, class Period>
      platform_duration(chrono::duration<Rep, Period> const& d)
      {

        ts_val = ns_to_timespec(chrono::ceil<chrono::nanoseconds>(d).count());



      }


      boost::time_max_t getMs() const
      {
        const boost::time_max_t ns = getNs();

        if (ns >= 0)
        {

          return (ns + 999999) / 1000000;
        }
        else
        {

          return (ns - 999999) / 1000000;
        }
      }

      static platform_duration zero()
      {
        return platform_duration(0);
      }

    private:

      timespec ts_val;



    };

    inline bool operator==(platform_duration const& lhs, platform_duration const& rhs)
    {
      return lhs.getNs() == rhs.getNs();
    }
    inline bool operator!=(platform_duration const& lhs, platform_duration const& rhs)
    {
      return lhs.getNs() != rhs.getNs();
    }
    inline bool operator<(platform_duration const& lhs, platform_duration const& rhs)
    {
      return lhs.getNs() < rhs.getNs();
    }
    inline bool operator<=(platform_duration const& lhs, platform_duration const& rhs)
    {
      return lhs.getNs() <= rhs.getNs();
    }
    inline bool operator>(platform_duration const& lhs, platform_duration const& rhs)
    {
      return lhs.getNs() > rhs.getNs();
    }
    inline bool operator>=(platform_duration const& lhs, platform_duration const& rhs)
    {
      return lhs.getNs() >= rhs.getNs();
    }

    static inline platform_duration platform_milliseconds(long const& ms)
    {
      return platform_duration(ms * 1000000l);
    }

    struct real_platform_timepoint
    {

      explicit real_platform_timepoint(timespec const& v) : dur(v) {}
      timespec const& getTs() const { return dur.getTs(); }


      explicit real_platform_timepoint(boost::time_max_t const& ns) : dur(ns) {}
      boost::time_max_t getNs() const { return dur.getNs(); }


      real_platform_timepoint(boost::system_time const& abs_time)
        : dur(abs_time - boost::posix_time::from_time_t(0)) {}



      template <class Duration>
      real_platform_timepoint(chrono::time_point<chrono::system_clock, Duration> const& abs_time)
        : dur(abs_time.time_since_epoch()) {}


    private:
      platform_duration dur;
    };

    inline bool operator==(real_platform_timepoint const& lhs, real_platform_timepoint const& rhs)
    {
      return lhs.getNs() == rhs.getNs();
    }
    inline bool operator!=(real_platform_timepoint const& lhs, real_platform_timepoint const& rhs)
    {
      return lhs.getNs() != rhs.getNs();
    }
    inline bool operator<(real_platform_timepoint const& lhs, real_platform_timepoint const& rhs)
    {
      return lhs.getNs() < rhs.getNs();
    }
    inline bool operator<=(real_platform_timepoint const& lhs, real_platform_timepoint const& rhs)
    {
      return lhs.getNs() <= rhs.getNs();
    }
    inline bool operator>(real_platform_timepoint const& lhs, real_platform_timepoint const& rhs)
    {
      return lhs.getNs() > rhs.getNs();
    }
    inline bool operator>=(real_platform_timepoint const& lhs, real_platform_timepoint const& rhs)
    {
      return lhs.getNs() >= rhs.getNs();
    }

    inline real_platform_timepoint operator+(real_platform_timepoint const& lhs, platform_duration const& rhs)
    {
      return real_platform_timepoint(lhs.getNs() + rhs.getNs());
    }
    inline real_platform_timepoint operator+(platform_duration const& lhs, real_platform_timepoint const& rhs)
    {
      return real_platform_timepoint(lhs.getNs() + rhs.getNs());
    }
    inline platform_duration operator-(real_platform_timepoint const& lhs, real_platform_timepoint const& rhs)
    {
      return platform_duration(lhs.getNs() - rhs.getNs());
    }

    struct real_platform_clock
    {
      static real_platform_timepoint now()
      {
# 308 "/usr/include/boost/thread/detail/platform_time.hpp" 3 4
        timespec ts;
        if ( ::clock_gettime( 0, &ts ) )
        {
          (static_cast <bool> (0 && "Boost::Thread - clock_gettime(CLOCK_REALTIME) Internal Error") ? void (0) : __assert_fail ("0 && \"Boost::Thread - clock_gettime(CLOCK_REALTIME) Internal Error\"", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
          return real_platform_timepoint(0);
        }
        return real_platform_timepoint(ts);

      }
    };



  struct mono_platform_timepoint
  {


    explicit mono_platform_timepoint(timespec const& v) : dur(v) {}
    timespec const& getTs() const { return dur.getTs(); }


    explicit mono_platform_timepoint(boost::time_max_t const& ns) : dur(ns) {}
    boost::time_max_t getNs() const { return dur.getNs(); }



    template <class Duration>
    mono_platform_timepoint(chrono::time_point<chrono::steady_clock, Duration> const& abs_time)
      : dur(abs_time.time_since_epoch()) {}



    static mono_platform_timepoint getMax()
    {

      timespec ts;
      ts.tv_sec = (std::numeric_limits<time_t>::max)();
      ts.tv_nsec = 999999999;
      return mono_platform_timepoint(ts);




    }

  private:
    platform_duration dur;
  };

  inline bool operator==(mono_platform_timepoint const& lhs, mono_platform_timepoint const& rhs)
  {
    return lhs.getNs() == rhs.getNs();
  }
  inline bool operator!=(mono_platform_timepoint const& lhs, mono_platform_timepoint const& rhs)
  {
    return lhs.getNs() != rhs.getNs();
  }
  inline bool operator<(mono_platform_timepoint const& lhs, mono_platform_timepoint const& rhs)
  {
    return lhs.getNs() < rhs.getNs();
  }
  inline bool operator<=(mono_platform_timepoint const& lhs, mono_platform_timepoint const& rhs)
  {
    return lhs.getNs() <= rhs.getNs();
  }
  inline bool operator>(mono_platform_timepoint const& lhs, mono_platform_timepoint const& rhs)
  {
    return lhs.getNs() > rhs.getNs();
  }
  inline bool operator>=(mono_platform_timepoint const& lhs, mono_platform_timepoint const& rhs)
  {
    return lhs.getNs() >= rhs.getNs();
  }

  inline mono_platform_timepoint operator+(mono_platform_timepoint const& lhs, platform_duration const& rhs)
  {
    return mono_platform_timepoint(lhs.getNs() + rhs.getNs());
  }
  inline mono_platform_timepoint operator+(platform_duration const& lhs, mono_platform_timepoint const& rhs)
  {
    return mono_platform_timepoint(lhs.getNs() + rhs.getNs());
  }
  inline platform_duration operator-(mono_platform_timepoint const& lhs, mono_platform_timepoint const& rhs)
  {
    return platform_duration(lhs.getNs() - rhs.getNs());
  }

  struct mono_platform_clock
  {
    static mono_platform_timepoint now()
    {
# 444 "/usr/include/boost/thread/detail/platform_time.hpp" 3 4
      timespec ts;
      if ( ::clock_gettime( 1, &ts ) )
      {
        (static_cast <bool> (0 && "Boost::Thread - clock_gettime(CLOCK_MONOTONIC) Internal Error") ? void (0) : __assert_fail ("0 && \"Boost::Thread - clock_gettime(CLOCK_MONOTONIC) Internal Error\"", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        return mono_platform_timepoint(0);
      }
      return mono_platform_timepoint(ts);

    }
  };




  typedef mono_platform_clock internal_platform_clock;
  typedef mono_platform_timepoint internal_platform_timepoint;







  typedef chrono::steady_clock internal_chrono_clock;





  }
}

# 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
# 477 "/usr/include/boost/thread/detail/platform_time.hpp" 2 3 4
# 25 "/usr/include/boost/thread/pthread/mutex.hpp" 2 3 4
# 1 "/usr/include/boost/thread/pthread/pthread_mutex_scoped_lock.hpp" 1 3 4
# 10 "/usr/include/boost/thread/pthread/pthread_mutex_scoped_lock.hpp" 3 4
# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 58 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 59 "/usr/include/boost/assert.hpp" 2 3 4
# 11 "/usr/include/boost/thread/pthread/pthread_mutex_scoped_lock.hpp" 2 3 4
# 1 "/usr/include/boost/thread/pthread/pthread_helpers.hpp" 1 3 4
# 15 "/usr/include/boost/thread/pthread/pthread_helpers.hpp" 3 4
# 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
# 16 "/usr/include/boost/thread/pthread/pthread_helpers.hpp" 2 3 4





namespace boost
{
  namespace posix
  {
    inline __attribute__ ((__always_inline__))
    int pthread_mutex_init(pthread_mutex_t* m, const pthread_mutexattr_t* attr = __null)
    {
      return ::pthread_mutex_init(m, attr);
    }

    inline __attribute__ ((__always_inline__))
    int pthread_cond_init(pthread_cond_t* c)
    {

      pthread_condattr_t attr;
      int res = pthread_condattr_init(&attr);
      if (res)
      {
        return res;
      }
      (static_cast <bool> (!pthread_condattr_setclock(&attr, 1)) ? void (0) : __assert_fail ("!pthread_condattr_setclock(&attr, 1)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      res = ::pthread_cond_init(c, &attr);
      (static_cast <bool> (!pthread_condattr_destroy(&attr)) ? void (0) : __assert_fail ("!pthread_condattr_destroy(&attr)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      return res;



    }


    inline __attribute__ ((__always_inline__))
    int pthread_mutex_destroy(pthread_mutex_t* m)
    {
      int ret;
      do
      {
          ret = ::pthread_mutex_destroy(m);
      } while (ret == 4);
      return ret;
    }

    inline __attribute__ ((__always_inline__))
    int pthread_cond_destroy(pthread_cond_t* c)
    {
      int ret;
      do
      {
          ret = ::pthread_cond_destroy(c);
      } while (ret == 4);
      return ret;
    }

    inline __attribute__ ((__always_inline__))
    int pthread_mutex_lock(pthread_mutex_t* m)
    {
      int ret;
      do
      {
          ret = ::pthread_mutex_lock(m);
      } while (ret == 4);
      return ret;
    }

    inline __attribute__ ((__always_inline__))
    int pthread_mutex_trylock(pthread_mutex_t* m)
    {
      int ret;
      do
      {
          ret = ::pthread_mutex_trylock(m);
      } while (ret == 4);
      return ret;
    }

    inline __attribute__ ((__always_inline__))
    int pthread_mutex_unlock(pthread_mutex_t* m)
    {
      int ret;
      do
      {
          ret = ::pthread_mutex_unlock(m);
      } while (ret == 4);
      return ret;
    }

    inline __attribute__ ((__always_inline__))
    int pthread_cond_wait(pthread_cond_t* c, pthread_mutex_t* m)
    {
      int ret;
      do
      {
          ret = ::pthread_cond_wait(c, m);
      } while (ret == 4);
      return ret;
    }

    inline __attribute__ ((__always_inline__))
    int pthread_cond_timedwait(pthread_cond_t* c, pthread_mutex_t* m, const struct timespec* t)
    {
      int ret;
      do
      {
          ret = ::pthread_cond_timedwait(c, m, t);
      } while (ret == 4);
      return ret;
    }
# 171 "/usr/include/boost/thread/pthread/pthread_helpers.hpp" 3 4
    inline __attribute__ ((__always_inline__))
    int pthread_cond_signal(pthread_cond_t* c)
    {
      return ::pthread_cond_signal(c);
    }

    inline __attribute__ ((__always_inline__))
    int pthread_cond_broadcast(pthread_cond_t* c)
    {
      return ::pthread_cond_broadcast(c);
    }
  }
}

# 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
# 186 "/usr/include/boost/thread/pthread/pthread_helpers.hpp" 2 3 4
# 12 "/usr/include/boost/thread/pthread/pthread_mutex_scoped_lock.hpp" 2 3 4

# 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
# 14 "/usr/include/boost/thread/pthread/pthread_mutex_scoped_lock.hpp" 2 3 4

namespace boost
{
    namespace pthread
    {
        class pthread_mutex_scoped_lock
        {
            pthread_mutex_t* m;
            bool locked;
        public:
            explicit pthread_mutex_scoped_lock(pthread_mutex_t* m_) noexcept:
                m(m_),locked(true)
            {
                (static_cast <bool> (!posix::pthread_mutex_lock(m)) ? void (0) : __assert_fail ("!posix::pthread_mutex_lock(m)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
            }
            void unlock() noexcept
            {
                (static_cast <bool> (!posix::pthread_mutex_unlock(m)) ? void (0) : __assert_fail ("!posix::pthread_mutex_unlock(m)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
                locked=false;
            }
            void unlock_if_locked() noexcept
            {
              if(locked)
              {
                  unlock();
              }
            }
            ~pthread_mutex_scoped_lock() noexcept
            {
                if(locked)
                {
                    unlock();
                }
            }

        };

        class pthread_mutex_scoped_unlock
        {
            pthread_mutex_t* m;
        public:
            explicit pthread_mutex_scoped_unlock(pthread_mutex_t* m_) noexcept:
                m(m_)
            {
                (static_cast <bool> (!posix::pthread_mutex_unlock(m)) ? void (0) : __assert_fail ("!posix::pthread_mutex_unlock(m)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
            }
            ~pthread_mutex_scoped_unlock() noexcept
            {
                (static_cast <bool> (!posix::pthread_mutex_lock(m)) ? void (0) : __assert_fail ("!posix::pthread_mutex_lock(m)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
            }

        };
    }
}

# 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
# 70 "/usr/include/boost/thread/pthread/pthread_mutex_scoped_lock.hpp" 2 3 4
# 26 "/usr/include/boost/thread/pthread/mutex.hpp" 2 3 4








# 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
# 35 "/usr/include/boost/thread/pthread/mutex.hpp" 2 3 4

namespace boost
{

    class mutex
    {
    private:
        pthread_mutex_t m;
    public:
        mutex(mutex const&) = delete; mutex& operator=(mutex const&) = delete;

        mutex()
        {
            int const res=posix::pthread_mutex_init(&m);
            if(res)
            {
                boost::throw_exception(thread_resource_error(res, "boost:: mutex constructor failed in pthread_mutex_init"));
            }
        }
        ~mutex()
        {
          (static_cast <bool> (!posix::pthread_mutex_destroy(&m)) ? void (0) : __assert_fail ("!posix::pthread_mutex_destroy(&m)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        }

        void lock()
        {
            int res = posix::pthread_mutex_lock(&m);
            if (res)
            {
                boost::throw_exception(lock_error(res,"boost: mutex lock failed in pthread_mutex_lock"));
            }
        }

        void unlock()
        {
            (static_cast <bool> (!posix::pthread_mutex_unlock(&m)) ? void (0) : __assert_fail ("!posix::pthread_mutex_unlock(&m)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        }

        bool try_lock()
        {
            int res = posix::pthread_mutex_trylock(&m);
            if (res==16)
            {
                return false;
            }

            return !res;
        }


        typedef pthread_mutex_t* native_handle_type;
        native_handle_type native_handle()
        {
            return &m;
        }


        typedef unique_lock<mutex> scoped_lock;
        typedef detail::try_lock_wrapper<mutex> scoped_try_lock;

    };

    typedef mutex try_mutex;

    class timed_mutex
    {
    private:
        pthread_mutex_t m;

        pthread_cond_t cond;
        bool is_locked;

    public:
        timed_mutex(timed_mutex const&) = delete; timed_mutex& operator=(timed_mutex const&) = delete;
        timed_mutex()
        {
            int const res=posix::pthread_mutex_init(&m);
            if(res)
            {
                boost::throw_exception(thread_resource_error(res, "boost:: timed_mutex constructor failed in pthread_mutex_init"));
            }

            int const res2=posix::pthread_cond_init(&cond);
            if(res2)
            {
                (static_cast <bool> (!posix::pthread_mutex_destroy(&m)) ? void (0) : __assert_fail ("!posix::pthread_mutex_destroy(&m)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
                boost::throw_exception(thread_resource_error(res2, "boost:: timed_mutex constructor failed in pthread_cond_init"));
            }
            is_locked=false;

        }
        ~timed_mutex()
        {
            (static_cast <bool> (!posix::pthread_mutex_destroy(&m)) ? void (0) : __assert_fail ("!posix::pthread_mutex_destroy(&m)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));

            (static_cast <bool> (!posix::pthread_cond_destroy(&cond)) ? void (0) : __assert_fail ("!posix::pthread_cond_destroy(&cond)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));

        }


        template<typename TimeDuration>
        bool timed_lock(TimeDuration const & relative_time)
        {
            if (relative_time.is_pos_infinity())
            {
                lock();
                return true;
            }
            if (relative_time.is_special())
            {
                return true;
            }
            detail::platform_duration d(relative_time);
# 159 "/usr/include/boost/thread/pthread/mutex.hpp" 3 4
            return do_try_lock_until(detail::internal_platform_clock::now() + d);

        }
        bool timed_lock(boost::xtime const & absolute_time)
        {
            return timed_lock(system_time(absolute_time));
        }
# 204 "/usr/include/boost/thread/pthread/mutex.hpp" 3 4
        void lock()
        {
            boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
            while(is_locked)
            {
                (static_cast <bool> (!posix::pthread_cond_wait(&cond,&m)) ? void (0) : __assert_fail ("!posix::pthread_cond_wait(&cond,&m)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
            }
            is_locked=true;
        }

        void unlock()
        {
            boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
            is_locked=false;
            (static_cast <bool> (!posix::pthread_cond_signal(&cond)) ? void (0) : __assert_fail ("!posix::pthread_cond_signal(&cond)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        }

        bool try_lock()
        {
            boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
            if(is_locked)
            {
                return false;
            }
            is_locked=true;
            return true;
        }

    private:
        bool do_try_lock_until(detail::internal_platform_timepoint const &timeout)
        {
            boost::pthread::pthread_mutex_scoped_lock const local_lock(&m);
            while(is_locked)
            {
                int const cond_res=posix::pthread_cond_timedwait(&cond,&m,&timeout.getTs());
                if(cond_res==110)
                {
                    break;
                }
                (static_cast <bool> (!cond_res) ? void (0) : __assert_fail ("!cond_res", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
            }
            if(is_locked)
            {
                return false;
            }
            is_locked=true;
            return true;
        }
    public:



        bool timed_lock(system_time const & abs_time)
        {
            const detail::real_platform_timepoint ts(abs_time);

            detail::platform_duration d(ts - detail::real_platform_clock::now());
            d = (std::min)(d, detail::platform_milliseconds(100));
            while ( ! do_try_lock_until(detail::internal_platform_clock::now() + d) )
            {
              d = ts - detail::real_platform_clock::now();
              if ( d <= detail::platform_duration::zero() ) return false;
              d = (std::min)(d, detail::platform_milliseconds(100));
            }
            return true;



        }


        template <class Rep, class Period>
        bool try_lock_for(const chrono::duration<Rep, Period>& rel_time)
        {
          return try_lock_until(chrono::steady_clock::now() + rel_time);
        }
        template <class Clock, class Duration>
        bool try_lock_until(const chrono::time_point<Clock, Duration>& t)
        {
          typedef typename common_type<Duration, typename Clock::duration>::type common_duration;
          common_duration d(t - Clock::now());
          d = (std::min)(d, common_duration(chrono::milliseconds(100)));
          while ( ! try_lock_until(detail::internal_chrono_clock::now() + d))
          {
              d = t - Clock::now();
              if ( d <= common_duration::zero() ) return false;
              d = (std::min)(d, common_duration(chrono::milliseconds(100)));
          }
          return true;
        }
        template <class Duration>
        bool try_lock_until(const chrono::time_point<detail::internal_chrono_clock, Duration>& t)
        {
          detail::internal_platform_timepoint ts(t);
          return do_try_lock_until(ts);
        }



        typedef pthread_mutex_t* native_handle_type;
        native_handle_type native_handle()
        {
            return &m;
        }


        typedef unique_lock<timed_mutex> scoped_timed_lock;
        typedef detail::try_lock_wrapper<timed_mutex> scoped_try_lock;
        typedef scoped_timed_lock scoped_lock;

    };
}

# 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
# 318 "/usr/include/boost/thread/pthread/mutex.hpp" 2 3 4
# 17 "/usr/include/boost/thread/mutex.hpp" 2 3 4







namespace boost
{
  namespace sync
  {
# 50 "/usr/include/boost/thread/mutex.hpp" 3 4
  }
}
# 17 "/usr/include/boost/thread/barrier.hpp" 2 3 4

# 1 "/usr/include/boost/thread/condition_variable.hpp" 1 3 4
# 16 "/usr/include/boost/thread/condition_variable.hpp" 3 4
# 1 "/usr/include/boost/thread/pthread/condition_variable.hpp" 1 3 4
# 14 "/usr/include/boost/thread/pthread/condition_variable.hpp" 3 4
# 1 "/usr/include/boost/thread/interruption.hpp" 1 3 4
# 12 "/usr/include/boost/thread/interruption.hpp" 3 4
namespace boost
{
    namespace this_thread
    {
        void __attribute__((__visibility__("default"))) interruption_point();
        bool __attribute__((__visibility__("default"))) interruption_enabled() noexcept;
        bool __attribute__((__visibility__("default"))) interruption_requested() noexcept;
    }
}
# 15 "/usr/include/boost/thread/pthread/condition_variable.hpp" 2 3 4
# 1 "/usr/include/boost/thread/pthread/thread_data.hpp" 1 3 4
# 11 "/usr/include/boost/thread/pthread/thread_data.hpp" 3 4
# 1 "/usr/include/boost/thread/lock_guard.hpp" 1 3 4
# 13 "/usr/include/boost/thread/lock_guard.hpp" 3 4
# 1 "/usr/include/boost/thread/detail/lockable_wrapper.hpp" 1 3 4
# 14 "/usr/include/boost/thread/detail/lockable_wrapper.hpp" 3 4
# 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
# 15 "/usr/include/boost/thread/detail/lockable_wrapper.hpp" 2 3 4

namespace boost
{


  namespace thread_detail
  {
    template <typename Mutex>
    struct lockable_wrapper
    {
      Mutex* m;
      explicit lockable_wrapper(Mutex& m_) :
        m(&m_)
      {}
    };
    template <typename Mutex>
    struct lockable_adopt_wrapper
    {
      Mutex* m;
      explicit lockable_adopt_wrapper(Mutex& m_) :
        m(&m_)
      {}
    };
  }


}

# 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
# 44 "/usr/include/boost/thread/detail/lockable_wrapper.hpp" 2 3 4
# 14 "/usr/include/boost/thread/lock_guard.hpp" 2 3 4






# 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
# 21 "/usr/include/boost/thread/lock_guard.hpp" 2 3 4

namespace boost
{

  template <typename Mutex>
  class lock_guard
  {
  private:
    Mutex& m;

  public:
    typedef Mutex mutex_type;
    lock_guard(lock_guard const&) = delete; lock_guard& operator=(lock_guard const&) = delete;

    explicit lock_guard(Mutex& m_) :
      m(m_)
    {
      m.lock();
    }

    lock_guard(Mutex& m_, adopt_lock_t) :
      m(m_)
    {



    }


    lock_guard(std::initializer_list<thread_detail::lockable_wrapper<Mutex> > l_) :
      m(*(const_cast<thread_detail::lockable_wrapper<Mutex>*>(l_.begin())->m))
    {
      m.lock();
    }

    lock_guard(std::initializer_list<thread_detail::lockable_adopt_wrapper<Mutex> > l_) :
      m(*(const_cast<thread_detail::lockable_adopt_wrapper<Mutex>*>(l_.begin())->m))
    {



    }


    ~lock_guard()
    {
      m.unlock();
    }
  };



  template <typename Lockable>
  lock_guard<Lockable> make_lock_guard(Lockable& mtx)
  {
    return { thread_detail::lockable_wrapper<Lockable>(mtx) };
  }
  template <typename Lockable>
  lock_guard<Lockable> make_lock_guard(Lockable& mtx, adopt_lock_t)
  {
    return { thread_detail::lockable_adopt_wrapper<Lockable>(mtx) };
  }

}

# 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
# 87 "/usr/include/boost/thread/lock_guard.hpp" 2 3 4
# 12 "/usr/include/boost/thread/pthread/thread_data.hpp" 2 3 4


# 1 "/usr/include/boost/thread/pthread/condition_variable_fwd.hpp" 1 3 4








# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 58 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 59 "/usr/include/boost/assert.hpp" 2 3 4
# 10 "/usr/include/boost/thread/pthread/condition_variable_fwd.hpp" 2 3 4


# 1 "/usr/include/boost/thread/cv_status.hpp" 1 3 4
# 12 "/usr/include/boost/thread/cv_status.hpp" 3 4
# 1 "/usr/include/boost/core/scoped_enum.hpp" 1 3 4
# 19 "/usr/include/boost/core/scoped_enum.hpp" 3 4
namespace boost
{
# 72 "/usr/include/boost/core/scoped_enum.hpp" 3 4
  template <typename EnumType>
  struct native_type
  {
    typedef EnumType type;
  };

  template <typename UnderlyingType, typename EnumType>
  inline
  constexpr UnderlyingType underlying_cast(EnumType v) noexcept
  {
    return static_cast<UnderlyingType>(v);
  }

  template <typename EnumType>
  inline
  constexpr EnumType native_value(EnumType e) noexcept
  {
    return e;
  }


}
# 13 "/usr/include/boost/thread/cv_status.hpp" 2 3 4

namespace boost
{


  enum class cv_status
  {
    no_timeout,
    timeout
  }
  ;
}
# 13 "/usr/include/boost/thread/pthread/condition_variable_fwd.hpp" 2 3 4
# 32 "/usr/include/boost/thread/pthread/condition_variable_fwd.hpp" 3 4
# 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
# 33 "/usr/include/boost/thread/pthread/condition_variable_fwd.hpp" 2 3 4

namespace boost
{
    class condition_variable
    {
    private:

        pthread_mutex_t internal_mutex;

        pthread_cond_t cond;

    public:


        bool do_wait_until(
            unique_lock<mutex>& lock,
            detail::internal_platform_timepoint const &timeout);

    public:
      condition_variable(condition_variable const&) = delete; condition_variable& operator=(condition_variable const&) = delete;
        condition_variable()
        {
            int res;





            res=posix::pthread_mutex_init(&internal_mutex);
            if(res)
            {
                boost::throw_exception(thread_resource_error(res, "boost::condition_variable::condition_variable() constructor failed in pthread_mutex_init"));
            }

            res = posix::pthread_cond_init(&cond);
            if (res)
            {


                (static_cast <bool> (!posix::pthread_mutex_destroy(&internal_mutex)) ? void (0) : __assert_fail ("!posix::pthread_mutex_destroy(&internal_mutex)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));

                boost::throw_exception(thread_resource_error(res, "boost::condition_variable::condition_variable() constructor failed in pthread_cond_init"));
            }
        }
        ~condition_variable()
        {


            (static_cast <bool> (!posix::pthread_mutex_destroy(&internal_mutex)) ? void (0) : __assert_fail ("!posix::pthread_mutex_destroy(&internal_mutex)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));

            (static_cast <bool> (!posix::pthread_cond_destroy(&cond)) ? void (0) : __assert_fail ("!posix::pthread_cond_destroy(&cond)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        }

        void wait(unique_lock<mutex>& m);

        template<typename predicate_type>
        void wait(unique_lock<mutex>& m,predicate_type pred)
        {
            while (!pred())
            {
                wait(m);
            }
        }


        bool timed_wait(
            unique_lock<mutex>& m,
            boost::system_time const& abs_time)
        {



            const detail::real_platform_timepoint ts(abs_time);
# 115 "/usr/include/boost/thread/pthread/condition_variable_fwd.hpp" 3 4
            const detail::platform_duration d(ts - detail::real_platform_clock::now());
            do_wait_until(m, detail::internal_platform_clock::now() + d);
            return ts > detail::real_platform_clock::now();



        }
        bool timed_wait(
            unique_lock<mutex>& m,
            ::boost::xtime const& abs_time)
        {
            return timed_wait(m,system_time(abs_time));
        }

        template<typename duration_type>
        bool timed_wait(
            unique_lock<mutex>& m,
            duration_type const& wait_duration)
        {
            if (wait_duration.is_pos_infinity())
            {
                wait(m);
                return true;
            }
            if (wait_duration.is_special())
            {
                return true;
            }
            detail::platform_duration d(wait_duration);
# 156 "/usr/include/boost/thread/pthread/condition_variable_fwd.hpp" 3 4
            return do_wait_until(m, detail::internal_platform_clock::now() + d);

        }

        template<typename predicate_type>
        bool timed_wait(
            unique_lock<mutex>& m,
            boost::system_time const& abs_time,predicate_type pred)
        {



            const detail::real_platform_timepoint ts(abs_time);

            while (!pred())
            {




                detail::platform_duration d(ts - detail::real_platform_clock::now());
                if (d <= detail::platform_duration::zero()) break;
                d = (std::min)(d, detail::platform_milliseconds(100));
                do_wait_until(m, detail::internal_platform_clock::now() + d);



            }
            return pred();
        }

        template<typename predicate_type>
        bool timed_wait(
            unique_lock<mutex>& m,
            ::boost::xtime const& abs_time,predicate_type pred)
        {
            return timed_wait(m,system_time(abs_time),pred);
        }

        template<typename duration_type,typename predicate_type>
        bool timed_wait(
            unique_lock<mutex>& m,
            duration_type const& wait_duration,predicate_type pred)
        {
            if (wait_duration.is_pos_infinity())
            {
                while (!pred())
                {
                    wait(m);
                }
                return true;
            }
            if (wait_duration.is_special())
            {
                return pred();
            }
            detail::platform_duration d(wait_duration);
# 226 "/usr/include/boost/thread/pthread/condition_variable_fwd.hpp" 3 4
            const detail::internal_platform_timepoint ts(detail::internal_platform_clock::now() + d);
            while (!pred())
            {
                if (!do_wait_until(m, ts)) break;
            }

            return pred();
        }




        template <class Duration>
        cv_status
        wait_until(
                unique_lock<mutex>& lock,
                const chrono::time_point<detail::internal_chrono_clock, Duration>& t)
        {
            const detail::internal_platform_timepoint ts(t);
            if (do_wait_until(lock, ts)) return cv_status::no_timeout;
            else return cv_status::timeout;
        }

        template <class Clock, class Duration>
        cv_status
        wait_until(
                unique_lock<mutex>& lock,
                const chrono::time_point<Clock, Duration>& t)
        {







            typedef typename common_type<Duration, typename Clock::duration>::type common_duration;
            common_duration d(t - Clock::now());
            do_wait_until(lock, detail::internal_chrono_clock::now() + d);
            if (t > Clock::now()) return cv_status::no_timeout;
            else return cv_status::timeout;
        }

        template <class Rep, class Period>
        cv_status
        wait_for(
                unique_lock<mutex>& lock,
                const chrono::duration<Rep, Period>& d)
        {
            return wait_until(lock, chrono::steady_clock::now() + d);
        }

        template <class Duration, class Predicate>
        bool
        wait_until(
                unique_lock<mutex>& lock,
                const chrono::time_point<detail::internal_chrono_clock, Duration>& t,
                Predicate pred)
        {
            const detail::internal_platform_timepoint ts(t);
            while (!pred())
            {
                if (!do_wait_until(lock, ts)) break;
            }
            return pred();
        }

        template <class Clock, class Duration, class Predicate>
        bool
        wait_until(
                unique_lock<mutex>& lock,
                const chrono::time_point<Clock, Duration>& t,
                Predicate pred)
        {



            typedef typename common_type<Duration, typename Clock::duration>::type common_duration;
            while (!pred())
            {
                common_duration d(t - Clock::now());
                if (d <= common_duration::zero()) break;
                d = (std::min)(d, common_duration(chrono::milliseconds(100)));
                do_wait_until(lock, detail::internal_platform_clock::now() + detail::platform_duration(d));
            }
            return pred();
        }

        template <class Rep, class Period, class Predicate>
        bool
        wait_for(
                unique_lock<mutex>& lock,
                const chrono::duration<Rep, Period>& d,
                Predicate pred)
        {
            return wait_until(lock, chrono::steady_clock::now() + d, boost::move(pred));
        }



        typedef pthread_cond_t* native_handle_type;
        native_handle_type native_handle()
        {
            return &cond;
        }

        void notify_one() noexcept;
        void notify_all() noexcept;
    };

    __attribute__((__visibility__("default"))) void notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk);
}

# 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
# 340 "/usr/include/boost/thread/pthread/condition_variable_fwd.hpp" 2 3 4
# 15 "/usr/include/boost/thread/pthread/thread_data.hpp" 2 3 4



# 1 "/usr/include/boost/enable_shared_from_this.hpp" 1 3 4
# 16 "/usr/include/boost/enable_shared_from_this.hpp" 3 4
# 1 "/usr/include/boost/smart_ptr/enable_shared_from_this.hpp" 1 3 4
# 17 "/usr/include/boost/smart_ptr/enable_shared_from_this.hpp" 3 4
# 1 "/usr/include/boost/smart_ptr/weak_ptr.hpp" 1 3 4
# 23 "/usr/include/boost/smart_ptr/weak_ptr.hpp" 3 4
namespace boost
{

template<class T> class weak_ptr
{
private:


    typedef weak_ptr<T> this_type;

public:

    typedef typename boost::detail::sp_element< T >::type element_type;

    constexpr weak_ptr() noexcept : px(0), pn()
    {
    }







    weak_ptr( weak_ptr const & r ) noexcept : px( r.px ), pn( r.pn )
    {
    }

    weak_ptr & operator=( weak_ptr const & r ) noexcept
    {
        px = r.px;
        pn = r.pn;
        return *this;
    }
# 77 "/usr/include/boost/smart_ptr/weak_ptr.hpp" 3 4
    template<class Y>


    weak_ptr( weak_ptr<Y> const & r, typename boost::detail::sp_enable_if_convertible<Y,T>::type = boost::detail::sp_empty() )






    noexcept : px(r.lock().get()), pn(r.pn)
    {
        boost::detail::sp_assert_convertible< Y, T >();
    }



    template<class Y>


    weak_ptr( weak_ptr<Y> && r, typename boost::detail::sp_enable_if_convertible<Y,T>::type = boost::detail::sp_empty() )






    noexcept : px( r.lock().get() ), pn( static_cast< boost::detail::weak_count && >( r.pn ) )
    {
        boost::detail::sp_assert_convertible< Y, T >();
        r.px = 0;
    }


    weak_ptr( weak_ptr && r )
    noexcept : px( r.px ), pn( static_cast< boost::detail::weak_count && >( r.pn ) )
    {
        r.px = 0;
    }


    weak_ptr & operator=( weak_ptr && r ) noexcept
    {
        this_type( static_cast< weak_ptr && >( r ) ).swap( *this );
        return *this;
    }




    template<class Y>


    weak_ptr( shared_ptr<Y> const & r, typename boost::detail::sp_enable_if_convertible<Y,T>::type = boost::detail::sp_empty() )






    noexcept : px( r.px ), pn( r.pn )
    {
        boost::detail::sp_assert_convertible< Y, T >();
    }


    template<class Y> weak_ptr(shared_ptr<Y> const & r, element_type * p) noexcept: px( p ), pn( r.pn )
    {
    }

    template<class Y> weak_ptr(weak_ptr<Y> const & r, element_type * p) noexcept: px( p ), pn( r.pn )
    {
    }



    template<class Y> weak_ptr(weak_ptr<Y> && r, element_type * p) noexcept: px( p ), pn( std::move( r.pn ) )
    {
    }





    template<class Y>
    weak_ptr & operator=( weak_ptr<Y> const & r ) noexcept
    {
        boost::detail::sp_assert_convertible< Y, T >();

        px = r.lock().get();
        pn = r.pn;

        return *this;
    }



    template<class Y>
    weak_ptr & operator=( weak_ptr<Y> && r ) noexcept
    {
        this_type( static_cast< weak_ptr<Y> && >( r ) ).swap( *this );
        return *this;
    }



    template<class Y>
    weak_ptr & operator=( shared_ptr<Y> const & r ) noexcept
    {
        boost::detail::sp_assert_convertible< Y, T >();

        px = r.px;
        pn = r.pn;

        return *this;
    }



    shared_ptr<T> lock() const noexcept
    {
        return shared_ptr<T>( *this, boost::detail::sp_nothrow_tag() );
    }

    long use_count() const noexcept
    {
        return pn.use_count();
    }

    bool expired() const noexcept
    {
        return pn.use_count() == 0;
    }

    bool _empty() const noexcept
    {
        return pn.empty();
    }

    bool empty() const noexcept
    {
        return pn.empty();
    }

    void reset() noexcept
    {
        this_type().swap(*this);
    }

    void swap(this_type & other) noexcept
    {
        std::swap(px, other.px);
        pn.swap(other.pn);
    }

    template<class Y> bool owner_before( weak_ptr<Y> const & rhs ) const noexcept
    {
        return pn < rhs.pn;
    }

    template<class Y> bool owner_before( shared_ptr<Y> const & rhs ) const noexcept
    {
        return pn < rhs.pn;
    }

    template<class Y> bool owner_equals( weak_ptr<Y> const & rhs ) const noexcept
    {
        return pn == rhs.pn;
    }

    template<class Y> bool owner_equals( shared_ptr<Y> const & rhs ) const noexcept
    {
        return pn == rhs.pn;
    }

    std::size_t owner_hash_value() const noexcept
    {
        return pn.hash_value();
    }






private:

    template<class Y> friend class weak_ptr;
    template<class Y> friend class shared_ptr;



    element_type * px;
    boost::detail::weak_count pn;

};

template<class T, class U> inline bool operator<(weak_ptr<T> const & a, weak_ptr<U> const & b) noexcept
{
    return a.owner_before( b );
}

template<class T> void swap(weak_ptr<T> & a, weak_ptr<T> & b) noexcept
{
    a.swap(b);
}



template<class T> weak_ptr( shared_ptr<T> ) -> weak_ptr<T>;





template< class T > std::size_t hash_value( boost::weak_ptr<T> const & p ) noexcept
{
    return p.owner_hash_value();
}

}



namespace std
{



template<class T> struct hash< ::boost::weak_ptr<T> >
{
    std::size_t operator()( ::boost::weak_ptr<T> const & p ) const noexcept
    {
        return p.owner_hash_value();
    }
};



template<class T> struct equal_to< ::boost::weak_ptr<T> >
{
    bool operator()( ::boost::weak_ptr<T> const & a, ::boost::weak_ptr<T> const & b ) const noexcept
    {
        return a.owner_equals( b );
    }
};

}
# 18 "/usr/include/boost/smart_ptr/enable_shared_from_this.hpp" 2 3 4


# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 58 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 59 "/usr/include/boost/assert.hpp" 2 3 4
# 21 "/usr/include/boost/smart_ptr/enable_shared_from_this.hpp" 2 3 4


namespace boost
{

template<class T> class enable_shared_from_this
{
protected:

    constexpr enable_shared_from_this() noexcept
    {
    }

    constexpr enable_shared_from_this(enable_shared_from_this const &) noexcept
    {
    }

    enable_shared_from_this & operator=(enable_shared_from_this const &) noexcept
    {
        return *this;
    }

    ~enable_shared_from_this() noexcept
    {
    }

public:

    shared_ptr<T> shared_from_this()
    {
        shared_ptr<T> p( weak_this_ );
        (static_cast <bool> (p.get() == this) ? void (0) : __assert_fail ("p.get() == this", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        return p;
    }

    shared_ptr<T const> shared_from_this() const
    {
        shared_ptr<T const> p( weak_this_ );
        (static_cast <bool> (p.get() == this) ? void (0) : __assert_fail ("p.get() == this", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        return p;
    }

    weak_ptr<T> weak_from_this() noexcept
    {
        return weak_this_;
    }

    weak_ptr<T const> weak_from_this() const noexcept
    {
        return weak_this_;
    }

public:


    template<class X, class Y> void _internal_accept_owner( shared_ptr<X> const * ppx, Y * py ) const noexcept
    {
        if( weak_this_.expired() )
        {
            weak_this_ = shared_ptr<T>( *ppx, py );
        }
    }

private:

    mutable weak_ptr<T> weak_this_;
};

}
# 17 "/usr/include/boost/enable_shared_from_this.hpp" 2 3 4
# 19 "/usr/include/boost/thread/pthread/thread_data.hpp" 2 3 4
# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 58 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 59 "/usr/include/boost/assert.hpp" 2 3 4
# 20 "/usr/include/boost/thread/pthread/thread_data.hpp" 2 3 4





# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/map" 1 3 4
# 59 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/map" 3




# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_map.h" 1 3
# 66 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_map.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{



  template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    class multimap;
# 100 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_map.h" 3
  template <typename _Key, typename _Tp, typename _Compare = std::less<_Key>,
     typename _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
    class map
    {
    public:
      typedef _Key key_type;
      typedef _Tp mapped_type;
      typedef std::pair<const _Key, _Tp> value_type;
      typedef _Compare key_compare;
      typedef _Alloc allocator_type;

    private:
# 125 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_map.h" 3
      static_assert(is_same<typename _Alloc::value_type, value_type>::value,
   "std::map must have the same value_type as its allocator");



    public:
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
      class value_compare
      : public std::binary_function<value_type, value_type, bool>
      {
 friend class map<_Key, _Tp, _Compare, _Alloc>;
      protected:
 _Compare comp;

 value_compare(_Compare __c)
 : comp(__c) { }

      public:
 bool operator()(const value_type& __x, const value_type& __y) const
 { return comp(__x.first, __y.first); }
      };
#pragma GCC diagnostic pop

    private:

      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
 rebind<value_type>::other _Pair_alloc_type;

      typedef _Rb_tree<key_type, value_type, _Select1st<value_type>,
         key_compare, _Pair_alloc_type> _Rep_type;


      _Rep_type _M_t;

      typedef __gnu_cxx::__alloc_traits<_Pair_alloc_type> _Alloc_traits;


      template<typename _Up, typename _Vp = remove_reference_t<_Up>>
 static constexpr bool __usable_key
   = __or_v<is_same<const _Vp, const _Key>,
     __and_<is_scalar<_Vp>, is_scalar<_Key>>>;


    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;
# 197 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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)) { }
# 219 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_map.h" 3
      map(const map&) = default;







      map(map&&) = default;
# 240 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_map.h" 3
      map(initializer_list<value_type> __l,
   const _Compare& __comp = _Compare(),
   const allocator_type& __a = allocator_type())
      : _M_t(__comp, _Pair_alloc_type(__a))
      { _M_t._M_insert_range_unique(__l.begin(), __l.end()); }


      explicit
      map(const allocator_type& __a)
      : _M_t(_Pair_alloc_type(__a)) { }


      map(const map& __m, const __type_identity_t<allocator_type>& __a)
      : _M_t(__m._M_t, _Pair_alloc_type(__a)) { }


      map(map&& __m, const __type_identity_t<allocator_type>& __a)
      noexcept(is_nothrow_copy_constructible<_Compare>::value
        && _Alloc_traits::_S_always_equal())
      : _M_t(std::move(__m._M_t), _Pair_alloc_type(__a)) { }


      map(initializer_list<value_type> __l, const allocator_type& __a)
      : _M_t(_Pair_alloc_type(__a))
      { _M_t._M_insert_range_unique(__l.begin(), __l.end()); }


      template<typename _InputIterator>
 map(_InputIterator __first, _InputIterator __last,
     const allocator_type& __a)
 : _M_t(_Pair_alloc_type(__a))
 { _M_t._M_insert_range_unique(__first, __last); }
# 284 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_map.h" 3
      template<typename _InputIterator>
 map(_InputIterator __first, _InputIterator __last)
 : _M_t()
 { _M_t._M_insert_range_unique(__first, __last); }
# 301 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_map.h" 3
      template<typename _InputIterator>
 map(_InputIterator __first, _InputIterator __last,
     const _Compare& __comp,
     const allocator_type& __a = allocator_type())
 : _M_t(__comp, _Pair_alloc_type(__a))
 { _M_t._M_insert_range_unique(__first, __last); }







      ~map() = default;
# 330 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_map.h" 3
      map&
      operator=(const map&) = default;


      map&
      operator=(map&&) = default;
# 348 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_map.h" 3
      map&
      operator=(initializer_list<value_type> __l)
      {
 _M_t._M_assign_unique(__l.begin(), __l.end());
 return *this;
      }



      allocator_type
      get_allocator() const noexcept
      { return allocator_type(_M_t.get_allocator()); }







      iterator
      begin() noexcept
      { return _M_t.begin(); }






      const_iterator
      begin() const noexcept
      { return _M_t.begin(); }






      iterator
      end() noexcept
      { return _M_t.end(); }






      const_iterator
      end() const noexcept
      { return _M_t.end(); }






      reverse_iterator
      rbegin() noexcept
      { return _M_t.rbegin(); }






      const_reverse_iterator
      rbegin() const noexcept
      { return _M_t.rbegin(); }






      reverse_iterator
      rend() noexcept
      { return _M_t.rend(); }






      const_reverse_iterator
      rend() const noexcept
      { return _M_t.rend(); }







      const_iterator
      cbegin() const noexcept
      { return _M_t.begin(); }






      const_iterator
      cend() const noexcept
      { return _M_t.end(); }






      const_reverse_iterator
      crbegin() const noexcept
      { return _M_t.rbegin(); }






      const_reverse_iterator
      crend() const noexcept
      { return _M_t.rend(); }






      [[__nodiscard__]] bool
      empty() const noexcept
      { return _M_t.empty(); }


      size_type
      size() const noexcept
      { return _M_t.size(); }


      size_type
      max_size() const noexcept
      { return _M_t.max_size(); }
# 503 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_map.h" 3
      mapped_type&
      operator[](const key_type& __k)
      {



 iterator __i = lower_bound(__k);

 if (__i == end() || key_comp()(__k, (*__i).first))

   __i = _M_t._M_emplace_hint_unique(__i, std::piecewise_construct,
         std::tuple<const key_type&>(__k),
         std::tuple<>());



 return (*__i).second;
      }


      mapped_type&
      operator[](key_type&& __k)
      {



 iterator __i = lower_bound(__k);

 if (__i == end() || key_comp()(__k, (*__i).first))
   __i = _M_t._M_emplace_hint_unique(__i, std::piecewise_construct,
     std::forward_as_tuple(std::move(__k)),
     std::tuple<>());
 return (*__i).second;
      }
# 548 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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;
      }
# 586 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_map.h" 3
      template<typename... _Args>
 std::pair<iterator, bool>
 emplace(_Args&&... __args)
 {

   if constexpr (sizeof...(_Args) == 2)
     if constexpr (is_same_v<allocator_type, allocator<value_type>>)
       {
  auto&& [__a, __v] = pair<_Args&...>(__args...);
  if constexpr (__usable_key<decltype(__a)>)
    {
      const key_type& __k = __a;
      iterator __i = lower_bound(__k);
      if (__i == end() || key_comp()(__k, (*__i).first))
        {
   __i = emplace_hint(__i, std::forward<_Args>(__args)...);
   return {__i, true};
        }
      return {__i, false};
    }
       }

   return _M_t._M_emplace_unique(std::forward<_Args>(__args)...);
 }
# 636 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_map.h" 3
      template<typename... _Args>
 iterator
 emplace_hint(const_iterator __pos, _Args&&... __args)
 {
   return _M_t._M_emplace_hint_unique(__pos,
          std::forward<_Args>(__args)...);
 }




      node_type
      extract(const_iterator __pos)
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__pos != end()), false)) std::__glibcxx_assert_fail(); } while (false);
 return _M_t.extract(__pos);
      }


      node_type
      extract(const key_type& __x)
      { return _M_t.extract(__x); }


      insert_return_type
      insert(node_type&& __nh)
      { return _M_t._M_reinsert_node_unique(std::move(__nh)); }


      iterator
      insert(const_iterator __hint, node_type&& __nh)
      { return _M_t._M_reinsert_node_hint_unique(__hint, std::move(__nh)); }

      template<typename, typename>
 friend struct std::_Rb_tree_merge_helper;

      template<typename _Cmp2>
 void
 merge(map<_Key, _Tp, _Cmp2, _Alloc>& __source)
 {
   using _Merge_helper = _Rb_tree_merge_helper<map, _Cmp2>;
   _M_t._M_merge_unique(_Merge_helper::_S_get_tree(__source));
 }

      template<typename _Cmp2>
 void
 merge(map<_Key, _Tp, _Cmp2, _Alloc>&& __source)
 { merge(__source); }

      template<typename _Cmp2>
 void
 merge(multimap<_Key, _Tp, _Cmp2, _Alloc>& __source)
 {
   using _Merge_helper = _Rb_tree_merge_helper<map, _Cmp2>;
   _M_t._M_merge_unique(_Merge_helper::_S_get_tree(__source));
 }

      template<typename _Cmp2>
 void
 merge(multimap<_Key, _Tp, _Cmp2, _Alloc>&& __source)
 { merge(__source); }
# 720 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_map.h" 3
      template <typename... _Args>
 pair<iterator, bool>
 try_emplace(const key_type& __k, _Args&&... __args)
 {
   iterator __i = lower_bound(__k);
   if (__i == end() || key_comp()(__k, (*__i).first))
     {
       __i = emplace_hint(__i, std::piecewise_construct,
     std::forward_as_tuple(__k),
     std::forward_as_tuple(
       std::forward<_Args>(__args)...));
       return {__i, true};
     }
   return {__i, false};
 }


      template <typename... _Args>
 pair<iterator, bool>
 try_emplace(key_type&& __k, _Args&&... __args)
 {
   iterator __i = lower_bound(__k);
   if (__i == end() || key_comp()(__k, (*__i).first))
     {
       __i = emplace_hint(__i, std::piecewise_construct,
     std::forward_as_tuple(std::move(__k)),
     std::forward_as_tuple(
       std::forward<_Args>(__args)...));
       return {__i, true};
     }
   return {__i, false};
 }
# 780 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_map.h" 3
      template <typename... _Args>
 iterator
 try_emplace(const_iterator __hint, const key_type& __k,
      _Args&&... __args)
 {
   iterator __i;
   auto __true_hint = _M_t._M_get_insert_hint_unique_pos(__hint, __k);
   if (__true_hint.second)
     __i = emplace_hint(iterator(__true_hint.second),
          std::piecewise_construct,
          std::forward_as_tuple(__k),
          std::forward_as_tuple(
     std::forward<_Args>(__args)...));
   else
     __i = iterator(__true_hint.first);
   return __i;
 }


      template <typename... _Args>
 iterator
 try_emplace(const_iterator __hint, key_type&& __k, _Args&&... __args)
 {
   iterator __i;
   auto __true_hint = _M_t._M_get_insert_hint_unique_pos(__hint, __k);
   if (__true_hint.second)
     __i = emplace_hint(iterator(__true_hint.second),
          std::piecewise_construct,
          std::forward_as_tuple(std::move(__k)),
          std::forward_as_tuple(
     std::forward<_Args>(__args)...));
   else
     __i = iterator(__true_hint.first);
   return __i;
 }
# 833 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_map.h" 3
      std::pair<iterator, bool>
      insert(const value_type& __x)
      { return _M_t._M_insert_unique(__x); }




      std::pair<iterator, bool>
      insert(value_type&& __x)
      { return _M_t._M_insert_unique(std::move(__x)); }

      template<typename _Pair>
 __enable_if_t<is_constructible<value_type, _Pair>::value,
        pair<iterator, bool>>
 insert(_Pair&& __x)
 {

   using _P2 = remove_reference_t<_Pair>;
   if constexpr (__is_pair<remove_const_t<_P2>>)
     if constexpr (is_same_v<allocator_type, allocator<value_type>>)
       if constexpr (__usable_key<typename _P2::first_type>)
  {
    const key_type& __k = __x.first;
    iterator __i = lower_bound(__k);
    if (__i == end() || key_comp()(__k, (*__i).first))
      {
        __i = emplace_hint(__i, std::forward<_Pair>(__x));
        return {__i, true};
      }
    return {__i, false};
  }

   return _M_t._M_emplace_unique(std::forward<_Pair>(__x));
 }
# 878 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_map.h" 3
      void
      insert(std::initializer_list<value_type> __list)
      { insert(__list.begin(), __list.end()); }
# 907 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_map.h" 3
      iterator

      insert(const_iterator __position, const value_type& __x)



      { return _M_t._M_insert_unique_(__position, __x); }




      iterator
      insert(const_iterator __position, value_type&& __x)
      { return _M_t._M_insert_unique_(__position, std::move(__x)); }

      template<typename _Pair>
 __enable_if_t<is_constructible<value_type, _Pair>::value, iterator>
 insert(const_iterator __position, _Pair&& __x)
 {
   return _M_t._M_emplace_hint_unique(__position,
          std::forward<_Pair>(__x));
 }
# 940 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_map.h" 3
      template<typename _InputIterator>
 void
 insert(_InputIterator __first, _InputIterator __last)
 { _M_t._M_insert_range_unique(__first, __last); }
# 965 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_map.h" 3
      template <typename _Obj>
 pair<iterator, bool>
 insert_or_assign(const key_type& __k, _Obj&& __obj)
 {
   iterator __i = lower_bound(__k);
   if (__i == end() || key_comp()(__k, (*__i).first))
     {
       __i = emplace_hint(__i, std::piecewise_construct,
     std::forward_as_tuple(__k),
     std::forward_as_tuple(
       std::forward<_Obj>(__obj)));
       return {__i, true};
     }
   (*__i).second = std::forward<_Obj>(__obj);
   return {__i, false};
 }


      template <typename _Obj>
 pair<iterator, bool>
 insert_or_assign(key_type&& __k, _Obj&& __obj)
 {
   iterator __i = lower_bound(__k);
   if (__i == end() || key_comp()(__k, (*__i).first))
     {
       __i = emplace_hint(__i, std::piecewise_construct,
     std::forward_as_tuple(std::move(__k)),
     std::forward_as_tuple(
       std::forward<_Obj>(__obj)));
       return {__i, true};
     }
   (*__i).second = std::forward<_Obj>(__obj);
   return {__i, false};
 }
# 1020 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_map.h" 3
      template <typename _Obj>
 iterator
 insert_or_assign(const_iterator __hint,
    const key_type& __k, _Obj&& __obj)
 {
   iterator __i;
   auto __true_hint = _M_t._M_get_insert_hint_unique_pos(__hint, __k);
   if (__true_hint.second)
     {
       return emplace_hint(iterator(__true_hint.second),
      std::piecewise_construct,
      std::forward_as_tuple(__k),
      std::forward_as_tuple(
        std::forward<_Obj>(__obj)));
     }
   __i = iterator(__true_hint.first);
   (*__i).second = std::forward<_Obj>(__obj);
   return __i;
 }


      template <typename _Obj>
 iterator
 insert_or_assign(const_iterator __hint, key_type&& __k, _Obj&& __obj)
 {
   iterator __i;
   auto __true_hint = _M_t._M_get_insert_hint_unique_pos(__hint, __k);
   if (__true_hint.second)
     {
       return emplace_hint(iterator(__true_hint.second),
      std::piecewise_construct,
      std::forward_as_tuple(std::move(__k)),
      std::forward_as_tuple(
        std::forward<_Obj>(__obj)));
     }
   __i = iterator(__true_hint.first);
   (*__i).second = std::forward<_Obj>(__obj);
   return __i;
 }
# 1079 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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); }
# 1116 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_map.h" 3
      size_type
      erase(const key_type& __x)
      { return _M_t.erase(__x); }
# 1136 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_map.h" 3
      iterator
      erase(const_iterator __first, const_iterator __last)
      { return _M_t.erase(__first, __last); }
# 1170 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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()); }
# 1217 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_map.h" 3
      iterator
      find(const key_type& __x)
      { return _M_t.find(__x); }


      template<typename _Kt>
 auto
 find(const _Kt& __x) -> decltype(_M_t._M_find_tr(__x))
 { return _M_t._M_find_tr(__x); }
# 1242 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_map.h" 3
      const_iterator
      find(const key_type& __x) const
      { return _M_t.find(__x); }


      template<typename _Kt>
 auto
 find(const _Kt& __x) const -> decltype(_M_t._M_find_tr(__x))
 { return _M_t._M_find_tr(__x); }
# 1263 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_map.h" 3
      size_type
      count(const key_type& __x) const
      { return _M_t.find(__x) == _M_t.end() ? 0 : 1; }


      template<typename _Kt>
 auto
 count(const _Kt& __x) const -> decltype(_M_t._M_count_tr(__x))
 { return _M_t._M_count_tr(__x); }
# 1282 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_map.h" 3
      bool
      contains(const key_type& __x) const
      { return _M_t.find(__x) != _M_t.end(); }

      template<typename _Kt>
 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(); }
# 1306 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_map.h" 3
      iterator
      lower_bound(const key_type& __x)
      { return _M_t.lower_bound(__x); }


      template<typename _Kt>
 auto
 lower_bound(const _Kt& __x)
 -> decltype(iterator(_M_t._M_lower_bound_tr(__x)))
 { return iterator(_M_t._M_lower_bound_tr(__x)); }
# 1331 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_map.h" 3
      const_iterator
      lower_bound(const key_type& __x) const
      { return _M_t.lower_bound(__x); }


      template<typename _Kt>
 auto
 lower_bound(const _Kt& __x) const
 -> decltype(const_iterator(_M_t._M_lower_bound_tr(__x)))
 { return const_iterator(_M_t._M_lower_bound_tr(__x)); }
# 1351 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_map.h" 3
      iterator
      upper_bound(const key_type& __x)
      { return _M_t.upper_bound(__x); }


      template<typename _Kt>
 auto
 upper_bound(const _Kt& __x)
 -> decltype(iterator(_M_t._M_upper_bound_tr(__x)))
 { return iterator(_M_t._M_upper_bound_tr(__x)); }
# 1371 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_map.h" 3
      const_iterator
      upper_bound(const key_type& __x) const
      { return _M_t.upper_bound(__x); }


      template<typename _Kt>
 auto
 upper_bound(const _Kt& __x) const
 -> decltype(const_iterator(_M_t._M_upper_bound_tr(__x)))
 { return const_iterator(_M_t._M_upper_bound_tr(__x)); }
# 1400 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_map.h" 3
      std::pair<iterator, iterator>
      equal_range(const key_type& __x)
      { return _M_t.equal_range(__x); }


      template<typename _Kt>
 auto
 equal_range(const _Kt& __x)
 -> decltype(pair<iterator, iterator>(_M_t._M_equal_range_tr(__x)))
 { return pair<iterator, iterator>(_M_t._M_equal_range_tr(__x)); }
# 1429 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_map.h" 3
      std::pair<const_iterator, const_iterator>
      equal_range(const key_type& __x) const
      { return _M_t.equal_range(__x); }


      template<typename _Kt>
 auto
 equal_range(const _Kt& __x) const
 -> decltype(pair<const_iterator, const_iterator>(
       _M_t._M_equal_range_tr(__x)))
 {
   return pair<const_iterator, const_iterator>(
       _M_t._M_equal_range_tr(__x));
 }



      template<typename _K1, typename _T1, typename _C1, typename _A1>
 friend bool
 operator==(const map<_K1, _T1, _C1, _A1>&,
     const map<_K1, _T1, _C1, _A1>&);


      template<typename _K1, typename _T1, typename _C1, typename _A1>
 friend __detail::__synth3way_t<pair<const _K1, _T1>>
 operator<=>(const map<_K1, _T1, _C1, _A1>&,
      const map<_K1, _T1, _C1, _A1>&);






    };




  template<typename _InputIterator,
    typename _Compare = less<__iter_key_t<_InputIterator>>,
    typename _Allocator = allocator<__iter_to_alloc_t<_InputIterator>>,
    typename = _RequireInputIter<_InputIterator>,
    typename = _RequireNotAllocator<_Compare>,
    typename = _RequireAllocator<_Allocator>>
    map(_InputIterator, _InputIterator,
 _Compare = _Compare(), _Allocator = _Allocator())
    -> map<__iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>,
    _Compare, _Allocator>;

  template<typename _Key, typename _Tp, typename _Compare = less<_Key>,
    typename _Allocator = allocator<pair<const _Key, _Tp>>,
    typename = _RequireNotAllocator<_Compare>,
    typename = _RequireAllocator<_Allocator>>
    map(initializer_list<pair<_Key, _Tp>>,
 _Compare = _Compare(), _Allocator = _Allocator())
    -> map<_Key, _Tp, _Compare, _Allocator>;

  template <typename _InputIterator, typename _Allocator,
     typename = _RequireInputIter<_InputIterator>,
     typename = _RequireAllocator<_Allocator>>
    map(_InputIterator, _InputIterator, _Allocator)
    -> map<__iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>,
    less<__iter_key_t<_InputIterator>>, _Allocator>;

  template<typename _Key, typename _Tp, typename _Allocator,
    typename = _RequireAllocator<_Allocator>>
    map(initializer_list<pair<_Key, _Tp>>, _Allocator)
    -> map<_Key, _Tp, less<_Key>, _Allocator>;
# 1510 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_map.h" 3
  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    inline bool
    operator==(const map<_Key, _Tp, _Compare, _Alloc>& __x,
        const map<_Key, _Tp, _Compare, _Alloc>& __y)
    { return __x._M_t == __y._M_t; }
# 1531 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_map.h" 3
  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    inline __detail::__synth3way_t<pair<const _Key, _Tp>>
    operator<=>(const map<_Key, _Tp, _Compare, _Alloc>& __x,
  const map<_Key, _Tp, _Compare, _Alloc>& __y)
    { return __x._M_t <=> __y._M_t; }
# 1584 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_map.h" 3
  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    inline void
    swap(map<_Key, _Tp, _Compare, _Alloc>& __x,
  map<_Key, _Tp, _Compare, _Alloc>& __y)
    noexcept(noexcept(__x.swap(__y)))
    { __x.swap(__y); }





  template<typename _Key, typename _Val, typename _Cmp1, typename _Alloc,
    typename _Cmp2>
    struct
    _Rb_tree_merge_helper<std::map<_Key, _Val, _Cmp1, _Alloc>,
     _Cmp2>
    {
    private:
      friend class std::map<_Key, _Val, _Cmp1, _Alloc>;

      static auto&
      _S_get_tree(std::map<_Key, _Val, _Cmp2, _Alloc>& __map)
      { return __map._M_t; }

      static auto&
      _S_get_tree(std::multimap<_Key, _Val, _Cmp2, _Alloc>& __map)
      { return __map._M_t; }
    };



}
# 64 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/map" 2 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multimap.h" 1 3
# 64 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multimap.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{



  template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    class map;
# 98 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multimap.h" 3
  template <typename _Key, typename _Tp,
     typename _Compare = std::less<_Key>,
     typename _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
    class multimap
    {
    public:
      typedef _Key key_type;
      typedef _Tp mapped_type;
      typedef std::pair<const _Key, _Tp> value_type;
      typedef _Compare key_compare;
      typedef _Alloc allocator_type;

    private:
# 124 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multimap.h" 3
      static_assert(is_same<typename _Alloc::value_type, value_type>::value,
   "std::multimap must have the same value_type as its allocator");



    public:
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
      class value_compare
      : public std::binary_function<value_type, value_type, bool>
      {
 friend class multimap<_Key, _Tp, _Compare, _Alloc>;
      protected:
 _Compare comp;

 value_compare(_Compare __c)
 : comp(__c) { }

      public:
 bool operator()(const value_type& __x, const value_type& __y) const
 { return comp(__x.first, __y.first); }
      };
#pragma GCC diagnostic pop

    private:

      typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
 rebind<value_type>::other _Pair_alloc_type;

      typedef _Rb_tree<key_type, value_type, _Select1st<value_type>,
         key_compare, _Pair_alloc_type> _Rep_type;

      _Rep_type _M_t;

      typedef __gnu_cxx::__alloc_traits<_Pair_alloc_type> _Alloc_traits;

    public:


      typedef typename _Alloc_traits::pointer pointer;
      typedef typename _Alloc_traits::const_pointer const_pointer;
      typedef typename _Alloc_traits::reference reference;
      typedef typename _Alloc_traits::const_reference const_reference;
      typedef typename _Rep_type::iterator iterator;
      typedef typename _Rep_type::const_iterator const_iterator;
      typedef typename _Rep_type::size_type size_type;
      typedef typename _Rep_type::difference_type difference_type;
      typedef typename _Rep_type::reverse_iterator reverse_iterator;
      typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator;


      using node_type = typename _Rep_type::node_type;
# 187 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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)) { }
# 209 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multimap.h" 3
      multimap(const multimap&) = default;
# 218 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multimap.h" 3
      multimap(multimap&&) = default;
# 230 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multimap.h" 3
      multimap(initializer_list<value_type> __l,
        const _Compare& __comp = _Compare(),
        const allocator_type& __a = allocator_type())
      : _M_t(__comp, _Pair_alloc_type(__a))
      { _M_t._M_insert_range_equal(__l.begin(), __l.end()); }


      explicit
      multimap(const allocator_type& __a)
      : _M_t(_Pair_alloc_type(__a)) { }


      multimap(const multimap& __m,
        const __type_identity_t<allocator_type>& __a)
      : _M_t(__m._M_t, _Pair_alloc_type(__a)) { }


      multimap(multimap&& __m, const __type_identity_t<allocator_type>& __a)
      noexcept(is_nothrow_copy_constructible<_Compare>::value
        && _Alloc_traits::_S_always_equal())
      : _M_t(std::move(__m._M_t), _Pair_alloc_type(__a)) { }


      multimap(initializer_list<value_type> __l, const allocator_type& __a)
      : _M_t(_Pair_alloc_type(__a))
      { _M_t._M_insert_range_equal(__l.begin(), __l.end()); }


      template<typename _InputIterator>
 multimap(_InputIterator __first, _InputIterator __last,
   const allocator_type& __a)
 : _M_t(_Pair_alloc_type(__a))
 { _M_t._M_insert_range_equal(__first, __last); }
# 274 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multimap.h" 3
      template<typename _InputIterator>
 multimap(_InputIterator __first, _InputIterator __last)
 : _M_t()
 { _M_t._M_insert_range_equal(__first, __last); }
# 290 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multimap.h" 3
      template<typename _InputIterator>
 multimap(_InputIterator __first, _InputIterator __last,
   const _Compare& __comp,
   const allocator_type& __a = allocator_type())
 : _M_t(__comp, _Pair_alloc_type(__a))
 { _M_t._M_insert_range_equal(__first, __last); }







      ~multimap() = default;
# 319 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multimap.h" 3
      multimap&
      operator=(const multimap&) = default;


      multimap&
      operator=(multimap&&) = default;
# 337 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multimap.h" 3
      multimap&
      operator=(initializer_list<value_type> __l)
      {
 _M_t._M_assign_equal(__l.begin(), __l.end());
 return *this;
      }



      allocator_type
      get_allocator() const noexcept
      { return allocator_type(_M_t.get_allocator()); }







      iterator
      begin() noexcept
      { return _M_t.begin(); }






      const_iterator
      begin() const noexcept
      { return _M_t.begin(); }






      iterator
      end() noexcept
      { return _M_t.end(); }






      const_iterator
      end() const noexcept
      { return _M_t.end(); }






      reverse_iterator
      rbegin() noexcept
      { return _M_t.rbegin(); }






      const_reverse_iterator
      rbegin() const noexcept
      { return _M_t.rbegin(); }






      reverse_iterator
      rend() noexcept
      { return _M_t.rend(); }






      const_reverse_iterator
      rend() const noexcept
      { return _M_t.rend(); }







      const_iterator
      cbegin() const noexcept
      { return _M_t.begin(); }






      const_iterator
      cend() const noexcept
      { return _M_t.end(); }






      const_reverse_iterator
      crbegin() const noexcept
      { return _M_t.rbegin(); }






      const_reverse_iterator
      crend() const noexcept
      { return _M_t.rend(); }




      [[__nodiscard__]] bool
      empty() const noexcept
      { return _M_t.empty(); }


      size_type
      size() const noexcept
      { return _M_t.size(); }


      size_type
      max_size() const noexcept
      { return _M_t.max_size(); }
# 495 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multimap.h" 3
      template<typename... _Args>
 iterator
 emplace(_Args&&... __args)
 { return _M_t._M_emplace_equal(std::forward<_Args>(__args)...); }
# 522 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multimap.h" 3
      template<typename... _Args>
 iterator
 emplace_hint(const_iterator __pos, _Args&&... __args)
 {
   return _M_t._M_emplace_hint_equal(__pos,
         std::forward<_Args>(__args)...);
 }
# 544 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multimap.h" 3
      iterator
      insert(const value_type& __x)
      { return _M_t._M_insert_equal(__x); }




      iterator
      insert(value_type&& __x)
      { return _M_t._M_insert_equal(std::move(__x)); }

      template<typename _Pair>
 __enable_if_t<is_constructible<value_type, _Pair>::value, iterator>
 insert(_Pair&& __x)
 { return _M_t._M_emplace_equal(std::forward<_Pair>(__x)); }
# 583 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multimap.h" 3
      iterator

      insert(const_iterator __position, const value_type& __x)



      { return _M_t._M_insert_equal_(__position, __x); }




      iterator
      insert(const_iterator __position, value_type&& __x)
      { return _M_t._M_insert_equal_(__position, std::move(__x)); }

      template<typename _Pair>
 __enable_if_t<is_constructible<value_type, _Pair&&>::value, iterator>
 insert(const_iterator __position, _Pair&& __x)
 {
   return _M_t._M_emplace_hint_equal(__position,
         std::forward<_Pair>(__x));
 }
# 617 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multimap.h" 3
      template<typename _InputIterator>
 void
 insert(_InputIterator __first, _InputIterator __last)
 { _M_t._M_insert_range_equal(__first, __last); }
# 630 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multimap.h" 3
      void
      insert(initializer_list<value_type> __l)
      { this->insert(__l.begin(), __l.end()); }




      node_type
      extract(const_iterator __pos)
      {
 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(__pos != end()), false)) std::__glibcxx_assert_fail(); } while (false);
 return _M_t.extract(__pos);
      }


      node_type
      extract(const key_type& __x)
      { return _M_t.extract(__x); }


      iterator
      insert(node_type&& __nh)
      { return _M_t._M_reinsert_node_equal(std::move(__nh)); }


      iterator
      insert(const_iterator __hint, node_type&& __nh)
      { return _M_t._M_reinsert_node_hint_equal(__hint, std::move(__nh)); }

      template<typename, typename>
 friend struct std::_Rb_tree_merge_helper;

      template<typename _Cmp2>
 void
 merge(multimap<_Key, _Tp, _Cmp2, _Alloc>& __source)
 {
   using _Merge_helper = _Rb_tree_merge_helper<multimap, _Cmp2>;
   _M_t._M_merge_equal(_Merge_helper::_S_get_tree(__source));
 }

      template<typename _Cmp2>
 void
 merge(multimap<_Key, _Tp, _Cmp2, _Alloc>&& __source)
 { merge(__source); }

      template<typename _Cmp2>
 void
 merge(map<_Key, _Tp, _Cmp2, _Alloc>& __source)
 {
   using _Merge_helper = _Rb_tree_merge_helper<multimap, _Cmp2>;
   _M_t._M_merge_equal(_Merge_helper::_S_get_tree(__source));
 }

      template<typename _Cmp2>
 void
 merge(map<_Key, _Tp, _Cmp2, _Alloc>&& __source)
 { merge(__source); }
# 707 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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); }
# 744 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multimap.h" 3
      size_type
      erase(const key_type& __x)
      { return _M_t.erase(__x); }
# 765 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multimap.h" 3
      iterator
      erase(const_iterator __first, const_iterator __last)
      { return _M_t.erase(__first, __last); }
# 802 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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()); }
# 848 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multimap.h" 3
      iterator
      find(const key_type& __x)
      { return _M_t.find(__x); }


      template<typename _Kt>
 auto
 find(const _Kt& __x) -> decltype(_M_t._M_find_tr(__x))
 { return _M_t._M_find_tr(__x); }
# 872 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multimap.h" 3
      const_iterator
      find(const key_type& __x) const
      { return _M_t.find(__x); }


      template<typename _Kt>
 auto
 find(const _Kt& __x) const -> decltype(_M_t._M_find_tr(__x))
 { return _M_t._M_find_tr(__x); }
# 890 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multimap.h" 3
      size_type
      count(const key_type& __x) const
      { return _M_t.count(__x); }


      template<typename _Kt>
 auto
 count(const _Kt& __x) const -> decltype(_M_t._M_count_tr(__x))
 { return _M_t._M_count_tr(__x); }
# 909 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multimap.h" 3
      bool
      contains(const key_type& __x) const
      { return _M_t.find(__x) != _M_t.end(); }

      template<typename _Kt>
 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(); }
# 933 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multimap.h" 3
      iterator
      lower_bound(const key_type& __x)
      { return _M_t.lower_bound(__x); }


      template<typename _Kt>
 auto
 lower_bound(const _Kt& __x)
 -> decltype(iterator(_M_t._M_lower_bound_tr(__x)))
 { return iterator(_M_t._M_lower_bound_tr(__x)); }
# 958 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multimap.h" 3
      const_iterator
      lower_bound(const key_type& __x) const
      { return _M_t.lower_bound(__x); }


      template<typename _Kt>
 auto
 lower_bound(const _Kt& __x) const
 -> decltype(const_iterator(_M_t._M_lower_bound_tr(__x)))
 { return const_iterator(_M_t._M_lower_bound_tr(__x)); }
# 978 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multimap.h" 3
      iterator
      upper_bound(const key_type& __x)
      { return _M_t.upper_bound(__x); }


      template<typename _Kt>
 auto
 upper_bound(const _Kt& __x)
 -> decltype(iterator(_M_t._M_upper_bound_tr(__x)))
 { return iterator(_M_t._M_upper_bound_tr(__x)); }
# 998 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multimap.h" 3
      const_iterator
      upper_bound(const key_type& __x) const
      { return _M_t.upper_bound(__x); }


      template<typename _Kt>
 auto
 upper_bound(const _Kt& __x) const
 -> decltype(const_iterator(_M_t._M_upper_bound_tr(__x)))
 { return const_iterator(_M_t._M_upper_bound_tr(__x)); }
# 1025 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multimap.h" 3
      std::pair<iterator, iterator>
      equal_range(const key_type& __x)
      { return _M_t.equal_range(__x); }


      template<typename _Kt>
 auto
 equal_range(const _Kt& __x)
 -> decltype(pair<iterator, iterator>(_M_t._M_equal_range_tr(__x)))
 { return pair<iterator, iterator>(_M_t._M_equal_range_tr(__x)); }
# 1052 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multimap.h" 3
      std::pair<const_iterator, const_iterator>
      equal_range(const key_type& __x) const
      { return _M_t.equal_range(__x); }


      template<typename _Kt>
 auto
 equal_range(const _Kt& __x) const
 -> decltype(pair<const_iterator, const_iterator>(
       _M_t._M_equal_range_tr(__x)))
 {
   return pair<const_iterator, const_iterator>(
       _M_t._M_equal_range_tr(__x));
 }



      template<typename _K1, typename _T1, typename _C1, typename _A1>
 friend bool
 operator==(const multimap<_K1, _T1, _C1, _A1>&,
     const multimap<_K1, _T1, _C1, _A1>&);


      template<typename _K1, typename _T1, typename _C1, typename _A1>
 friend __detail::__synth3way_t<pair<const _K1, _T1>>
 operator<=>(const multimap<_K1, _T1, _C1, _A1>&,
      const multimap<_K1, _T1, _C1, _A1>&);






  };



  template<typename _InputIterator,
    typename _Compare = less<__iter_key_t<_InputIterator>>,
    typename _Allocator = allocator<__iter_to_alloc_t<_InputIterator>>,
    typename = _RequireInputIter<_InputIterator>,
    typename = _RequireNotAllocator<_Compare>,
    typename = _RequireAllocator<_Allocator>>
    multimap(_InputIterator, _InputIterator,
      _Compare = _Compare(), _Allocator = _Allocator())
    -> multimap<__iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>,
  _Compare, _Allocator>;

  template<typename _Key, typename _Tp, typename _Compare = less<_Key>,
    typename _Allocator = allocator<pair<const _Key, _Tp>>,
    typename = _RequireNotAllocator<_Compare>,
    typename = _RequireAllocator<_Allocator>>
    multimap(initializer_list<pair<_Key, _Tp>>,
      _Compare = _Compare(), _Allocator = _Allocator())
    -> multimap<_Key, _Tp, _Compare, _Allocator>;

  template<typename _InputIterator, typename _Allocator,
    typename = _RequireInputIter<_InputIterator>,
    typename = _RequireAllocator<_Allocator>>
    multimap(_InputIterator, _InputIterator, _Allocator)
    -> multimap<__iter_key_t<_InputIterator>, __iter_val_t<_InputIterator>,
  less<__iter_key_t<_InputIterator>>, _Allocator>;

  template<typename _Key, typename _Tp, typename _Allocator,
    typename = _RequireAllocator<_Allocator>>
    multimap(initializer_list<pair<_Key, _Tp>>, _Allocator)
    -> multimap<_Key, _Tp, less<_Key>, _Allocator>;
# 1132 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multimap.h" 3
  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    inline bool
    operator==(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
        const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
    { return __x._M_t == __y._M_t; }
# 1153 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multimap.h" 3
  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    inline __detail::__synth3way_t<pair<const _Key, _Tp>>
    operator<=>(const multimap<_Key, _Tp, _Compare, _Alloc>& __x,
  const multimap<_Key, _Tp, _Compare, _Alloc>& __y)
    { return __x._M_t <=> __y._M_t; }
# 1206 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_multimap.h" 3
  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc>
    inline void
    swap(multimap<_Key, _Tp, _Compare, _Alloc>& __x,
  multimap<_Key, _Tp, _Compare, _Alloc>& __y)
    noexcept(noexcept(__x.swap(__y)))
    { __x.swap(__y); }





  template<typename _Key, typename _Val, typename _Cmp1, typename _Alloc,
    typename _Cmp2>
    struct
    _Rb_tree_merge_helper<std::multimap<_Key, _Val, _Cmp1, _Alloc>,
     _Cmp2>
    {
    private:
      friend class std::multimap<_Key, _Val, _Cmp1, _Alloc>;

      static auto&
      _S_get_tree(std::map<_Key, _Val, _Cmp2, _Alloc>& __map)
      { return __map._M_t; }

      static auto&
      _S_get_tree(std::multimap<_Key, _Val, _Cmp2, _Alloc>& __map)
      { return __map._M_t; }
    };



}
# 65 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/map" 2 3
# 78 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/map" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 79 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/map" 2 3



namespace std __attribute__ ((__visibility__ ("default")))
{

  namespace pmr
  {
    template<typename _Key, typename _Tp, typename _Cmp = std::less<_Key>>
      using map
 = std::map<_Key, _Tp, _Cmp,
     polymorphic_allocator<pair<const _Key, _Tp>>>;
    template<typename _Key, typename _Tp, typename _Cmp = std::less<_Key>>
      using multimap
 = std::multimap<_Key, _Tp, _Cmp,
   polymorphic_allocator<pair<const _Key, _Tp>>>;
  }

}



namespace std __attribute__ ((__visibility__ ("default")))
{

  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc,
    typename _Predicate>
    inline typename map<_Key, _Tp, _Compare, _Alloc>::size_type
    erase_if(map<_Key, _Tp, _Compare, _Alloc>& __cont, _Predicate __pred)
    {
      std::map<_Key, _Tp, _Compare, _Alloc>& __ucont = __cont;
      return __detail::__erase_nodes_if(__cont, __ucont, __pred);
    }

  template<typename _Key, typename _Tp, typename _Compare, typename _Alloc,
    typename _Predicate>
    inline typename multimap<_Key, _Tp, _Compare, _Alloc>::size_type
    erase_if(multimap<_Key, _Tp, _Compare, _Alloc>& __cont, _Predicate __pred)
    {
      std::multimap<_Key, _Tp, _Compare, _Alloc>& __ucont = __cont;
      return __detail::__erase_nodes_if(__cont, __ucont, __pred);
    }

}
# 26 "/usr/include/boost/thread/pthread/thread_data.hpp" 2 3 4
# 38 "/usr/include/boost/thread/pthread/thread_data.hpp" 3 4
# 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
# 39 "/usr/include/boost/thread/pthread/thread_data.hpp" 2 3 4

namespace boost
{
    class thread_attributes {
    public:
        thread_attributes() noexcept {
            int res = pthread_attr_init(&val_);
            (static_cast <bool> (!res && "pthread_attr_init failed") ? void (0) : __assert_fail ("!res && \"pthread_attr_init failed\"", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        }
        ~thread_attributes() {
          int res = pthread_attr_destroy(&val_);
          (static_cast <bool> (!res && "pthread_attr_destroy failed") ? void (0) : __assert_fail ("!res && \"pthread_attr_destroy failed\"", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        }

        void set_stack_size(std::size_t size) noexcept {
          if (size==0) return;



          std::size_t page_size = ::sysconf( _SC_PAGESIZE);


          if (size<static_cast<std::size_t>(__sysconf (75))) size=__sysconf (75);

          size = ((size+page_size-1)/page_size)*page_size;
          int res = pthread_attr_setstacksize(&val_, size);
          (static_cast <bool> (!res && "pthread_attr_setstacksize failed") ? void (0) : __assert_fail ("!res && \"pthread_attr_setstacksize failed\"", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        }

        std::size_t get_stack_size() const noexcept {
            std::size_t size;
            int res = pthread_attr_getstacksize(&val_, &size);
            (static_cast <bool> (!res && "pthread_attr_getstacksize failed") ? void (0) : __assert_fail ("!res && \"pthread_attr_getstacksize failed\"", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
            return size;
        }


        typedef pthread_attr_t native_handle_type;
        native_handle_type* native_handle() noexcept {
          return &val_;
        }
        const native_handle_type* native_handle() const noexcept {
          return &val_;
        }

    private:
        pthread_attr_t val_;
    };

    class thread;

    namespace detail
    {
        struct shared_state_base;
        struct tss_cleanup_function;
        struct thread_exit_callback_node;
        struct tss_data_node
        {
            typedef void(*cleanup_func_t)(void*);
            typedef void(*cleanup_caller_t)(cleanup_func_t, void*);

            cleanup_caller_t caller;
            cleanup_func_t func;
            void* value;

            tss_data_node(cleanup_caller_t caller_,cleanup_func_t func_,void* value_):
                caller(caller_),func(func_),value(value_)
            {}
        };

        struct thread_data_base;
        typedef boost::shared_ptr<thread_data_base> thread_data_ptr;

        struct __attribute__((__visibility__("default"))) thread_data_base:
            enable_shared_from_this<thread_data_base>
        {
            thread_data_ptr self;
            pthread_t thread_handle;
            boost::mutex data_mutex;
            boost::condition_variable done_condition;
            bool done;
            bool join_started;
            bool joined;
            boost::detail::thread_exit_callback_node* thread_exit_callbacks;
            std::map<void const*,boost::detail::tss_data_node> tss_data;





            pthread_mutex_t* cond_mutex;
            pthread_cond_t* current_cond;

            typedef std::vector<std::pair<condition_variable*, mutex*>

            > notify_list_t;
            notify_list_t notify;


            typedef std::vector<shared_ptr<shared_state_base> > async_states_t;
            async_states_t async_states_;





            bool interrupt_enabled;
            bool interrupt_requested;

            thread_data_base():
                thread_handle(0),
                done(false),join_started(false),joined(false),
                thread_exit_callbacks(0),

                cond_mutex(0),
                current_cond(0),

                notify()

                , async_states_()


                , interrupt_enabled(true)
                , interrupt_requested(false)

            {}
            virtual ~thread_data_base();

            typedef pthread_t native_handle_type;

            virtual void run()=0;
            virtual void notify_all_at_thread_exit(condition_variable* cv, mutex* m)
            {
              notify.push_back(std::pair<condition_variable*, mutex*>(cv, m));
            }


            void make_ready_at_thread_exit(shared_ptr<shared_state_base> as)
            {
              async_states_.push_back(as);
            }

        };

        __attribute__((__visibility__("default"))) thread_data_base* get_current_thread_data();


        class interruption_checker
        {
            thread_data_base* const thread_info;
            pthread_mutex_t* m;
            bool set;
            bool done;

            void check_for_interruption()
            {

                if(thread_info->interrupt_requested)
                {
                    thread_info->interrupt_requested=false;
                    throw thread_interrupted();
                }

            }

            void operator=(interruption_checker&);
        public:
            explicit interruption_checker(pthread_mutex_t* cond_mutex,pthread_cond_t* cond):
                thread_info(detail::get_current_thread_data()),m(cond_mutex),
                set(thread_info && thread_info->interrupt_enabled), done(false)
            {
                if(set)
                {
                    lock_guard<mutex> guard(thread_info->data_mutex);
                    check_for_interruption();
                    thread_info->cond_mutex=cond_mutex;
                    thread_info->current_cond=cond;
                    (static_cast <bool> (!posix::pthread_mutex_lock(m)) ? void (0) : __assert_fail ("!posix::pthread_mutex_lock(m)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
                }
                else
                {
                    (static_cast <bool> (!posix::pthread_mutex_lock(m)) ? void (0) : __assert_fail ("!posix::pthread_mutex_lock(m)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
                }
            }
            void unlock_if_locked()
            {
              if ( ! done) {
                if (set)
                {
                    (static_cast <bool> (!posix::pthread_mutex_unlock(m)) ? void (0) : __assert_fail ("!posix::pthread_mutex_unlock(m)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
                    lock_guard<mutex> guard(thread_info->data_mutex);
                    thread_info->cond_mutex=__null;
                    thread_info->current_cond=__null;
                }
                else
                {
                    (static_cast <bool> (!posix::pthread_mutex_unlock(m)) ? void (0) : __assert_fail ("!posix::pthread_mutex_unlock(m)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
                }
                done = true;
              }
            }

            ~interruption_checker() noexcept((false))
            {
                unlock_if_locked();
            }
        };

    }

    namespace this_thread
    {
        void __attribute__((__visibility__("default"))) yield() noexcept;

        namespace hidden
        {
          inline bool always_false()
          {
            return false;
          }
        }






        inline void sleep(system_time const& abs_time)
        {
          mutex mx;
          unique_lock<mutex> lock(mx);
          condition_variable cond;
          cond.timed_wait(lock, abs_time, hidden::always_false);
        }

        template<typename TimeDuration>
        void sleep(TimeDuration const& rel_time)
        {
          mutex mx;
          unique_lock<mutex> lock(mx);
          condition_variable cond;
          cond.timed_wait(lock, rel_time, hidden::always_false);
        }



        template <class Clock, class Duration>
        void sleep_until(const chrono::time_point<Clock, Duration>& t)
        {
          mutex mut;
          unique_lock<mutex> lk(mut);
          condition_variable cv;
          cv.wait_until(lk, t, hidden::always_false);
        }

        template <class Rep, class Period>
        void sleep_for(const chrono::duration<Rep, Period>& d)
        {
          mutex mut;
          unique_lock<mutex> lk(mut);
          condition_variable cv;
          cv.wait_for(lk, d, hidden::always_false);
        }


        namespace no_interruption_point
        {




          namespace hidden
          {
            void __attribute__((__visibility__("default"))) sleep_for_internal(const detail::platform_duration& ts);
          }






          inline void sleep(system_time const& abs_time)
          {
            const detail::real_platform_timepoint ts(abs_time);
            detail::platform_duration d(ts - detail::real_platform_clock::now());
            while (d > detail::platform_duration::zero())
            {
              d = (std::min)(d, detail::platform_milliseconds(100));
              hidden::sleep_for_internal(d);
              d = ts - detail::real_platform_clock::now();
            }
          }

          template<typename TimeDuration>
          void sleep(TimeDuration const& rel_time)
          {
            hidden::sleep_for_internal(detail::platform_duration(rel_time));
          }



          template <class Rep, class Period>
          void sleep_for(const chrono::duration<Rep, Period>& d)
          {
            hidden::sleep_for_internal(detail::platform_duration(d));
          }

          template <class Duration>
          void sleep_until(const chrono::time_point<chrono::steady_clock, Duration>& t)
          {
            sleep_for(t - chrono::steady_clock::now());
          }

          template <class Clock, class Duration>
          void sleep_until(const chrono::time_point<Clock, Duration>& t)
          {
            typedef typename common_type<Duration, typename Clock::duration>::type common_duration;
            common_duration d(t - Clock::now());
            while (d > common_duration::zero())
            {
              d = (std::min)(d, common_duration(chrono::milliseconds(100)));
              hidden::sleep_for_internal(detail::platform_duration(d));
              d = t - Clock::now();
            }
          }
# 402 "/usr/include/boost/thread/pthread/thread_data.hpp" 3 4
        }
    }
}

# 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
# 407 "/usr/include/boost/thread/pthread/thread_data.hpp" 2 3 4
# 16 "/usr/include/boost/thread/pthread/condition_variable.hpp" 2 3 4
# 26 "/usr/include/boost/thread/pthread/condition_variable.hpp" 3 4
# 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
# 27 "/usr/include/boost/thread/pthread/condition_variable.hpp" 2 3 4

namespace boost
{
    namespace thread_cv_detail
    {
        template<typename MutexType>
        struct lock_on_exit
        {
            MutexType* m;

            lock_on_exit():
                m(0)
            {}

            void activate(MutexType& m_)
            {
                m_.unlock();
                m=&m_;
            }
            void deactivate()
            {
                if (m)
                {
                    m->lock();
                }
                m = 0;
            }
            ~lock_on_exit() noexcept((false))
            {
                if (m)
                {
                    m->lock();
                }
           }
        };
    }

    inline void condition_variable::wait(unique_lock<mutex>& m)
    {






        int res=0;
        {

            thread_cv_detail::lock_on_exit<unique_lock<mutex> > guard;
            detail::interruption_checker check_for_interruption(&internal_mutex,&cond);
            pthread_mutex_t* the_mutex = &internal_mutex;
            guard.activate(m);
            res = posix::pthread_cond_wait(&cond,the_mutex);
            check_for_interruption.unlock_if_locked();
            guard.deactivate();




        }

        this_thread::interruption_point();

        if(res)
        {
            boost::throw_exception(condition_error(res, "boost::condition_variable::wait failed in pthread_cond_wait"));
        }
    }
# 105 "/usr/include/boost/thread/pthread/condition_variable.hpp" 3 4
    inline bool condition_variable::do_wait_until(
                unique_lock<mutex>& m,
                detail::internal_platform_timepoint const &timeout)
    {






        int cond_res;
        {

            thread_cv_detail::lock_on_exit<unique_lock<mutex> > guard;
            detail::interruption_checker check_for_interruption(&internal_mutex,&cond);
            pthread_mutex_t* the_mutex = &internal_mutex;
            guard.activate(m);
            cond_res=posix::pthread_cond_timedwait(&cond,the_mutex,&timeout.getTs());
            check_for_interruption.unlock_if_locked();
            guard.deactivate();




        }

        this_thread::interruption_point();

        if(cond_res==110)
        {
            return false;
        }
        if(cond_res)
        {
            boost::throw_exception(condition_error(cond_res, "boost::condition_variable::do_wait_until failed in pthread_cond_timedwait"));
        }
        return true;
    }

    inline void condition_variable::notify_one() noexcept
    {

        boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);

        (static_cast <bool> (!posix::pthread_cond_signal(&cond)) ? void (0) : __assert_fail ("!posix::pthread_cond_signal(&cond)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
    }

    inline void condition_variable::notify_all() noexcept
    {

        boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);

        (static_cast <bool> (!posix::pthread_cond_broadcast(&cond)) ? void (0) : __assert_fail ("!posix::pthread_cond_broadcast(&cond)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
    }

    class condition_variable_any
    {
        pthread_mutex_t internal_mutex;
        pthread_cond_t cond;

    public:
        condition_variable_any(condition_variable_any const&) = delete; condition_variable_any& operator=(condition_variable_any const&) = delete;
        condition_variable_any()
        {
            int const res=posix::pthread_mutex_init(&internal_mutex);
            if(res)
            {
                boost::throw_exception(thread_resource_error(res, "boost::condition_variable_any::condition_variable_any() failed in pthread_mutex_init"));
            }
            int const res2 = posix::pthread_cond_init(&cond);
            if(res2)
            {
                (static_cast <bool> (!posix::pthread_mutex_destroy(&internal_mutex)) ? void (0) : __assert_fail ("!posix::pthread_mutex_destroy(&internal_mutex)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
                boost::throw_exception(thread_resource_error(res2, "boost::condition_variable_any::condition_variable_any() failed in pthread_cond_init"));
            }
        }
        ~condition_variable_any()
        {
            (static_cast <bool> (!posix::pthread_mutex_destroy(&internal_mutex)) ? void (0) : __assert_fail ("!posix::pthread_mutex_destroy(&internal_mutex)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
            (static_cast <bool> (!posix::pthread_cond_destroy(&cond)) ? void (0) : __assert_fail ("!posix::pthread_cond_destroy(&cond)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        }

        template<typename lock_type>
        void wait(lock_type& m)
        {
            int res=0;
            {
                thread_cv_detail::lock_on_exit<lock_type> guard;

                detail::interruption_checker check_for_interruption(&internal_mutex,&cond);



                guard.activate(m);
                res=posix::pthread_cond_wait(&cond,&internal_mutex);
                check_for_interruption.unlock_if_locked();
                guard.deactivate();
            }

            this_thread::interruption_point();

            if(res)
            {
                boost::throw_exception(condition_error(res, "boost::condition_variable_any::wait() failed in pthread_cond_wait"));
            }
        }

        template<typename lock_type,typename predicate_type>
        void wait(lock_type& m,predicate_type pred)
        {
            while (!pred())
            {
                wait(m);
            }
        }


        template<typename lock_type>
        bool timed_wait(lock_type& m,boost::system_time const& abs_time)
        {



            const detail::real_platform_timepoint ts(abs_time);
# 238 "/usr/include/boost/thread/pthread/condition_variable.hpp" 3 4
            const detail::platform_duration d(ts - detail::real_platform_clock::now());
            do_wait_until(m, detail::internal_platform_clock::now() + d);
            return ts > detail::real_platform_clock::now();



        }
        template<typename lock_type>
        bool timed_wait(lock_type& m,::boost::xtime const& abs_time)
        {
            return timed_wait(m,system_time(abs_time));
        }

        template<typename lock_type,typename duration_type>
        bool timed_wait(lock_type& m,duration_type const& wait_duration)
        {
            if (wait_duration.is_pos_infinity())
            {
                wait(m);
                return true;
            }
            if (wait_duration.is_special())
            {
                return true;
            }
            detail::platform_duration d(wait_duration);
# 276 "/usr/include/boost/thread/pthread/condition_variable.hpp" 3 4
            return do_wait_until(m, detail::internal_platform_clock::now() + d);

        }

        template<typename lock_type,typename predicate_type>
        bool timed_wait(lock_type& m,boost::system_time const& abs_time, predicate_type pred)
        {



            const detail::real_platform_timepoint ts(abs_time);

            while (!pred())
            {




                detail::platform_duration d(ts - detail::real_platform_clock::now());
                if (d <= detail::platform_duration::zero()) break;
                d = (std::min)(d, detail::platform_milliseconds(100));
                do_wait_until(m, detail::internal_platform_clock::now() + d);



            }
            return pred();
        }

        template<typename lock_type,typename predicate_type>
        bool timed_wait(lock_type& m,::boost::xtime const& abs_time, predicate_type pred)
        {
            return timed_wait(m,system_time(abs_time),pred);
        }

        template<typename lock_type,typename duration_type,typename predicate_type>
        bool timed_wait(lock_type& m,duration_type const& wait_duration,predicate_type pred)
        {
            if (wait_duration.is_pos_infinity())
            {
                while (!pred())
                {
                    wait(m);
                }
                return true;
            }
            if (wait_duration.is_special())
            {
                return pred();
            }
            detail::platform_duration d(wait_duration);
# 340 "/usr/include/boost/thread/pthread/condition_variable.hpp" 3 4
            const detail::internal_platform_timepoint ts(detail::internal_platform_clock::now() + d);
            while (!pred())
            {
                if (!do_wait_until(m, ts)) break;
            }

            return pred();
        }



        template <class lock_type,class Duration>
        cv_status
        wait_until(
                lock_type& lock,
                const chrono::time_point<detail::internal_chrono_clock, Duration>& t)
        {
            const boost::detail::internal_platform_timepoint ts(t);
            if (do_wait_until(lock, ts)) return cv_status::no_timeout;
            else return cv_status::timeout;
        }

        template <class lock_type, class Clock, class Duration>
        cv_status
        wait_until(
                lock_type& lock,
                const chrono::time_point<Clock, Duration>& t)
        {







            typedef typename common_type<Duration, typename Clock::duration>::type common_duration;
            common_duration d(t - Clock::now());
            do_wait_until(lock, detail::internal_chrono_clock::now() + d);
            if (t > Clock::now()) return cv_status::no_timeout;
            else return cv_status::timeout;
        }

        template <class lock_type, class Rep, class Period>
        cv_status
        wait_for(
                lock_type& lock,
                const chrono::duration<Rep, Period>& d)
        {
            return wait_until(lock, chrono::steady_clock::now() + d);
        }

        template <class lock_type, class Duration, class Predicate>
        bool
        wait_until(
                lock_type& lock,
                const chrono::time_point<detail::internal_chrono_clock, Duration>& t,
                Predicate pred)
        {
            const detail::internal_platform_timepoint ts(t);
            while (!pred())
            {
                if (!do_wait_until(lock, ts)) break;
            }
            return pred();
        }

        template <class lock_type, class Clock, class Duration, class Predicate>
        bool
        wait_until(
                lock_type& lock,
                const chrono::time_point<Clock, Duration>& t,
                Predicate pred)
        {



            typedef typename common_type<Duration, typename Clock::duration>::type common_duration;
            while (!pred())
            {
                common_duration d(t - Clock::now());
                if (d <= common_duration::zero()) break;
                d = (std::min)(d, common_duration(chrono::milliseconds(100)));
                do_wait_until(lock, detail::internal_platform_clock::now() + detail::platform_duration(d));
            }
            return pred();
        }

        template <class lock_type, class Rep, class Period, class Predicate>
        bool
        wait_for(
                lock_type& lock,
                const chrono::duration<Rep, Period>& d,
                Predicate pred)
        {
            return wait_until(lock, chrono::steady_clock::now() + d, boost::move(pred));
        }


        void notify_one() noexcept
        {
            boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);
            (static_cast <bool> (!posix::pthread_cond_signal(&cond)) ? void (0) : __assert_fail ("!posix::pthread_cond_signal(&cond)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        }

        void notify_all() noexcept
        {
            boost::pthread::pthread_mutex_scoped_lock internal_lock(&internal_mutex);
            (static_cast <bool> (!posix::pthread_cond_broadcast(&cond)) ? void (0) : __assert_fail ("!posix::pthread_cond_broadcast(&cond)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        }
    private:
# 460 "/usr/include/boost/thread/pthread/condition_variable.hpp" 3 4
        template <class lock_type>
        bool do_wait_until(
          lock_type& m,
          detail::internal_platform_timepoint const &timeout)
        {
          int res=0;
          {
              thread_cv_detail::lock_on_exit<lock_type> guard;

              detail::interruption_checker check_for_interruption(&internal_mutex,&cond);



              guard.activate(m);
              res=posix::pthread_cond_timedwait(&cond,&internal_mutex,&timeout.getTs());
              check_for_interruption.unlock_if_locked();
              guard.deactivate();
          }

          this_thread::interruption_point();

          if(res==110)
          {
              return false;
          }
          if(res)
          {
              boost::throw_exception(condition_error(res, "boost::condition_variable_any::do_wait_until() failed in pthread_cond_timedwait"));
          }
          return true;
        }
    };
}

# 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
# 495 "/usr/include/boost/thread/pthread/condition_variable.hpp" 2 3 4
# 17 "/usr/include/boost/thread/condition_variable.hpp" 2 3 4
# 19 "/usr/include/boost/thread/barrier.hpp" 2 3 4


# 1 "/usr/include/boost/thread/detail/nullary_function.hpp" 1 3 4
# 14 "/usr/include/boost/thread/detail/nullary_function.hpp" 3 4
# 1 "/usr/include/boost/thread/detail/memory.hpp" 1 3 4
# 17 "/usr/include/boost/thread/detail/memory.hpp" 3 4
# 1 "/usr/include/boost/thread/csbl/memory/pointer_traits.hpp" 1 3 4
# 12 "/usr/include/boost/thread/csbl/memory/pointer_traits.hpp" 3 4
# 1 "/usr/include/boost/thread/csbl/memory/config.hpp" 1 3 4
# 13 "/usr/include/boost/thread/csbl/memory/pointer_traits.hpp" 2 3 4
# 26 "/usr/include/boost/thread/csbl/memory/pointer_traits.hpp" 3 4
namespace boost
{
  namespace csbl
  {
    using ::std::pointer_traits;
  }
}
# 18 "/usr/include/boost/thread/detail/memory.hpp" 2 3 4
# 1 "/usr/include/boost/thread/csbl/memory/allocator_arg.hpp" 1 3 4
# 27 "/usr/include/boost/thread/csbl/memory/allocator_arg.hpp" 3 4
namespace boost
{
  namespace csbl
  {
    using ::std::allocator_arg_t;
    using ::std::allocator_arg;
  }
}

namespace boost
{
  using ::boost::csbl::allocator_arg_t;
  using ::boost::csbl::allocator_arg;
}
# 19 "/usr/include/boost/thread/detail/memory.hpp" 2 3 4
# 1 "/usr/include/boost/thread/csbl/memory/allocator_traits.hpp" 1 3 4
# 26 "/usr/include/boost/thread/csbl/memory/allocator_traits.hpp" 3 4
namespace boost
{
  namespace csbl
  {
    using ::std::allocator_traits;
  }
}
# 20 "/usr/include/boost/thread/detail/memory.hpp" 2 3 4
# 1 "/usr/include/boost/thread/csbl/memory/scoped_allocator.hpp" 1 3 4
# 26 "/usr/include/boost/thread/csbl/memory/scoped_allocator.hpp" 3 4
namespace boost
{
  namespace csbl
  {
    using ::std::uses_allocator;
  }
}
# 21 "/usr/include/boost/thread/detail/memory.hpp" 2 3 4

namespace boost
{
  namespace thread_detail
  {
    template <class _Alloc>
    class allocator_destructor
    {
      typedef csbl::allocator_traits<_Alloc> alloc_traits;
    public:
      typedef typename alloc_traits::pointer pointer;
      typedef typename alloc_traits::size_type size_type;
    private:
      _Alloc alloc_;
      size_type s_;
    public:
      allocator_destructor(_Alloc& a, size_type s)noexcept
      : alloc_(a), s_(s)
      {}
      void operator()(pointer p)noexcept
      {
        alloc_traits::destroy(alloc_, p);
        alloc_traits::deallocate(alloc_, p, s_);
      }
    };
  }
}
# 15 "/usr/include/boost/thread/detail/nullary_function.hpp" 2 3 4

# 1 "/usr/include/boost/thread/csbl/memory/shared_ptr.hpp" 1 3 4
# 32 "/usr/include/boost/thread/csbl/memory/shared_ptr.hpp" 3 4
namespace boost
{
  namespace csbl
  {
    using std::shared_ptr;
    using std::make_shared;
  }
}
# 17 "/usr/include/boost/thread/detail/nullary_function.hpp" 2 3 4



namespace boost
{
  namespace detail
  {

    template <typename F>
    class nullary_function;
    template <>
    class nullary_function<void()>
    {
      struct impl_base
      {
        virtual void call()=0;
        virtual ~impl_base()
        {
        }
      };
      csbl::shared_ptr<impl_base> impl;
      template <typename F>
      struct impl_type: impl_base
      {
        F f;





        impl_type(F && f_)
          : f(boost::move(f_))
        {}

        void call()
        {
          f();
        }
      };
      struct impl_type_ptr: impl_base
      {
        void (*f)();
        impl_type_ptr(void (*f_)())
          : f(f_)
        {}
        void call()
        {
          f();
        }
      };
    public:


      explicit nullary_function(void (*f)()):
      impl(new impl_type_ptr(f))
      {}
# 82 "/usr/include/boost/thread/detail/nullary_function.hpp" 3 4
      template<typename F>
      nullary_function(F && f
                       , typename disable_if<is_same<typename decay<F>::type, nullary_function>, int* >::type=0
                       ):
      impl(new impl_type<typename decay<F>::type>(thread_detail::decay_copy(boost::forward<F>(f))))
      {}

      nullary_function()
        : impl()
      {
      }
      nullary_function(nullary_function const& other) noexcept :
      impl(other.impl)
      {
      }
      nullary_function(nullary_function && other) noexcept :






      impl(boost::move(other.impl))
      {
      }

      ~nullary_function()
      {
      }

      nullary_function& operator=(const nullary_function & other) noexcept
      {
        impl=other.impl;
        return *this;
      }
      nullary_function& operator=(nullary_function && other) noexcept
      {




        impl = boost::move(other.impl);

        return *this;
      }


      void operator()()
      { if (impl) impl->call();}

    };

    template <typename R>
    class nullary_function<R()>
    {
      struct impl_base
      {
        virtual R call()=0;
        virtual ~impl_base()
        {
        }
      };
      csbl::shared_ptr<impl_base> impl;
      template <typename F>
      struct impl_type: impl_base
      {
        F f;





        impl_type(F && f_)
          : f(boost::move(f_))
        {}

        R call()
        {
          return f();
        }
      };
      struct impl_type_ptr: impl_base
      {
        R (*f)();
        impl_type_ptr(R (*f_)())
          : f(f_)
        {}

        R call()
        {
          return f();
        }
      };
    public:


      nullary_function(R (*f)()):
      impl(new impl_type_ptr(f))
      {}






      template<typename F>
      nullary_function(F && f):
      impl(new impl_type<typename decay<F>::type>(thread_detail::decay_copy(boost::forward<F>(f))))
      {}

      nullary_function(nullary_function const& other) noexcept :
      impl(other.impl)
      {
      }
      nullary_function(nullary_function && other) noexcept :






      impl(boost::move(other.impl))
      {
      }

      nullary_function()
        : impl()
      {
      }
      ~nullary_function()
      {
      }

      nullary_function& operator=(const nullary_function & other) noexcept
      {
        impl=other.impl;
        return *this;
      }
      nullary_function& operator=(nullary_function && other) noexcept
      {




        impl = boost::move(other.impl);

        return *this;
      }

      R operator()()
      { if (impl) return impl->call(); else return R();}

    };
  }
  namespace detail { template <typename F> struct enable_move_utility_emulation_dummy_specialization< detail::nullary_function<F> > : integral_constant<bool, false> {}; }
}
# 22 "/usr/include/boost/thread/barrier.hpp" 2 3 4





# 1 "/usr/include/boost/config/abi_prefix.hpp" 1 3 4
# 28 "/usr/include/boost/thread/barrier.hpp" 2 3 4

namespace boost
{
  namespace thread_detail
  {
    typedef detail::nullary_function<void()> void_completion_function;
    typedef detail::nullary_function<size_t()> size_completion_function;

    struct default_barrier_reseter
    {
      unsigned int size_;
      default_barrier_reseter(unsigned int size) :
        size_(size)
      {
      }



      default_barrier_reseter(default_barrier_reseter const& other) noexcept :
      size_(other.size_)
      {
      }
      default_barrier_reseter(default_barrier_reseter && other) noexcept :
      size_(other.size_)
      {
      }

      unsigned int operator()()
      {
        return size_;
      }
    };

    struct void_functor_barrier_reseter
    {
      unsigned int size_;
      void_completion_function fct_;
      template <typename F>
      void_functor_barrier_reseter(unsigned int size, F && funct)
      : size_(size), fct_(boost::move(funct))
      {}
      template <typename F>
      void_functor_barrier_reseter(unsigned int size, F& funct)
      : size_(size), fct_(funct)
      {}




      void_functor_barrier_reseter(void_functor_barrier_reseter const& other) noexcept :
      size_(other.size_), fct_(other.fct_)
      {
      }
      void_functor_barrier_reseter(void_functor_barrier_reseter && other) noexcept :
      size_(other.size_), fct_(other.fct_)

      {
      }

      unsigned int operator()()
      {
        fct_();
        return size_;
      }
    };
    struct void_fct_ptr_barrier_reseter
    {
      unsigned int size_;
      void(*fct_)();
      void_fct_ptr_barrier_reseter(unsigned int size, void(*funct)()) :
        size_(size), fct_(funct)
      {
      }



      void_fct_ptr_barrier_reseter(void_fct_ptr_barrier_reseter const& other) noexcept :
      size_(other.size_), fct_(other.fct_)
      {
      }
      void_fct_ptr_barrier_reseter(void_fct_ptr_barrier_reseter && other) noexcept :
      size_(other.size_), fct_(other.fct_)
      {
      }
      unsigned int operator()()
      {
        fct_();
        return size_;
      }
    };
  }




  class barrier
  {
    static inline unsigned int check_counter(unsigned int count)
    {
      if (count == 0) boost::throw_exception(
          thread_exception(system::errc::invalid_argument, "barrier constructor: count cannot be zero."));
      return count;
    }
    struct dummy
    {
    };

  public:
    barrier(barrier const&) = delete; barrier& operator=(barrier const&) = delete;

    explicit barrier(unsigned int count) :
      m_count(check_counter(count)), m_generation(0), fct_(thread_detail::default_barrier_reseter(count))
    {
    }

    template <typename F>
    barrier(
        unsigned int count,
        F && funct,
        typename enable_if<
        typename is_void<typename result_of<F()>::type>::type, dummy*
        >::type=0
    )
    : m_count(check_counter(count)),
      m_generation(0),
      fct_(thread_detail::void_functor_barrier_reseter(count, boost::move(funct))

    )
    {
    }
    template <typename F>
    barrier(
        unsigned int count,
        F &funct,
        typename enable_if<
        typename is_void<typename result_of<F()>::type>::type, dummy*
        >::type=0
    )
    : m_count(check_counter(count)),
      m_generation(0),
      fct_(thread_detail::void_functor_barrier_reseter(count, funct)

    )
    {
    }

    template <typename F>
    barrier(
        unsigned int count,
        F && funct,
        typename enable_if<
        typename is_same<typename result_of<F()>::type, unsigned int>::type, dummy*
        >::type=0
    )
    : m_count(check_counter(count)),
      m_generation(0),
      fct_(boost::move(funct))
    {
    }
    template <typename F>
    barrier(
        unsigned int count,
        F& funct,
        typename enable_if<
        typename is_same<typename result_of<F()>::type, unsigned int>::type, dummy*
        >::type=0
    )
    : m_count(check_counter(count)),
      m_generation(0),
      fct_(funct)
    {
    }

    barrier(unsigned int count, void(*funct)()) :
      m_count(check_counter(count)), m_generation(0),
      fct_(funct
          ? thread_detail::size_completion_function(thread_detail::void_fct_ptr_barrier_reseter(count, funct))
          : thread_detail::size_completion_function(thread_detail::default_barrier_reseter(count))
      )
    {
    }
    barrier(unsigned int count, unsigned int(*funct)()) :
      m_count(check_counter(count)), m_generation(0),
      fct_(funct
          ? thread_detail::size_completion_function(funct)
          : thread_detail::size_completion_function(thread_detail::default_barrier_reseter(count))
      )
    {
    }

    bool wait()
    {
      boost::unique_lock < boost::mutex > lock(m_mutex);
      unsigned int gen = m_generation;

      if (--m_count == 0)
      {
        m_generation++;
        m_count = static_cast<unsigned int>(fct_());
        (static_cast <bool> (m_count != 0) ? void (0) : __assert_fail ("m_count != 0", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        lock.unlock();
        m_cond.notify_all();
        return true;
      }

      while (gen == m_generation)
        m_cond.wait(lock);
      return false;
    }

    void count_down_and_wait()
    {
      wait();
    }

  private:
    mutex m_mutex;
    condition_variable m_cond;
    unsigned int m_count;
    unsigned int m_generation;
    thread_detail::size_completion_function fct_;
  };

}

# 1 "/usr/include/boost/config/abi_suffix.hpp" 1 3 4
# 254 "/usr/include/boost/thread/barrier.hpp" 2 3 4
# 37 "/home/avi/scylla-maint/seastar/include/seastar/core/smp.hh" 2
# 1 "/usr/include/boost/range/irange.hpp" 1 3 4
# 14 "/usr/include/boost/range/irange.hpp" 3 4
# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 58 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 59 "/usr/include/boost/assert.hpp" 2 3 4
# 15 "/usr/include/boost/range/irange.hpp" 2 3 4

# 1 "/usr/include/boost/range/iterator_range.hpp" 1 3 4
# 13 "/usr/include/boost/range/iterator_range.hpp" 3 4
# 1 "/usr/include/boost/range/iterator_range_core.hpp" 1 3 4
# 25 "/usr/include/boost/range/iterator_range_core.hpp" 3 4
# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 58 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 59 "/usr/include/boost/assert.hpp" 2 3 4
# 26 "/usr/include/boost/range/iterator_range_core.hpp" 2 3 4





# 1 "/usr/include/boost/type_traits/is_abstract.hpp" 1 3 4
# 63 "/usr/include/boost/type_traits/is_abstract.hpp" 3 4
namespace boost {

namespace detail{


template <class T>
struct is_abstract_imp
{
   static const bool value = __is_abstract(T);
};
# 140 "/usr/include/boost/type_traits/is_abstract.hpp" 3 4
}


template <class T> struct is_abstract : public integral_constant<bool, ::boost::detail::is_abstract_imp<T>::value> {};




}
# 32 "/usr/include/boost/range/iterator_range_core.hpp" 2 3 4






# 1 "/usr/include/boost/range/functions.hpp" 1 3 4
# 18 "/usr/include/boost/range/functions.hpp" 3 4
# 1 "/usr/include/boost/range/begin.hpp" 1 3 4
# 18 "/usr/include/boost/range/begin.hpp" 3 4
# 1 "/usr/include/boost/range/config.hpp" 1 3 4
# 19 "/usr/include/boost/range/begin.hpp" 2 3 4

# 1 "/usr/include/boost/range/iterator.hpp" 1 3 4
# 19 "/usr/include/boost/range/iterator.hpp" 3 4
# 1 "/usr/include/boost/range/range_fwd.hpp" 1 3 4
# 13 "/usr/include/boost/range/range_fwd.hpp" 3 4
namespace boost
{


    template<typename C, typename Enabler>
    struct range_iterator;

    template<typename C, typename Enabler>
    struct range_mutable_iterator;

    template<typename C, typename Enabler>
    struct range_const_iterator;


    template<typename IteratorT>
    class iterator_range;

    template<typename ForwardRange>
    class sub_range;


    template<typename T>
    struct range_category;

    template<typename T>
    struct range_difference;

    template<typename T>
    struct range_pointer;

    template<typename T>
    struct range_reference;

    template<typename T>
    struct range_reverse_iterator;

    template<typename T>
    struct range_size;

    template<typename T>
    struct range_value;

    template<typename T>
    struct has_range_iterator;

    template<typename T>
    struct has_range_const_iterator;

}
# 20 "/usr/include/boost/range/iterator.hpp" 2 3 4
# 1 "/usr/include/boost/range/mutable_iterator.hpp" 1 3 4
# 21 "/usr/include/boost/range/mutable_iterator.hpp" 3 4
# 1 "/usr/include/boost/range/detail/extract_optional_type.hpp" 1 3 4
# 22 "/usr/include/boost/range/mutable_iterator.hpp" 2 3 4





namespace boost
{





    namespace range_detail
    {

template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_iterator { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<typename U::iterator>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; }; template< typename C, bool B = has_iterator<C>::value > struct extract_iterator {}; template< typename C > struct extract_iterator< C, true > { typedef typename C::iterator type; };

template< typename C >
struct range_mutable_iterator
        : range_detail::extract_iterator<
            typename remove_reference<C>::type>
{};





template< typename Iterator >
struct range_mutable_iterator< std::pair<Iterator,Iterator> >
{
    typedef Iterator type;
};





template< typename T, std::size_t sz >
struct range_mutable_iterator< T[sz] >
{
    typedef T* type;
};

    }

template<typename C, typename Enabler=void>
struct range_mutable_iterator
        : range_detail::range_mutable_iterator<
            typename remove_reference<C>::type
        >
{
};

}

# 1 "/usr/include/boost/range/detail/msvc_has_iterator_workaround.hpp" 1 3 4
# 78 "/usr/include/boost/range/mutable_iterator.hpp" 2 3 4
# 21 "/usr/include/boost/range/iterator.hpp" 2 3 4
# 1 "/usr/include/boost/range/const_iterator.hpp" 1 3 4
# 27 "/usr/include/boost/range/const_iterator.hpp" 3 4
namespace boost
{




    namespace range_detail
    {

template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_const_iterator { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<typename U::const_iterator>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; }; template< typename C, bool B = has_const_iterator<C>::value > struct extract_const_iterator {}; template< typename C > struct extract_const_iterator< C, true > { typedef typename C::const_iterator type; };

template< typename C >
struct range_const_iterator_helper
        : extract_const_iterator<C>
{};





template< typename Iterator >
struct range_const_iterator_helper<std::pair<Iterator,Iterator> >
{
    typedef Iterator type;
};





template< typename T, std::size_t sz >
struct range_const_iterator_helper< T[sz] >
{
    typedef const T* type;
};

    }

template<typename C, typename Enabler=void>
struct range_const_iterator
        : range_detail::range_const_iterator_helper<
            typename remove_reference<C>::type
        >
{
};

}
# 22 "/usr/include/boost/range/iterator.hpp" 2 3 4




namespace boost
{
# 60 "/usr/include/boost/range/iterator.hpp" 3 4
    template< typename C, typename Enabler=void >
    struct range_iterator
      : mpl::if_c<
            is_const<typename remove_reference<C>::type>::value,
            range_const_iterator<typename remove_const<typename remove_reference<C>::type>::type>,
            range_mutable_iterator<typename remove_reference<C>::type>
        >::type
    {
    };



}
# 21 "/usr/include/boost/range/begin.hpp" 2 3 4



namespace boost
{


namespace range_detail
{






    template< typename C >
    constexpr inline typename range_iterator<C>::type
    range_begin( C& c )
    {





        return c.begin();
    }





    template< typename Iterator >
    constexpr inline Iterator range_begin( const std::pair<Iterator,Iterator>& p )
    {
        return p.first;
    }

    template< typename Iterator >
    constexpr inline Iterator range_begin( std::pair<Iterator,Iterator>& p )
    {
        return p.first;
    }
# 71 "/usr/include/boost/range/begin.hpp" 3 4
    template< typename T, std::size_t sz >
    constexpr inline const T* range_begin( const T (&a)[sz] ) noexcept
    {
        return a;
    }

    template< typename T, std::size_t sz >
    constexpr inline T* range_begin( T (&a)[sz] ) noexcept
    {
        return a;
    }



}





namespace range_adl_barrier
{

template< class T >

constexpr

inline typename range_iterator<T>::type begin( T& r )
{

    using namespace range_detail;

    return range_begin( r );
}

template< class T >

constexpr

inline typename range_iterator<const T>::type begin( const T& r )
{

    using namespace range_detail;

    return range_begin( r );
}

    }
}

namespace boost
{
    namespace range_adl_barrier
    {
        template< class T >
        inline typename range_iterator<const T>::type
        const_begin( const T& r )
        {
            return boost::range_adl_barrier::begin( r );
        }
    }

    using namespace range_adl_barrier;
}
# 19 "/usr/include/boost/range/functions.hpp" 2 3 4
# 1 "/usr/include/boost/range/end.hpp" 1 3 4
# 20 "/usr/include/boost/range/end.hpp" 3 4
# 1 "/usr/include/boost/range/detail/implementation_help.hpp" 1 3 4
# 15 "/usr/include/boost/range/detail/implementation_help.hpp" 3 4
# 1 "/usr/include/boost/range/detail/common.hpp" 1 3 4
# 19 "/usr/include/boost/range/detail/common.hpp" 3 4
# 1 "/usr/include/boost/range/detail/sfinae.hpp" 1 3 4
# 20 "/usr/include/boost/range/detail/sfinae.hpp" 3 4
namespace boost
{
    namespace range_detail
    {
        using type_traits::yes_type;
        using type_traits::no_type;





        yes_type is_string_impl( const char* const );
        yes_type is_string_impl( const wchar_t* const );
        no_type is_string_impl( ... );

        template< std::size_t sz >
        yes_type is_char_array_impl( char (&boost_range_array)[sz] );
        template< std::size_t sz >
        yes_type is_char_array_impl( const char (&boost_range_array)[sz] );
        no_type is_char_array_impl( ... );

        template< std::size_t sz >
        yes_type is_wchar_t_array_impl( wchar_t (&boost_range_array)[sz] );
        template< std::size_t sz >
        yes_type is_wchar_t_array_impl( const wchar_t (&boost_range_array)[sz] );
        no_type is_wchar_t_array_impl( ... );

        yes_type is_char_ptr_impl( char* const );
        no_type is_char_ptr_impl( ... );

        yes_type is_const_char_ptr_impl( const char* const );
        no_type is_const_char_ptr_impl( ... );

        yes_type is_wchar_t_ptr_impl( wchar_t* const );
        no_type is_wchar_t_ptr_impl( ... );

        yes_type is_const_wchar_t_ptr_impl( const wchar_t* const );
        no_type is_const_wchar_t_ptr_impl( ... );





        template< typename Iterator >
        yes_type is_pair_impl( const std::pair<Iterator,Iterator>* );
        no_type is_pair_impl( ... );





        struct char_or_wchar_t_array_tag {};

    }

}
# 20 "/usr/include/boost/range/detail/common.hpp" 2 3 4
# 29 "/usr/include/boost/range/detail/common.hpp" 3 4
namespace boost
{
    namespace range_detail
    {
# 46 "/usr/include/boost/range/detail/common.hpp" 3 4
        typedef mpl::int_<1>::type std_container_;
        typedef mpl::int_<2>::type std_pair_;
        typedef mpl::int_<3>::type const_std_pair_;
        typedef mpl::int_<4>::type array_;
        typedef mpl::int_<5>::type const_array_;
        typedef mpl::int_<6>::type char_array_;
        typedef mpl::int_<7>::type wchar_t_array_;
        typedef mpl::int_<8>::type char_ptr_;
        typedef mpl::int_<9>::type const_char_ptr_;
        typedef mpl::int_<10>::type wchar_t_ptr_;
        typedef mpl::int_<11>::type const_wchar_t_ptr_;
        typedef mpl::int_<12>::type string_;

        template< typename C >
        struct range_helper
        {
            static C* c;
            static C ptr;

            static const bool is_pair_ = sizeof( boost::range_detail::is_pair_impl( c ) ) == sizeof( yes_type );
            static const bool is_char_ptr_ = sizeof( boost::range_detail::is_char_ptr_impl( ptr ) ) == sizeof( yes_type );
            static const bool is_const_char_ptr_ = sizeof( boost::range_detail::is_const_char_ptr_impl( ptr ) ) == sizeof( yes_type );
            static const bool is_wchar_t_ptr_ = sizeof( boost::range_detail::is_wchar_t_ptr_impl( ptr ) ) == sizeof( yes_type );
            static const bool is_const_wchar_t_ptr_ = sizeof( boost::range_detail::is_const_wchar_t_ptr_impl( ptr ) ) == sizeof( yes_type );
            static const bool is_char_array_ = sizeof( boost::range_detail::is_char_array_impl( ptr ) ) == sizeof( yes_type );
            static const bool is_wchar_t_array_ = sizeof( boost::range_detail::is_wchar_t_array_impl( ptr ) ) == sizeof( yes_type );
            static const bool is_string_ = (is_const_char_ptr_ || is_const_wchar_t_ptr_);
            static const bool is_array_ = boost::is_array<C>::value;

        };

        template< typename C >
        class range
        {
            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_pair_,
                                                                  boost::range_detail::std_pair_,
                                                                  void >::type pair_t;
            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_array_,
                                                                    boost::range_detail::array_,
                                                                    pair_t >::type array_t;
            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_string_,
                                                                    boost::range_detail::string_,
                                                                    array_t >::type string_t;
            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_const_char_ptr_,
                                                                    boost::range_detail::const_char_ptr_,
                                                                    string_t >::type const_char_ptr_t;
            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_char_ptr_,
                                                                    boost::range_detail::char_ptr_,
                                                                    const_char_ptr_t >::type char_ptr_t;
            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_const_wchar_t_ptr_,
                                                                    boost::range_detail::const_wchar_t_ptr_,
                                                                    char_ptr_t >::type const_wchar_ptr_t;
            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_wchar_t_ptr_,
                                                                    boost::range_detail::wchar_t_ptr_,
                                                                    const_wchar_ptr_t >::type wchar_ptr_t;
            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_wchar_t_array_,
                                                                    boost::range_detail::wchar_t_array_,
                                                                    wchar_ptr_t >::type wchar_array_t;
            typedef typename boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_char_array_,
                                                                    boost::range_detail::char_array_,
                                                                    wchar_array_t >::type char_array_t;
        public:
            typedef typename boost::mpl::if_c< ::boost::is_void<char_array_t>::value,
                                                                    boost::range_detail::std_container_,
                                                                    char_array_t >::type type;
        };
    }
}
# 16 "/usr/include/boost/range/detail/implementation_help.hpp" 2 3 4








namespace boost
{
    namespace range_detail
    {
        template <typename T>
        inline void boost_range_silence_warning( const T& ) { }





        inline const char* str_end( const char* s, const char* )
        {
            return s + strlen( s );
        }


        inline const wchar_t* str_end( const wchar_t* s, const wchar_t* )
        {
            return s + wcslen( s );
        }
# 56 "/usr/include/boost/range/detail/implementation_help.hpp" 3 4
        template< class Char >
        inline Char* str_end( Char* s )
        {
            return const_cast<Char*>( str_end( s, s ) );
        }

        template< class T, std::size_t sz >
        constexpr inline T* array_end( T (&boost_range_array)[sz] ) noexcept
        {
            return boost_range_array + sz;
        }

        template< class T, std::size_t sz >
        constexpr inline const T* array_end( const T (&boost_range_array)[sz] ) noexcept
        {
            return boost_range_array + sz;
        }





        template< class Char >
        inline std::size_t str_size( const Char* const& s )
        {
            return str_end( s ) - s;
        }

        template< class T, std::size_t sz >
        inline std::size_t array_size( T (&boost_range_array)[sz] )
        {
            boost_range_silence_warning( boost_range_array );
            return sz;
        }

        template< class T, std::size_t sz >
        inline std::size_t array_size( const T (&boost_range_array)[sz] )
        {
            boost_range_silence_warning( boost_range_array );
            return sz;
        }

        inline bool is_same_address(const void* l, const void* r)
        {
            return l == r;
        }

        template<class T1, class T2>
        inline bool is_same_object(const T1& l, const T2& r)
        {
            return range_detail::is_same_address(&l, &r);
        }

    }

}
# 21 "/usr/include/boost/range/end.hpp" 2 3 4





namespace boost
{


namespace range_detail
{





        template< typename C >
        constexpr inline typename range_iterator<C>::type
        range_end( C& c )
        {





            return c.end();
        }





        template< typename Iterator >
        constexpr inline Iterator range_end( const std::pair<Iterator,Iterator>& p )
        {
            return p.second;
        }

        template< typename Iterator >
        constexpr inline Iterator range_end( std::pair<Iterator,Iterator>& p )
        {
            return p.second;
        }





        template< typename T, std::size_t sz >
        constexpr inline const T* range_end( const T (&a)[sz] ) noexcept
        {
            return range_detail::array_end<T,sz>( a );
        }

        template< typename T, std::size_t sz >
        constexpr inline T* range_end( T (&a)[sz] ) noexcept
        {
            return range_detail::array_end<T,sz>( a );
        }


}


namespace range_adl_barrier
{

template< class T >

constexpr

inline typename range_iterator<T>::type end( T& r )
{

    using namespace range_detail;

    return range_end( r );
}

template< class T >

constexpr

inline typename range_iterator<const T>::type end( const T& r )
{

    using namespace range_detail;

    return range_end( r );
}

    }
}

namespace boost
{
    namespace range_adl_barrier
    {
        template< class T >
        constexpr inline typename range_iterator<const T>::type
        const_end( const T& r )
        {
            return boost::range_adl_barrier::end( r );
        }
    }
    using namespace range_adl_barrier;
}
# 20 "/usr/include/boost/range/functions.hpp" 2 3 4
# 1 "/usr/include/boost/range/size.hpp" 1 3 4
# 21 "/usr/include/boost/range/size.hpp" 3 4
# 1 "/usr/include/boost/range/size_type.hpp" 1 3 4
# 19 "/usr/include/boost/range/size_type.hpp" 3 4
# 1 "/usr/include/boost/range/difference_type.hpp" 1 3 4
# 21 "/usr/include/boost/range/difference_type.hpp" 3 4
# 1 "/usr/include/boost/range/has_range_iterator.hpp" 1 3 4
# 23 "/usr/include/boost/range/has_range_iterator.hpp" 3 4
namespace boost
{
    namespace range_detail
    {
        template< typename T, typename fallback_ = boost::mpl::bool_<false> > struct has_type { struct gcc_3_2_wknd { template< typename U > static boost::mpl::aux::yes_tag test( boost::mpl::aux::type_wrapper<U> const volatile* , boost::mpl::aux::type_wrapper<typename U::type>* = 0 ); static boost::mpl::aux::no_tag test(...); }; typedef boost::mpl::aux::type_wrapper<T> t_; static const bool value = sizeof(gcc_3_2_wknd::test(static_cast<t_*>(0))) == sizeof(boost::mpl::aux::yes_tag); typedef boost::mpl::bool_<value> type; };

        template<class T, class Enabler = void>
        struct has_range_iterator_impl
            : boost::mpl::false_
        {
        };

        template<class T>
        struct has_range_iterator_impl<
            T,
            typename ::boost::enable_if<
                typename mpl::eval_if<is_const<T>,
                    has_type<boost::range_const_iterator<
                                typename remove_const<T>::type> >,
                    has_type<boost::range_mutable_iterator<T> >
                >::type
            >::type
        >
            : boost::mpl::true_
        {
        };

        template<class T, class Enabler = void>
        struct has_range_const_iterator_impl
            : boost::mpl::false_
        {
        };

        template<class T>
        struct has_range_const_iterator_impl<
            T,
            typename ::boost::enable_if<
                has_type<boost::range_const_iterator<T> >
            >::type
        >
            : boost::mpl::true_
        {
        };

    }

    template<class T>
    struct has_range_iterator
        : range_detail::has_range_iterator_impl<
            typename remove_reference<T>::type>
    {};

    template<class T>
    struct has_range_const_iterator
        : range_detail::has_range_const_iterator_impl<
            typename remove_reference<T>::type>
    {};
}
# 22 "/usr/include/boost/range/difference_type.hpp" 2 3 4



namespace boost
{
    namespace range_detail
    {
        template< class T, bool B = has_type<range_iterator<T> >::value >
        struct range_difference
        { };

        template< class T >
        struct range_difference<T, true>
          : iterator_difference<
                typename range_iterator<T>::type
            >
        { };
    }

    template< class T >
    struct range_difference
      : range_detail::range_difference<typename remove_reference<T>::type>
    { };
}
# 20 "/usr/include/boost/range/size_type.hpp" 2 3 4
# 1 "/usr/include/boost/range/concepts.hpp" 1 3 4
# 19 "/usr/include/boost/range/concepts.hpp" 3 4
# 1 "/usr/include/boost/concept_check.hpp" 1 3 4
# 20 "/usr/include/boost/concept_check.hpp" 3 4
# 1 "/usr/include/boost/concept/assert.hpp" 1 3 4
# 35 "/usr/include/boost/concept/assert.hpp" 3 4
# 1 "/usr/include/boost/concept/detail/general.hpp" 1 3 4








# 1 "/usr/include/boost/concept/detail/backward_compatibility.hpp" 1 3 4






namespace boost
{
  namespace concepts {}




}
# 10 "/usr/include/boost/concept/detail/general.hpp" 2 3 4


# 1 "/usr/include/boost/concept/detail/has_constraints.hpp" 1 3 4
# 11 "/usr/include/boost/concept/detail/has_constraints.hpp" 3 4
namespace boost { namespace concepts {

namespace detail
{



  typedef char yes;
  typedef char (&no)[2];

  template <class Model, void (Model::*)()>
  struct wrap_constraints {};
# 31 "/usr/include/boost/concept/detail/has_constraints.hpp" 3 4
  template <class Model>
  inline yes has_constraints_(Model*, wrap_constraints<Model,&Model::constraints>* = 0);
  inline no has_constraints_(...);

}



template <class Model>
struct not_satisfied
{
    static const bool value = sizeof( detail::has_constraints_((Model*)0) ) == sizeof(detail::yes);


    typedef boost::integral_constant<bool, value> type;
};

}}
# 13 "/usr/include/boost/concept/detail/general.hpp" 2 3 4





namespace boost { namespace concepts {

template <class ModelFn>
struct requirement_;

namespace detail
{
  template <void(*)()> struct instantiate {};
}

template <class Model>
struct requirement
{




    static void failed() { ((Model*)0)->~Model(); }



};

struct failed {};

template <class Model>
struct requirement<failed ************ Model::************>
{




    static void failed() { ((Model*)0)->~Model(); }



};



template <class Model>
struct constraint
{




    static void failed() { ((Model*)0)->constraints(); }



};

template <class Model>
struct requirement_<void(*)(Model)>
  : boost::conditional<
        concepts::not_satisfied<Model>::value
      , constraint<Model>
      , requirement<failed ************ Model::************>
    >::type
{};
# 96 "/usr/include/boost/concept/detail/general.hpp" 3 4
}}
# 36 "/usr/include/boost/concept/assert.hpp" 2 3 4
# 21 "/usr/include/boost/concept_check.hpp" 2 3 4


# 1 "/usr/include/boost/type_traits/conversion_traits.hpp" 1 3 4
# 24 "/usr/include/boost/concept_check.hpp" 2 3 4







# 1 "/usr/include/boost/concept/usage.hpp" 1 3 4
# 11 "/usr/include/boost/concept/usage.hpp" 3 4
namespace boost { namespace concepts {

template <class Model>
struct usage_requirements
{




    ~usage_requirements() { ((Model*)0)->~Model(); }



};
# 41 "/usr/include/boost/concept/usage.hpp" 3 4
}}
# 32 "/usr/include/boost/concept_check.hpp" 2 3 4
# 1 "/usr/include/boost/concept/detail/concept_def.hpp" 1 3 4





# 1 "/usr/include/boost/preprocessor/seq/for_each_i.hpp" 1 3 4
# 20 "/usr/include/boost/preprocessor/seq/for_each_i.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/repetition/for.hpp" 1 3 4
# 336 "/usr/include/boost/preprocessor/repetition/for.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/detail/auto_rec.hpp" 1 3 4
# 337 "/usr/include/boost/preprocessor/repetition/for.hpp" 2 3 4
# 369 "/usr/include/boost/preprocessor/repetition/for.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/repetition/detail/for.hpp" 1 3 4
# 550 "/usr/include/boost/preprocessor/repetition/detail/for.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/repetition/detail/limits/for_256.hpp" 1 3 4
# 551 "/usr/include/boost/preprocessor/repetition/detail/for.hpp" 2 3 4
# 370 "/usr/include/boost/preprocessor/repetition/for.hpp" 2 3 4
# 426 "/usr/include/boost/preprocessor/repetition/for.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/repetition/limits/for_256.hpp" 1 3 4
# 427 "/usr/include/boost/preprocessor/repetition/for.hpp" 2 3 4
# 21 "/usr/include/boost/preprocessor/seq/for_each_i.hpp" 2 3 4


# 1 "/usr/include/boost/preprocessor/seq/detail/is_empty.hpp" 1 3 4
# 24 "/usr/include/boost/preprocessor/seq/for_each_i.hpp" 2 3 4
# 7 "/usr/include/boost/concept/detail/concept_def.hpp" 2 3 4
# 1 "/usr/include/boost/preprocessor/seq/enum.hpp" 1 3 4
# 297 "/usr/include/boost/preprocessor/seq/enum.hpp" 3 4
# 1 "/usr/include/boost/preprocessor/seq/limits/enum_256.hpp" 1 3 4
# 298 "/usr/include/boost/preprocessor/seq/enum.hpp" 2 3 4
# 8 "/usr/include/boost/concept/detail/concept_def.hpp" 2 3 4
# 33 "/usr/include/boost/concept_check.hpp" 2 3 4







namespace boost
{





  template <class Model>
  inline void function_requires(Model* = 0)
  {
      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(Model)>::failed> boost_concept_check50 __attribute__((__unused__));
  }
  template <class T> inline void ignore_unused_variable_warning(T const&) {}
# 70 "/usr/include/boost/concept_check.hpp" 3 4
  template < typename T > struct Integer; template < typename T > struct IntegerConcept : Integer< T > { }; template < typename T > struct Integer
  {
      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<Integer>)>::failed> boost_concept_check72 __attribute__((__unused__)); ~Integer()
        {
            x.error_type_must_be_an_integer_type();
        }
   private:
      T x;
  };

  template <> struct Integer<char> {};
  template <> struct Integer<signed char> {};
  template <> struct Integer<unsigned char> {};
  template <> struct Integer<short> {};
  template <> struct Integer<unsigned short> {};
  template <> struct Integer<int> {};
  template <> struct Integer<unsigned int> {};
  template <> struct Integer<long> {};
  template <> struct Integer<unsigned long> {};

  template <> struct Integer< ::boost::long_long_type> {};
  template <> struct Integer< ::boost::ulong_long_type> {};





  template < typename T > struct SignedInteger; template < typename T > struct SignedIntegerConcept : SignedInteger< T > { }; template < typename T > struct SignedInteger {
    typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<SignedInteger>)>::failed> boost_concept_check98 __attribute__((__unused__)); ~SignedInteger() {
      x.error_type_must_be_a_signed_integer_type();
    }
   private:
    T x;
  };
  template <> struct SignedInteger<signed char> { };
  template <> struct SignedInteger<short> {};
  template <> struct SignedInteger<int> {};
  template <> struct SignedInteger<long> {};

  template <> struct SignedInteger< ::boost::long_long_type> {};




  template < typename T > struct UnsignedInteger; template < typename T > struct UnsignedIntegerConcept : UnsignedInteger< T > { }; template < typename T > struct UnsignedInteger {
    typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<UnsignedInteger>)>::failed> boost_concept_check115 __attribute__((__unused__)); ~UnsignedInteger() {
      x.error_type_must_be_an_unsigned_integer_type();
    }
   private:
    T x;
  };

  template <> struct UnsignedInteger<unsigned char> {};
  template <> struct UnsignedInteger<unsigned short> {};
  template <> struct UnsignedInteger<unsigned int> {};
  template <> struct UnsignedInteger<unsigned long> {};

  template <> struct UnsignedInteger< ::boost::ulong_long_type> {};







  template < typename TT > struct DefaultConstructible; template < typename TT > struct DefaultConstructibleConcept : DefaultConstructible< TT > { }; template < typename TT > struct DefaultConstructible
  {
    typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<DefaultConstructible>)>::failed> boost_concept_check137 __attribute__((__unused__)); ~DefaultConstructible() {
      TT a;
      ignore_unused_variable_warning(a);
    }
  };

  template < typename TT > struct Assignable; template < typename TT > struct AssignableConcept : Assignable< TT > { }; template < typename TT > struct Assignable
  {
    typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<Assignable>)>::failed> boost_concept_check145 __attribute__((__unused__)); ~Assignable() {

      a = b;

      const_constraints(b);
    }
   private:
    void const_constraints(const TT& x) {

      a = x;



    }
   private:
    TT a;
    TT b;
  };


  template < typename TT > struct CopyConstructible; template < typename TT > struct CopyConstructibleConcept : CopyConstructible< TT > { }; template < typename TT > struct CopyConstructible
  {
    typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<CopyConstructible>)>::failed> boost_concept_check167 __attribute__((__unused__)); ~CopyConstructible() {
      TT a(b);
      TT* ptr = &a;
      const_constraints(a);
      ignore_unused_variable_warning(ptr);
    }
   private:
    void const_constraints(const TT& a) {
      TT c(a);
      const TT* ptr = &a;
      ignore_unused_variable_warning(c);
      ignore_unused_variable_warning(ptr);
    }
    TT b;
  };


  template < typename TT > struct SGIAssignable; template < typename TT > struct SGIAssignableConcept : SGIAssignable< TT > { }; template < typename TT > struct SGIAssignable
  {
    typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<SGIAssignable>)>::failed> boost_concept_check186 __attribute__((__unused__)); ~SGIAssignable() {
      TT c(a);

      a = b;

      const_constraints(b);
      ignore_unused_variable_warning(c);
    }
   private:
    void const_constraints(const TT& x) {
      TT c(x);

      a = x;

      ignore_unused_variable_warning(c);
    }
    TT a;
    TT b;
  };

  template < typename X , typename Y > struct Convertible; template < typename X , typename Y > struct ConvertibleConcept : Convertible< X, Y > { }; template < typename X , typename Y > struct Convertible
  {
    typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<Convertible>)>::failed> boost_concept_check208 __attribute__((__unused__)); ~Convertible() {
      Y y = x;
      ignore_unused_variable_warning(y);
    }
   private:
    X x;
  };
# 225 "/usr/include/boost/concept_check.hpp" 3 4
  template <class TT>
  void require_boolean_expr(const TT& t) {
    bool x = t;
    ignore_unused_variable_warning(x);
  }

  template < typename TT > struct EqualityComparable; template < typename TT > struct EqualityComparableConcept : EqualityComparable< TT > { }; template < typename TT > struct EqualityComparable
  {
    typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<EqualityComparable>)>::failed> boost_concept_check233 __attribute__((__unused__)); ~EqualityComparable() {
      require_boolean_expr(a == b);
      require_boolean_expr(a != b);
    }
   private:
    TT a, b;
  };

  template < typename TT > struct LessThanComparable; template < typename TT > struct LessThanComparableConcept : LessThanComparable< TT > { }; template < typename TT > struct LessThanComparable
  {
    typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<LessThanComparable>)>::failed> boost_concept_check243 __attribute__((__unused__)); ~LessThanComparable() {
      require_boolean_expr(a < b);
    }
   private:
    TT a, b;
  };


  template < typename TT > struct Comparable; template < typename TT > struct ComparableConcept : Comparable< TT > { }; template < typename TT > struct Comparable
  {
    typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<Comparable>)>::failed> boost_concept_check253 __attribute__((__unused__)); ~Comparable() {
      require_boolean_expr(a < b);
      require_boolean_expr(a > b);
      require_boolean_expr(a <= b);
      require_boolean_expr(a >= b);
    }
   private:
    TT a, b;
  };
# 283 "/usr/include/boost/concept_check.hpp" 3 4
  template < typename First , typename Second > struct EqualOp; template < typename First , typename Second > struct EqualOpConcept : EqualOp< First, Second > { }; template < typename First , typename Second > struct EqualOp { typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<EqualOp>)>::failed> boost_concept_check283 __attribute__((__unused__)); ~EqualOp() { (void)constraints_(); } private: bool constraints_() { return a == b; } First a; Second b; };
  template < typename First , typename Second > struct NotEqualOp; template < typename First , typename Second > struct NotEqualOpConcept : NotEqualOp< First, Second > { }; template < typename First , typename Second > struct NotEqualOp { typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<NotEqualOp>)>::failed> boost_concept_check284 __attribute__((__unused__)); ~NotEqualOp() { (void)constraints_(); } private: bool constraints_() { return a != b; } First a; Second b; };
  template < typename First , typename Second > struct LessThanOp; template < typename First , typename Second > struct LessThanOpConcept : LessThanOp< First, Second > { }; template < typename First , typename Second > struct LessThanOp { typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<LessThanOp>)>::failed> boost_concept_check285 __attribute__((__unused__)); ~LessThanOp() { (void)constraints_(); } private: bool constraints_() { return a < b; } First a; Second b; };
  template < typename First , typename Second > struct LessEqualOp; template < typename First , typename Second > struct LessEqualOpConcept : LessEqualOp< First, Second > { }; template < typename First , typename Second > struct LessEqualOp { typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<LessEqualOp>)>::failed> boost_concept_check286 __attribute__((__unused__)); ~LessEqualOp() { (void)constraints_(); } private: bool constraints_() { return a <= b; } First a; Second b; };
  template < typename First , typename Second > struct GreaterThanOp; template < typename First , typename Second > struct GreaterThanOpConcept : GreaterThanOp< First, Second > { }; template < typename First , typename Second > struct GreaterThanOp { typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<GreaterThanOp>)>::failed> boost_concept_check287 __attribute__((__unused__)); ~GreaterThanOp() { (void)constraints_(); } private: bool constraints_() { return a > b; } First a; Second b; };
  template < typename First , typename Second > struct GreaterEqualOp; template < typename First , typename Second > struct GreaterEqualOpConcept : GreaterEqualOp< First, Second > { }; template < typename First , typename Second > struct GreaterEqualOp { typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<GreaterEqualOp>)>::failed> boost_concept_check288 __attribute__((__unused__)); ~GreaterEqualOp() { (void)constraints_(); } private: bool constraints_() { return a >= b; } First a; Second b; };

  template < typename Ret , typename First , typename Second > struct PlusOp; template < typename Ret , typename First , typename Second > struct PlusOpConcept : PlusOp< Ret, First, Second > { }; template < typename Ret , typename First , typename Second > struct PlusOp { typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<PlusOp>)>::failed> boost_concept_check290 __attribute__((__unused__)); ~PlusOp() { (void)constraints_(); } private: Ret constraints_() { return a + b; } First a; Second b; };
  template < typename Ret , typename First , typename Second > struct TimesOp; template < typename Ret , typename First , typename Second > struct TimesOpConcept : TimesOp< Ret, First, Second > { }; template < typename Ret , typename First , typename Second > struct TimesOp { typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<TimesOp>)>::failed> boost_concept_check291 __attribute__((__unused__)); ~TimesOp() { (void)constraints_(); } private: Ret constraints_() { return a * b; } First a; Second b; };
  template < typename Ret , typename First , typename Second > struct DivideOp; template < typename Ret , typename First , typename Second > struct DivideOpConcept : DivideOp< Ret, First, Second > { }; template < typename Ret , typename First , typename Second > struct DivideOp { typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<DivideOp>)>::failed> boost_concept_check292 __attribute__((__unused__)); ~DivideOp() { (void)constraints_(); } private: Ret constraints_() { return a / b; } First a; Second b; };
  template < typename Ret , typename First , typename Second > struct SubtractOp; template < typename Ret , typename First , typename Second > struct SubtractOpConcept : SubtractOp< Ret, First, Second > { }; template < typename Ret , typename First , typename Second > struct SubtractOp { typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<SubtractOp>)>::failed> boost_concept_check293 __attribute__((__unused__)); ~SubtractOp() { (void)constraints_(); } private: Ret constraints_() { return a - b; } First a; Second b; };
  template < typename Ret , typename First , typename Second > struct ModOp; template < typename Ret , typename First , typename Second > struct ModOpConcept : ModOp< Ret, First, Second > { }; template < typename Ret , typename First , typename Second > struct ModOp { typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<ModOp>)>::failed> boost_concept_check294 __attribute__((__unused__)); ~ModOp() { (void)constraints_(); } private: Ret constraints_() { return a % b; } First a; Second b; };




  template < typename Func , typename Return > struct Generator; template < typename Func , typename Return > struct GeneratorConcept : Generator< Func, Return > { }; template < typename Func , typename Return > struct Generator
  {
      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<Generator>)>::failed> boost_concept_check301 __attribute__((__unused__)); ~Generator() { test(is_void<Return>()); }

   private:
      void test(boost::false_type)
      {

          const Return& r = f();
          ignore_unused_variable_warning(r);
      }

      void test(boost::true_type)
      {
          f();
      }

      Func f;
  };

  template < typename Func , typename Return , typename Arg > struct UnaryFunction; template < typename Func , typename Return , typename Arg > struct UnaryFunctionConcept : UnaryFunction< Func, Return, Arg > { }; template < typename Func , typename Return , typename Arg > struct UnaryFunction
  {
      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<UnaryFunction>)>::failed> boost_concept_check321 __attribute__((__unused__)); ~UnaryFunction() { test(is_void<Return>()); }

   private:
      void test(boost::false_type)
      {
          f(arg);
          Return r = f(arg);
          ignore_unused_variable_warning(r);
      }

      void test(boost::true_type)
      {
          f(arg);
      }







      UnaryFunction();


      Func f;
      Arg arg;
  };

  template < typename Func , typename Return , typename First , typename Second > struct BinaryFunction; template < typename Func , typename Return , typename First , typename Second > struct BinaryFunctionConcept : BinaryFunction< Func, Return, First, Second > { }; template < typename Func , typename Return , typename First , typename Second > struct BinaryFunction
  {
      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<BinaryFunction>)>::failed> boost_concept_check351 __attribute__((__unused__)); ~BinaryFunction() { test(is_void<Return>()); }
   private:
      void test(boost::false_type)
      {
          (void) f(first,second);
          Return r = f(first, second);
          (void)r;
      }

      void test(boost::true_type)
      {
          f(first,second);
      }







      BinaryFunction();


      Func f;
      First first;
      Second second;
  };

  template < typename Func , typename Arg > struct UnaryPredicate; template < typename Func , typename Arg > struct UnaryPredicateConcept : UnaryPredicate< Func, Arg > { }; template < typename Func , typename Arg > struct UnaryPredicate
  {
    typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<UnaryPredicate>)>::failed> boost_concept_check381 __attribute__((__unused__)); ~UnaryPredicate() {
      require_boolean_expr(f(arg));
    }
   private:






      UnaryPredicate();


    Func f;
    Arg arg;
  };

  template < typename Func , typename First , typename Second > struct BinaryPredicate; template < typename Func , typename First , typename Second > struct BinaryPredicateConcept : BinaryPredicate< Func, First, Second > { }; template < typename Func , typename First , typename Second > struct BinaryPredicate
  {
    typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<BinaryPredicate>)>::failed> boost_concept_check400 __attribute__((__unused__)); ~BinaryPredicate() {
      require_boolean_expr(f(a, b));
    }
   private:






      BinaryPredicate();

    Func f;
    First a;
    Second b;
  };


  template < typename Func , typename First , typename Second > struct Const_BinaryPredicate; template < typename Func , typename First , typename Second > struct Const_BinaryPredicateConcept : Const_BinaryPredicate< Func, First, Second > { }; template < typename Func , typename First , typename Second > struct Const_BinaryPredicate
    : BinaryPredicate<Func, First, Second>
  {
    typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<Const_BinaryPredicate>)>::failed> boost_concept_check421 __attribute__((__unused__)); ~Const_BinaryPredicate() {
      const_constraints(f);
    }
   private:
    void const_constraints(const Func& fun) {

      require_boolean_expr(fun(a, b));
    }






      Const_BinaryPredicate();


    Func f;
    First a;
    Second b;
  };

  template < typename Func , typename Return > struct AdaptableGenerator; template < typename Func , typename Return > struct AdaptableGeneratorConcept : AdaptableGenerator< Func, Return > { }; template < typename Func , typename Return > struct AdaptableGenerator
    : Generator<Func, typename Func::result_type>
  {
      typedef typename Func::result_type result_type;

      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<AdaptableGenerator>)>::failed> boost_concept_check448 __attribute__((__unused__)); ~AdaptableGenerator()
      {
          typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(Convertible<result_type, Return>)>::failed> boost_concept_check450 __attribute__((__unused__));
      }
  };

  template < typename Func , typename Return , typename Arg > struct AdaptableUnaryFunction; template < typename Func , typename Return , typename Arg > struct AdaptableUnaryFunctionConcept : AdaptableUnaryFunction< Func, Return, Arg > { }; template < typename Func , typename Return , typename Arg > struct AdaptableUnaryFunction
    : UnaryFunction<Func, typename Func::result_type, typename Func::argument_type>
  {
      typedef typename Func::argument_type argument_type;
      typedef typename Func::result_type result_type;

      ~AdaptableUnaryFunction()
      {
          typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(Convertible<result_type, Return>)>::failed> boost_concept_check462 __attribute__((__unused__));
          typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(Convertible<Arg, argument_type>)>::failed> boost_concept_check463 __attribute__((__unused__));
      }
  };

  template < typename Func , typename Return , typename First , typename Second > struct AdaptableBinaryFunction; template < typename Func , typename Return , typename First , typename Second > struct AdaptableBinaryFunctionConcept : AdaptableBinaryFunction< Func, Return, First, Second > { }; template < typename Func , typename Return , typename First , typename Second > struct AdaptableBinaryFunction
    : BinaryFunction<
          Func
        , typename Func::result_type
        , typename Func::first_argument_type
        , typename Func::second_argument_type
      >
  {
      typedef typename Func::first_argument_type first_argument_type;
      typedef typename Func::second_argument_type second_argument_type;
      typedef typename Func::result_type result_type;

      ~AdaptableBinaryFunction()
      {
          typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(Convertible<result_type, Return>)>::failed> boost_concept_check481 __attribute__((__unused__));
          typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(Convertible<First, first_argument_type>)>::failed> boost_concept_check482 __attribute__((__unused__));
          typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(Convertible<Second, second_argument_type>)>::failed> boost_concept_check483 __attribute__((__unused__));
      }
  };

  template < typename Func , typename Arg > struct AdaptablePredicate; template < typename Func , typename Arg > struct AdaptablePredicateConcept : AdaptablePredicate< Func, Arg > { }; template < typename Func , typename Arg > struct AdaptablePredicate
    : UnaryPredicate<Func, Arg>
    , AdaptableUnaryFunction<Func, bool, Arg>
  {
  };

  template < typename Func , typename First , typename Second > struct AdaptableBinaryPredicate; template < typename Func , typename First , typename Second > struct AdaptableBinaryPredicateConcept : AdaptableBinaryPredicate< Func, First, Second > { }; template < typename Func , typename First , typename Second > struct AdaptableBinaryPredicate
    : BinaryPredicate<Func, First, Second>
    , AdaptableBinaryFunction<Func, bool, First, Second>
  {
  };




  template < typename TT > struct InputIterator; template < typename TT > struct InputIteratorConcept : InputIterator< TT > { }; template < typename TT > struct InputIterator
    : Assignable<TT>
    , EqualityComparable<TT>
  {
      typedef typename std::iterator_traits<TT>::value_type value_type;
      typedef typename std::iterator_traits<TT>::difference_type difference_type;
      typedef typename std::iterator_traits<TT>::reference reference;
      typedef typename std::iterator_traits<TT>::pointer pointer;
      typedef typename std::iterator_traits<TT>::iterator_category iterator_category;

      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<InputIterator>)>::failed> boost_concept_check512 __attribute__((__unused__)); ~InputIterator()
      {
        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(SignedInteger<difference_type>)>::failed> boost_concept_check514 __attribute__((__unused__));
        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(Convertible<iterator_category, std::input_iterator_tag>)>::failed> boost_concept_check515 __attribute__((__unused__));

        TT j(i);
        (void)*i;
        ++j;
        i++;
      }
   private:
    TT i;
  };

  template < typename TT , typename ValueT > struct OutputIterator; template < typename TT , typename ValueT > struct OutputIteratorConcept : OutputIterator< TT, ValueT > { }; template < typename TT , typename ValueT > struct OutputIterator
    : Assignable<TT>
  {
    typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<OutputIterator>)>::failed> boost_concept_check529 __attribute__((__unused__)); ~OutputIterator() {

      ++i;
      i++;
      *i++ = t;
    }
   private:
    TT i, j;
    ValueT t;
  };

  template < typename TT > struct ForwardIterator; template < typename TT > struct ForwardIteratorConcept : ForwardIterator< TT > { }; template < typename TT > struct ForwardIterator
    : InputIterator<TT>
  {
      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<ForwardIterator>)>::failed> boost_concept_check543 __attribute__((__unused__)); ~ForwardIterator()
      {
          typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(Convertible< typename ForwardIterator::iterator_category , std::forward_iterator_tag >)>::failed> boost_concept_check548 __attribute__((__unused__));




          typename InputIterator<TT>::reference r = *i;
          ignore_unused_variable_warning(r);
      }

   private:
      TT i;
  };

  template < typename TT > struct Mutable_ForwardIterator; template < typename TT > struct Mutable_ForwardIteratorConcept : Mutable_ForwardIterator< TT > { }; template < typename TT > struct Mutable_ForwardIterator
    : ForwardIterator<TT>
  {
      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<Mutable_ForwardIterator>)>::failed> boost_concept_check561 __attribute__((__unused__)); ~Mutable_ForwardIterator() {
        *i++ = *j;
      }
   private:
      TT i, j;
  };

  template < typename TT > struct BidirectionalIterator; template < typename TT > struct BidirectionalIteratorConcept : BidirectionalIterator< TT > { }; template < typename TT > struct BidirectionalIterator
    : ForwardIterator<TT>
  {
      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<BidirectionalIterator>)>::failed> boost_concept_check571 __attribute__((__unused__)); ~BidirectionalIterator()
      {
          typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(Convertible< typename BidirectionalIterator::iterator_category , std::bidirectional_iterator_tag >)>::failed> boost_concept_check576 __attribute__((__unused__));




          --i;
          i--;
      }
   private:
      TT i;
  };

  template < typename TT > struct Mutable_BidirectionalIterator; template < typename TT > struct Mutable_BidirectionalIteratorConcept : Mutable_BidirectionalIterator< TT > { }; template < typename TT > struct Mutable_BidirectionalIterator
    : BidirectionalIterator<TT>
    , Mutable_ForwardIterator<TT>
  {
      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<Mutable_BidirectionalIterator>)>::failed> boost_concept_check589 __attribute__((__unused__)); ~Mutable_BidirectionalIterator()
      {
          *i-- = *j;
      }
   private:
      TT i, j;
  };

  template < typename TT > struct RandomAccessIterator; template < typename TT > struct RandomAccessIteratorConcept : RandomAccessIterator< TT > { }; template < typename TT > struct RandomAccessIterator
    : BidirectionalIterator<TT>
    , Comparable<TT>
  {
      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<RandomAccessIterator>)>::failed> boost_concept_check601 __attribute__((__unused__)); ~RandomAccessIterator()
      {
          typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(Convertible< typename BidirectionalIterator<TT>::iterator_category , std::random_access_iterator_tag >)>::failed> boost_concept_check606 __attribute__((__unused__));




          i += n;
          i = i + n; i = n + i;
          i -= n;
          i = i - n;
          n = i - j;
          (void)i[n];
      }

   private:
    TT a, b;
    TT i, j;
      typename std::iterator_traits<TT>::difference_type n;
  };

  template < typename TT > struct Mutable_RandomAccessIterator; template < typename TT > struct Mutable_RandomAccessIteratorConcept : Mutable_RandomAccessIterator< TT > { }; template < typename TT > struct Mutable_RandomAccessIterator
    : RandomAccessIterator<TT>
    , Mutable_BidirectionalIterator<TT>
  {
      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<Mutable_RandomAccessIterator>)>::failed> boost_concept_check626 __attribute__((__unused__)); ~Mutable_RandomAccessIterator()
      {
          i[n] = *i;
      }
   private:
    TT i;
    typename std::iterator_traits<TT>::difference_type n;
  };




  template < typename C > struct Container; template < typename C > struct ContainerConcept : Container< C > { }; template < typename C > struct Container
    : Assignable<C>
  {
    typedef typename C::value_type value_type;
    typedef typename C::difference_type difference_type;
    typedef typename C::size_type size_type;
    typedef typename C::const_reference const_reference;
    typedef typename C::const_pointer const_pointer;
    typedef typename C::const_iterator const_iterator;

      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<Container>)>::failed> boost_concept_check648 __attribute__((__unused__)); ~Container()
      {
          typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(InputIterator<const_iterator>)>::failed> boost_concept_check650 __attribute__((__unused__));
          const_constraints(c);
      }

   private:
      void const_constraints(const C& cc) {
          i = cc.begin();
          i = cc.end();
          n = cc.size();
          n = cc.max_size();
          b = cc.empty();
      }
      C c;
      bool b;
      const_iterator i;
      size_type n;
  };

  template < typename C > struct Mutable_Container; template < typename C > struct Mutable_ContainerConcept : Mutable_Container< C > { }; template < typename C > struct Mutable_Container
    : Container<C>
  {
      typedef typename C::reference reference;
      typedef typename C::iterator iterator;
      typedef typename C::pointer pointer;

      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<Mutable_Container>)>::failed> boost_concept_check675 __attribute__((__unused__)); ~Mutable_Container()
      {
          typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( Assignable<typename Mutable_Container::value_type>)>::failed> boost_concept_check678 __attribute__((__unused__));


          typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(InputIterator<iterator>)>::failed> boost_concept_check680 __attribute__((__unused__));

          i = c.begin();
          i = c.end();
          c.swap(c2);
      }

   private:
      iterator i;
      C c, c2;
  };

  template < typename C > struct ForwardContainer; template < typename C > struct ForwardContainerConcept : ForwardContainer< C > { }; template < typename C > struct ForwardContainer
    : Container<C>
  {
      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<ForwardContainer>)>::failed> boost_concept_check695 __attribute__((__unused__)); ~ForwardContainer()
      {
          typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( ForwardIterator< typename ForwardContainer::const_iterator >)>::failed> boost_concept_check700 __attribute__((__unused__));



      }
  };

  template < typename C > struct Mutable_ForwardContainer; template < typename C > struct Mutable_ForwardContainerConcept : Mutable_ForwardContainer< C > { }; template < typename C > struct Mutable_ForwardContainer
    : ForwardContainer<C>
    , Mutable_Container<C>
  {
      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<Mutable_ForwardContainer>)>::failed> boost_concept_check708 __attribute__((__unused__)); ~Mutable_ForwardContainer()
      {
          typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( Mutable_ForwardIterator< typename Mutable_ForwardContainer::iterator >)>::failed> boost_concept_check713 __attribute__((__unused__));



      }
  };

  template < typename C > struct ReversibleContainer; template < typename C > struct ReversibleContainerConcept : ReversibleContainer< C > { }; template < typename C > struct ReversibleContainer
    : ForwardContainer<C>
  {
      typedef typename
        C::const_reverse_iterator
      const_reverse_iterator;

      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<ReversibleContainer>)>::failed> boost_concept_check724 __attribute__((__unused__)); ~ReversibleContainer()
      {
          typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( BidirectionalIterator< typename ReversibleContainer::const_iterator>)>::failed> boost_concept_check728 __attribute__((__unused__));



          typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(BidirectionalIterator<const_reverse_iterator>)>::failed> boost_concept_check730 __attribute__((__unused__));

          const_constraints(c);
      }
   private:
      void const_constraints(const C& cc)
      {
          const_reverse_iterator _i = cc.rbegin();
          _i = cc.rend();
      }
      C c;
  };

  template < typename C > struct Mutable_ReversibleContainer; template < typename C > struct Mutable_ReversibleContainerConcept : Mutable_ReversibleContainer< C > { }; template < typename C > struct Mutable_ReversibleContainer
    : Mutable_ForwardContainer<C>
    , ReversibleContainer<C>
  {
      typedef typename C::reverse_iterator reverse_iterator;

      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<Mutable_ReversibleContainer>)>::failed> boost_concept_check749 __attribute__((__unused__)); ~Mutable_ReversibleContainer()
      {
          typedef typename Mutable_ForwardContainer<C>::iterator iterator;
          typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(Mutable_BidirectionalIterator<iterator>)>::failed> boost_concept_check752 __attribute__((__unused__));
          typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(Mutable_BidirectionalIterator<reverse_iterator>)>::failed> boost_concept_check753 __attribute__((__unused__));

          reverse_iterator i = c.rbegin();
          i = c.rend();
      }
   private:
      C c;
  };

  template < typename C > struct RandomAccessContainer; template < typename C > struct RandomAccessContainerConcept : RandomAccessContainer< C > { }; template < typename C > struct RandomAccessContainer
    : ReversibleContainer<C>
  {
      typedef typename C::size_type size_type;
      typedef typename C::const_reference const_reference;

      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<RandomAccessContainer>)>::failed> boost_concept_check768 __attribute__((__unused__)); ~RandomAccessContainer()
      {
          typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( RandomAccessIterator< typename RandomAccessContainer::const_iterator >)>::failed> boost_concept_check773 __attribute__((__unused__));




          const_constraints(c);
      }
   private:
      void const_constraints(const C& cc)
      {
          const_reference r = cc[n];
          ignore_unused_variable_warning(r);
      }

      C c;
      size_type n;
  };

  template < typename C > struct Mutable_RandomAccessContainer; template < typename C > struct Mutable_RandomAccessContainerConcept : Mutable_RandomAccessContainer< C > { }; template < typename C > struct Mutable_RandomAccessContainer
    : Mutable_ReversibleContainer<C>
    , RandomAccessContainer<C>
  {
   private:
      typedef Mutable_RandomAccessContainer self;
   public:
      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<Mutable_RandomAccessContainer>)>::failed> boost_concept_check795 __attribute__((__unused__)); ~Mutable_RandomAccessContainer()
      {
          typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(Mutable_RandomAccessIterator<typename self::iterator>)>::failed> boost_concept_check797 __attribute__((__unused__));
          typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(Mutable_RandomAccessIterator<typename self::reverse_iterator>)>::failed> boost_concept_check798 __attribute__((__unused__));

          typename self::reference r = c[i];
          ignore_unused_variable_warning(r);
      }

   private:
      typename Mutable_ReversibleContainer<C>::size_type i;
      C c;
  };


  template < typename S > struct Sequence; template < typename S > struct SequenceConcept : Sequence< S > { }; template < typename S > struct Sequence
    : Mutable_ForwardContainer<S>



    , DefaultConstructible<S>
  {
      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<Sequence>)>::failed> boost_concept_check817 __attribute__((__unused__)); ~Sequence()
      {
          S
              c(n, t),
              c2(first, last);

          c.insert(p, t);
          c.insert(p, n, t);
          c.insert(p, first, last);

          c.erase(p);
          c.erase(p, q);

          typename Sequence::reference r = c.front();

          ignore_unused_variable_warning(c);
          ignore_unused_variable_warning(c2);
          ignore_unused_variable_warning(r);
          const_constraints(c);
      }
   private:
      void const_constraints(const S& c) {
          typename Sequence::const_reference r = c.front();
          ignore_unused_variable_warning(r);
      }

      typename S::value_type t;
      typename S::size_type n;
      typename S::value_type* first, *last;
      typename S::iterator p, q;
  };

  template < typename S > struct FrontInsertionSequence; template < typename S > struct FrontInsertionSequenceConcept : FrontInsertionSequence< S > { }; template < typename S > struct FrontInsertionSequence
    : Sequence<S>
  {
      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<FrontInsertionSequence>)>::failed> boost_concept_check852 __attribute__((__unused__)); ~FrontInsertionSequence()
      {
          c.push_front(t);
          c.pop_front();
      }
   private:
      S c;
      typename S::value_type t;
  };

  template < typename S > struct BackInsertionSequence; template < typename S > struct BackInsertionSequenceConcept : BackInsertionSequence< S > { }; template < typename S > struct BackInsertionSequence
    : Sequence<S>
  {
      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<BackInsertionSequence>)>::failed> boost_concept_check865 __attribute__((__unused__)); ~BackInsertionSequence()
      {
          c.push_back(t);
          c.pop_back();
          typename BackInsertionSequence::reference r = c.back();
          ignore_unused_variable_warning(r);
          const_constraints(c);
      }
   private:
      void const_constraints(const S& cc) {
          typename BackInsertionSequence::const_reference
              r = cc.back();
          ignore_unused_variable_warning(r);
      }
      S c;
      typename S::value_type t;
  };

  template < typename C > struct AssociativeContainer; template < typename C > struct AssociativeContainerConcept : AssociativeContainer< C > { }; template < typename C > struct AssociativeContainer
    : ForwardContainer<C>
    , DefaultConstructible<C>
  {
      typedef typename C::key_type key_type;
      typedef typename C::key_compare key_compare;
      typedef typename C::value_compare value_compare;
      typedef typename C::iterator iterator;

      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<AssociativeContainer>)>::failed> boost_concept_check892 __attribute__((__unused__)); ~AssociativeContainer()
      {
          i = c.find(k);
          r = c.equal_range(k);
          c.erase(k);
          c.erase(i);
          c.erase(r.first, r.second);
          const_constraints(c);
          typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(BinaryPredicate<key_compare,key_type,key_type>)>::failed> boost_concept_check900 __attribute__((__unused__));

          typedef typename AssociativeContainer::value_type value_type_;
          typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(BinaryPredicate<value_compare,value_type_,value_type_>)>::failed> boost_concept_check903 __attribute__((__unused__));
      }


      typedef typename C::const_iterator const_iterator;
   private:
      void const_constraints(const C& cc)
      {
          ci = cc.find(k);
          n = cc.count(k);
          cr = cc.equal_range(k);
      }

      C c;
      iterator i;
      std::pair<iterator,iterator> r;
      const_iterator ci;
      std::pair<const_iterator,const_iterator> cr;
      typename C::key_type k;
      typename C::size_type n;
  };

  template < typename C > struct UniqueAssociativeContainer; template < typename C > struct UniqueAssociativeContainerConcept : UniqueAssociativeContainer< C > { }; template < typename C > struct UniqueAssociativeContainer
    : AssociativeContainer<C>
  {
      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<UniqueAssociativeContainer>)>::failed> boost_concept_check928 __attribute__((__unused__)); ~UniqueAssociativeContainer()
      {
          C c(first, last);

          pos_flag = c.insert(t);
          c.insert(first, last);

          ignore_unused_variable_warning(c);
      }
   private:
      std::pair<typename C::iterator, bool> pos_flag;
      typename C::value_type t;
      typename C::value_type* first, *last;
  };

  template < typename C > struct MultipleAssociativeContainer; template < typename C > struct MultipleAssociativeContainerConcept : MultipleAssociativeContainer< C > { }; template < typename C > struct MultipleAssociativeContainer
    : AssociativeContainer<C>
  {
      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<MultipleAssociativeContainer>)>::failed> boost_concept_check946 __attribute__((__unused__)); ~MultipleAssociativeContainer()
      {
          C c(first, last);

          pos = c.insert(t);
          c.insert(first, last);

          ignore_unused_variable_warning(c);
          ignore_unused_variable_warning(pos);
      }
   private:
      typename C::iterator pos;
      typename C::value_type t;
      typename C::value_type* first, *last;
  };

  template < typename C > struct SimpleAssociativeContainer; template < typename C > struct SimpleAssociativeContainerConcept : SimpleAssociativeContainer< C > { }; template < typename C > struct SimpleAssociativeContainer
    : AssociativeContainer<C>
  {
      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<SimpleAssociativeContainer>)>::failed> boost_concept_check965 __attribute__((__unused__)); ~SimpleAssociativeContainer()
      {
          typedef typename C::key_type key_type;
          typedef typename C::value_type value_type;
          static_assert((boost::is_same<key_type,value_type>::value), "(boost::is_same<key_type,value_type>::value)");
      }
  };

  template < typename C > struct PairAssociativeContainer; template < typename C > struct PairAssociativeContainerConcept : PairAssociativeContainer< C > { }; template < typename C > struct PairAssociativeContainer
    : AssociativeContainer<C>
  {
      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<PairAssociativeContainer>)>::failed> boost_concept_check976 __attribute__((__unused__)); ~PairAssociativeContainer()
      {
          typedef typename C::key_type key_type;
          typedef typename C::value_type value_type;
          typedef typename C::mapped_type mapped_type;
          typedef std::pair<const key_type, mapped_type> required_value_type;
          static_assert((boost::is_same<value_type,required_value_type>::value), "(boost::is_same<value_type,required_value_type>::value)");
      }
  };

  template < typename C > struct SortedAssociativeContainer; template < typename C > struct SortedAssociativeContainerConcept : SortedAssociativeContainer< C > { }; template < typename C > struct SortedAssociativeContainer
    : AssociativeContainer<C>
    , ReversibleContainer<C>
  {
      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<SortedAssociativeContainer>)>::failed> boost_concept_check990 __attribute__((__unused__)); ~SortedAssociativeContainer()
      {
          C
              c(kc),
              c2(first, last),
              c3(first, last, kc);

          p = c.upper_bound(k);
          p = c.lower_bound(k);
          r = c.equal_range(k);

          c.insert(p, t);

          ignore_unused_variable_warning(c);
          ignore_unused_variable_warning(c2);
          ignore_unused_variable_warning(c3);
          const_constraints(c);
      }

      void const_constraints(const C& c)
      {
          kc = c.key_comp();
          vc = c.value_comp();

          cp = c.upper_bound(k);
          cp = c.lower_bound(k);
          cr = c.equal_range(k);
      }

   private:
      typename C::key_compare kc;
      typename C::value_compare vc;
      typename C::value_type t;
      typename C::key_type k;
      typedef typename C::iterator iterator;
      typedef typename C::const_iterator const_iterator;

      typedef SortedAssociativeContainer self;
      iterator p;
      const_iterator cp;
      std::pair<typename self::iterator,typename self::iterator> r;
      std::pair<typename self::const_iterator,typename self::const_iterator> cr;
      typename C::value_type* first, *last;
  };



  template < typename C > struct Collection; template < typename C > struct CollectionConcept : Collection< C > { }; template < typename C > struct Collection
  {
      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<Collection>)>::failed> boost_concept_check1039 __attribute__((__unused__)); ~Collection()
      {
        boost::function_requires<boost::InputIteratorConcept<iterator> >();
        boost::function_requires<boost::InputIteratorConcept<const_iterator> >();
        boost::function_requires<boost::CopyConstructibleConcept<value_type> >();
        const_constraints(c);
        i = c.begin();
        i = c.end();
        c.swap(c);
      }

      void const_constraints(const C& cc) {
        ci = cc.begin();
        ci = cc.end();
        n = cc.size();
        b = cc.empty();
      }

    private:
      typedef typename C::value_type value_type;
      typedef typename C::iterator iterator;
      typedef typename C::const_iterator const_iterator;
      typedef typename C::reference reference;
      typedef typename C::const_reference const_reference;

      typedef typename C::difference_type difference_type;
      typedef typename C::size_type size_type;

      C c;
      bool b;
      iterator i;
      const_iterator ci;
      size_type n;
  };
}





# 1 "/usr/include/boost/concept/detail/concept_undef.hpp" 1 3 4
# 1080 "/usr/include/boost/concept_check.hpp" 2 3 4
# 20 "/usr/include/boost/range/concepts.hpp" 2 3 4
# 1 "/usr/include/boost/iterator/iterator_concepts.hpp" 1 3 4
# 29 "/usr/include/boost/iterator/iterator_concepts.hpp" 3 4
# 1 "/usr/include/boost/concept/detail/concept_def.hpp" 1 3 4
# 30 "/usr/include/boost/iterator/iterator_concepts.hpp" 2 3 4

namespace boost_concepts
{







  template < typename Iterator > struct ReadableIterator; template < typename Iterator > struct ReadableIteratorConcept : ReadableIterator< Iterator > { }; template < typename Iterator > struct ReadableIterator
    : boost::Assignable<Iterator>
    , boost::CopyConstructible<Iterator>

  {
      typedef typename std::iterator_traits<Iterator>::value_type value_type;
      typedef typename std::iterator_traits<Iterator>::reference reference;

      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<ReadableIterator>)>::failed> boost_concept_check48 __attribute__((__unused__)); ~ReadableIterator()
      {

          value_type v = *i;
          boost::ignore_unused_variable_warning(v);
      }
  private:
      Iterator i;
  };

  template <
      typename Iterator
    , typename ValueType = typename std::iterator_traits<Iterator>::value_type
  >
  struct WritableIterator
    : boost::CopyConstructible<Iterator>
  {
      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<WritableIterator>)>::failed> boost_concept_check65 __attribute__((__unused__)); ~WritableIterator()
      {
          *i = v;
      }
  private:
      ValueType v;
      Iterator i;
  };

  template <
      typename Iterator
    , typename ValueType = typename std::iterator_traits<Iterator>::value_type
  >
  struct WritableIteratorConcept : WritableIterator<Iterator,ValueType> {};

  template < typename Iterator > struct SwappableIterator; template < typename Iterator > struct SwappableIteratorConcept : SwappableIterator< Iterator > { }; template < typename Iterator > struct SwappableIterator
  {
      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<SwappableIterator>)>::failed> boost_concept_check82 __attribute__((__unused__)); ~SwappableIterator()
      {
          std::iter_swap(i1, i2);
      }
  private:
      Iterator i1;
      Iterator i2;
  };

  template < typename Iterator > struct LvalueIterator; template < typename Iterator > struct LvalueIteratorConcept : LvalueIterator< Iterator > { }; template < typename Iterator > struct LvalueIterator
  {
      typedef typename std::iterator_traits<Iterator>::value_type value_type;

      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<LvalueIterator>)>::failed> boost_concept_check95 __attribute__((__unused__)); ~LvalueIterator()
      {
        value_type& r = const_cast<value_type&>(*i);
        boost::ignore_unused_variable_warning(r);
      }
  private:
      Iterator i;
  };





  template < typename Iterator > struct IncrementableIterator; template < typename Iterator > struct IncrementableIteratorConcept : IncrementableIterator< Iterator > { }; template < typename Iterator > struct IncrementableIterator
    : boost::Assignable<Iterator>
    , boost::CopyConstructible<Iterator>
  {
      typedef typename boost::iterator_traversal<Iterator>::type traversal_category;

      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( boost::Convertible< traversal_category , boost::incrementable_traversal_tag >)>::failed> boost_concept_check118 __attribute__((__unused__));





      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<IncrementableIterator>)>::failed> boost_concept_check120 __attribute__((__unused__)); ~IncrementableIterator()
      {
          ++i;
          (void)i++;
      }
  private:
      Iterator i;
  };

  template < typename Iterator > struct SinglePassIterator; template < typename Iterator > struct SinglePassIteratorConcept : SinglePassIterator< Iterator > { }; template < typename Iterator > struct SinglePassIterator
    : IncrementableIterator<Iterator>
    , boost::EqualityComparable<Iterator>

  {
      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( boost::Convertible< typename SinglePassIterator::traversal_category , boost::single_pass_traversal_tag > )>::failed> boost_concept_check138 __attribute__((__unused__));




  };

  template < typename Iterator > struct ForwardTraversal; template < typename Iterator > struct ForwardTraversalConcept : ForwardTraversal< Iterator > { }; template < typename Iterator > struct ForwardTraversal
    : SinglePassIterator<Iterator>
    , boost::DefaultConstructible<Iterator>
  {
      typedef typename std::iterator_traits<Iterator>::difference_type difference_type;

      static_assert(boost::is_integral<difference_type>::value, "boost::is_integral<difference_type>::value");
      static_assert(std::numeric_limits<difference_type>::is_signed, "std::numeric_limits<difference_type>::is_signed");

      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( boost::Convertible< typename ForwardTraversal::traversal_category , boost::forward_traversal_tag > )>::failed> boost_concept_check154 __attribute__((__unused__));




  };

  template < typename Iterator > struct BidirectionalTraversal; template < typename Iterator > struct BidirectionalTraversalConcept : BidirectionalTraversal< Iterator > { }; template < typename Iterator > struct BidirectionalTraversal
    : ForwardTraversal<Iterator>
  {
      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( boost::Convertible< typename BidirectionalTraversal::traversal_category , boost::bidirectional_traversal_tag > )>::failed> boost_concept_check164 __attribute__((__unused__));





      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<BidirectionalTraversal>)>::failed> boost_concept_check166 __attribute__((__unused__)); ~BidirectionalTraversal()
      {
          --i;
          (void)i--;
      }
   private:
      Iterator i;
  };

  template < typename Iterator > struct RandomAccessTraversal; template < typename Iterator > struct RandomAccessTraversalConcept : RandomAccessTraversal< Iterator > { }; template < typename Iterator > struct RandomAccessTraversal
    : BidirectionalTraversal<Iterator>
  {
      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( boost::Convertible< typename RandomAccessTraversal::traversal_category , boost::random_access_traversal_tag > )>::failed> boost_concept_check182 __attribute__((__unused__));





      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<RandomAccessTraversal>)>::failed> boost_concept_check184 __attribute__((__unused__)); ~RandomAccessTraversal()
      {
          i += n;
          i = i + n;
          i = n + i;
          i -= n;
          i = i - n;
          n = i - j;
      }

   private:
      typename BidirectionalTraversal<Iterator>::difference_type n;
      Iterator i, j;
  };




  namespace detail
  {
    template <typename Iterator1, typename Iterator2>
    void interop_single_pass_constraints(Iterator1 const& i1, Iterator2 const& i2)
    {
        bool b;
        b = i1 == i2;
        b = i1 != i2;

        b = i2 == i1;
        b = i2 != i1;
        boost::ignore_unused_variable_warning(b);
    }

    template <typename Iterator1, typename Iterator2>
    void interop_rand_access_constraints(
        Iterator1 const& i1, Iterator2 const& i2,
        boost::random_access_traversal_tag, boost::random_access_traversal_tag)
    {
        bool b;
        typename std::iterator_traits<Iterator2>::difference_type n;
        b = i1 < i2;
        b = i1 <= i2;
        b = i1 > i2;
        b = i1 >= i2;
        n = i1 - i2;

        b = i2 < i1;
        b = i2 <= i1;
        b = i2 > i1;
        b = i2 >= i1;
        n = i2 - i1;
        boost::ignore_unused_variable_warning(b);
        boost::ignore_unused_variable_warning(n);
    }

    template <typename Iterator1, typename Iterator2>
    void interop_rand_access_constraints(
        Iterator1 const&, Iterator2 const&,
        boost::single_pass_traversal_tag, boost::single_pass_traversal_tag)
    { }

  }

  template < typename Iterator , typename ConstIterator > struct InteroperableIterator; template < typename Iterator , typename ConstIterator > struct InteroperableIteratorConcept : InteroperableIterator< Iterator, ConstIterator > { }; template < typename Iterator , typename ConstIterator > struct InteroperableIterator
  {
   private:
      typedef typename boost::iterators::pure_iterator_traversal<Iterator>::type traversal_category;
      typedef typename boost::iterators::pure_iterator_traversal<ConstIterator>::type const_traversal_category;

   public:
      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(SinglePassIterator<Iterator>)>::failed> boost_concept_check253 __attribute__((__unused__));
      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(SinglePassIterator<ConstIterator>)>::failed> boost_concept_check254 __attribute__((__unused__));

      typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<InteroperableIterator>)>::failed> boost_concept_check256 __attribute__((__unused__)); ~InteroperableIterator()
      {
          detail::interop_single_pass_constraints(i, ci);
          detail::interop_rand_access_constraints(i, ci, traversal_category(), const_traversal_category());

          ci = i;
      }

   private:
      Iterator i;
      ConstIterator ci;
  };

}

# 1 "/usr/include/boost/concept/detail/concept_undef.hpp" 1 3 4
# 272 "/usr/include/boost/iterator/iterator_concepts.hpp" 2 3 4
# 21 "/usr/include/boost/range/concepts.hpp" 2 3 4



# 1 "/usr/include/boost/range/value_type.hpp" 1 3 4
# 23 "/usr/include/boost/range/value_type.hpp" 3 4
namespace boost
{
    template< class T >
    struct range_value : iterator_value< typename range_iterator<T>::type >
    { };
}
# 25 "/usr/include/boost/range/concepts.hpp" 2 3 4
# 1 "/usr/include/boost/range/detail/misc_concept.hpp" 1 3 4
# 13 "/usr/include/boost/range/detail/misc_concept.hpp" 3 4
namespace boost
{
    namespace range_detail
    {
        template<typename T1, typename T2>
        class SameTypeConcept
        {
        public:
            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<SameTypeConcept>)>::failed> boost_concept_check21 __attribute__((__unused__)); ~SameTypeConcept()
            {
                same_type(a,b);
            }
        private:
            template<typename T> void same_type(T,T) {}
            T1 a;
            T2 b;
        };
    }
}
# 26 "/usr/include/boost/range/concepts.hpp" 2 3 4
# 62 "/usr/include/boost/range/concepts.hpp" 3 4
namespace boost {

    namespace range_detail {
# 124 "/usr/include/boost/range/concepts.hpp" 3 4
        template<class Iterator>
        struct IncrementableIteratorConcept : CopyConstructible<Iterator>
        {

            typedef typename iterator_traversal<Iterator>::type traversal_category;

            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( Convertible< traversal_category, incrementable_traversal_tag >)>::failed> boost_concept_check134 __attribute__((__unused__));





            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<IncrementableIteratorConcept>)>::failed> boost_concept_check136 __attribute__((__unused__)); ~IncrementableIteratorConcept()
            {
                ++i;
                (void)i++;
            }
        private:
            Iterator i;

        };

        template<class Iterator>
        struct SinglePassIteratorConcept
            : IncrementableIteratorConcept<Iterator>
            , EqualityComparable<Iterator>
        {

            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( Convertible< typename SinglePassIteratorConcept::traversal_category, single_pass_traversal_tag >)>::failed> boost_concept_check156 __attribute__((__unused__));





            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<SinglePassIteratorConcept>)>::failed> boost_concept_check158 __attribute__((__unused__)); ~SinglePassIteratorConcept()
            {
                Iterator i2(++i);
                boost::ignore_unused_variable_warning(i2);





                (void)(i++);

                typename std::iterator_traits<Iterator>::reference r1(*i);
                boost::ignore_unused_variable_warning(r1);

                typename std::iterator_traits<Iterator>::reference r2(*(++i));
                boost::ignore_unused_variable_warning(r2);
            }
        private:
            Iterator i;

        };

        template<class Iterator>
        struct ForwardIteratorConcept
            : SinglePassIteratorConcept<Iterator>
            , DefaultConstructible<Iterator>
        {

            typedef typename std::iterator_traits<Iterator>::difference_type difference_type;

            enum { mpl_assertion_in_line_188 = sizeof( boost::mpl::assertion_failed<false>( boost::mpl::assert_arg( (void (*) (is_integral<difference_type>))nullptr, 1 ) ) ) };
            enum { mpl_assert_rel_value189 = (std::numeric_limits<difference_type>::is_signed == true) }; enum { mpl_assertion_in_line_189 = sizeof( boost::mpl::assertion_failed<mpl_assert_rel_value189>( (boost::mpl::failed ************ ( boost::mpl::assert_relation< boost::mpl::assert_::relations( sizeof( boost::mpl::assert_::arg == boost::mpl::assert_::arg ) ) , std::numeric_limits<difference_type>::is_signed , true >::************)) 0 ) ) };

            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( Convertible< typename ForwardIteratorConcept::traversal_category, forward_traversal_tag >)>::failed> boost_concept_check195 __attribute__((__unused__));





            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<ForwardIteratorConcept>)>::failed> boost_concept_check197 __attribute__((__unused__)); ~ForwardIteratorConcept()
            {




                Iterator i2(i++);
                boost::ignore_unused_variable_warning(i2);
                typename std::iterator_traits<Iterator>::reference r(*(i++));
                boost::ignore_unused_variable_warning(r);
            }
        private:
            Iterator i;

         };

         template<class Iterator>
         struct BidirectionalIteratorConcept
             : ForwardIteratorConcept<Iterator>
         {

             typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( Convertible< typename BidirectionalIteratorConcept::traversal_category, bidirectional_traversal_tag >)>::failed> boost_concept_check222 __attribute__((__unused__));





             typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<BidirectionalIteratorConcept>)>::failed> boost_concept_check224 __attribute__((__unused__)); ~BidirectionalIteratorConcept()
             {
                 --i;
                 (void)i--;
             }
         private:
             Iterator i;

         };

         template<class Iterator>
         struct RandomAccessIteratorConcept
             : BidirectionalIteratorConcept<Iterator>
         {

             typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( Convertible< typename RandomAccessIteratorConcept::traversal_category, random_access_traversal_tag >)>::failed> boost_concept_check243 __attribute__((__unused__));





             typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<RandomAccessIteratorConcept>)>::failed> boost_concept_check245 __attribute__((__unused__)); ~RandomAccessIteratorConcept()
             {
                 i += n;
                 i = i + n;
                 i = n + i;
                 i -= n;
                 i = i - n;
                 n = i - j;
             }
         private:
             typename BidirectionalIteratorConcept<Iterator>::difference_type n;
             Iterator i;
             Iterator j;

         };

    }


    template<class T>
    struct SinglePassRangeConcept
    {



        typedef typename remove_reference<T>::type Rng;

        typedef typename range_iterator<
            Rng const
        >::type const_iterator;

        typedef typename range_iterator<Rng>::type iterator;

        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( range_detail::SinglePassIteratorConcept<iterator>)>::failed> boost_concept_check279 __attribute__((__unused__));


        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( range_detail::SinglePassIteratorConcept<const_iterator>)>::failed> boost_concept_check282 __attribute__((__unused__));


        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<SinglePassRangeConcept>)>::failed> boost_concept_check284 __attribute__((__unused__)); ~SinglePassRangeConcept()
        {



            iterator i1 = boost::begin(*m_range);
            iterator i2 = boost::end(*m_range);

            boost::ignore_unused_variable_warning(i1);
            boost::ignore_unused_variable_warning(i2);

            const_constraints(*m_range);
        }

    private:
        void const_constraints(const Rng& const_range)
        {
            const_iterator ci1 = boost::begin(const_range);
            const_iterator ci2 = boost::end(const_range);

            boost::ignore_unused_variable_warning(ci1);
            boost::ignore_unused_variable_warning(ci2);
        }





       Rng* m_range;

    };


    template<class T>
    struct ForwardRangeConcept : SinglePassRangeConcept<T>
    {

        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(range_detail::ForwardIteratorConcept<typename ForwardRangeConcept::iterator>)>::failed> boost_concept_check321 __attribute__((__unused__));
        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(range_detail::ForwardIteratorConcept<typename ForwardRangeConcept::const_iterator>)>::failed> boost_concept_check322 __attribute__((__unused__));

    };

    template<class T>
    struct WriteableRangeConcept
    {

        typedef typename range_iterator<T>::type iterator;

        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::concepts::usage_requirements<WriteableRangeConcept>)>::failed> boost_concept_check332 __attribute__((__unused__)); ~WriteableRangeConcept()
        {
            *i = v;
        }
    private:
        iterator i;
        typename range_value<T>::type v;

    };


    template<class T>
    struct WriteableForwardRangeConcept
        : ForwardRangeConcept<T>
        , WriteableRangeConcept<T>
    {
    };


    template<class T>
    struct BidirectionalRangeConcept : ForwardRangeConcept<T>
    {

        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(range_detail::BidirectionalIteratorConcept<typename BidirectionalRangeConcept::iterator>)>::failed> boost_concept_check355 __attribute__((__unused__));
        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(range_detail::BidirectionalIteratorConcept<typename BidirectionalRangeConcept::const_iterator>)>::failed> boost_concept_check356 __attribute__((__unused__));

    };


    template<class T>
    struct WriteableBidirectionalRangeConcept
        : BidirectionalRangeConcept<T>
        , WriteableRangeConcept<T>
    {
    };


    template<class T>
    struct RandomAccessRangeConcept : BidirectionalRangeConcept<T>
    {

        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(range_detail::RandomAccessIteratorConcept<typename RandomAccessRangeConcept::iterator>)>::failed> boost_concept_check373 __attribute__((__unused__));
        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(range_detail::RandomAccessIteratorConcept<typename RandomAccessRangeConcept::const_iterator>)>::failed> boost_concept_check374 __attribute__((__unused__));

    };


    template<class T>
    struct WriteableRandomAccessRangeConcept
        : RandomAccessRangeConcept<T>
        , WriteableRangeConcept<T>
    {
    };

}
# 21 "/usr/include/boost/range/size_type.hpp" 2 3 4








namespace boost
{
    namespace detail
    {





        template<typename T>
        class has_size_type
        {
            typedef char no_type;
            struct yes_type { char dummy[2]; };

            template<typename C>
            static yes_type test(typename C::size_type x);

            template<typename C>
            static no_type test(...);

        public:
            static const bool value = sizeof(test<T>(0)) == sizeof(yes_type);
        };

        template<typename C, typename Enabler=void>
        struct range_size_
        {
            typedef typename make_unsigned<
                typename range_difference<C>::type
            >::type type;
        };

        template<typename C>
        struct range_size_<
            C,
            typename ::boost::enable_if<has_size_type<C>, void>::type
        >
        {
            typedef typename C::size_type type;
        };

        template<typename C, bool B = range_detail::has_type< range_iterator<C> >::value>
        struct range_size
        { };

        template<typename C>
        struct range_size<C, true>
          : range_size_<C>
        { };
    }

    template< class T >
    struct range_size :
        detail::range_size<T>
    { };

}
# 22 "/usr/include/boost/range/size.hpp" 2 3 4
# 1 "/usr/include/boost/range/detail/has_member_size.hpp" 1 3 4
# 18 "/usr/include/boost/range/detail/has_member_size.hpp" 3 4
# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 19 "/usr/include/boost/range/detail/has_member_size.hpp" 2 3 4

namespace boost
{
    namespace range_detail
    {

template<class T>
class has_member_size_impl
{
private:
    template<class U, U>
    class check
    {
    };

    template<class C>
    static boost::uint8_t f(check<std::size_t(C::*)(void) const, &C::size>*);

    template<class C>
    static boost::uint16_t f(...);

public:
    static const bool value =
        (sizeof(f<T>(0)) == sizeof(boost::uint8_t));

    typedef typename mpl::if_c<
        (sizeof(f<T>(0)) == sizeof(boost::uint8_t)),
        mpl::true_,
        mpl::false_
    >::type type;
};

template<class T>
struct has_member_size
{
    typedef typename mpl::and_<
        typename is_class<T>::type,
        typename has_member_size_impl<const T>::type
    >::type type;

    static const bool value =
        is_class<T>::value && has_member_size_impl<const T>::value;
};

    }
}
# 23 "/usr/include/boost/range/size.hpp" 2 3 4
# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 58 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 59 "/usr/include/boost/assert.hpp" 2 3 4
# 24 "/usr/include/boost/range/size.hpp" 2 3 4
# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 25 "/usr/include/boost/range/size.hpp" 2 3 4


namespace boost
{
    namespace range_detail
    {

        template<class SinglePassRange>
        inline typename ::boost::enable_if<
            has_member_size<SinglePassRange>,
            typename range_size<const SinglePassRange>::type
        >::type
        range_calculate_size(const SinglePassRange& rng)
        {
            return rng.size();
        }

        template<class SinglePassRange>
        inline typename disable_if<
            has_member_size<SinglePassRange>,
            typename range_size<const SinglePassRange>::type
        >::type
        range_calculate_size(const SinglePassRange& rng)
        {
            return std::distance(boost::begin(rng), boost::end(rng));
        }
    }

    template<class SinglePassRange>
    inline typename range_size<const SinglePassRange>::type
    size(const SinglePassRange& rng)
    {





        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(boost::SinglePassRangeConcept<SinglePassRange>)>::failed> boost_concept_check62 __attribute__((__unused__));





        using namespace range_detail;


        return range_calculate_size(rng);
    }

}
# 21 "/usr/include/boost/range/functions.hpp" 2 3 4
# 1 "/usr/include/boost/range/distance.hpp" 1 3 4
# 18 "/usr/include/boost/range/distance.hpp" 3 4
# 1 "/usr/include/boost/iterator/distance.hpp" 1 3 4
# 14 "/usr/include/boost/iterator/distance.hpp" 3 4
namespace boost {
namespace iterators {

    namespace detail {
        template <typename SinglePassIterator>
        inline constexpr typename iterator_difference<SinglePassIterator>::type
        distance_impl(
            SinglePassIterator first
          , SinglePassIterator last
          , single_pass_traversal_tag
        )
        {
            typename iterator_difference<SinglePassIterator>::type n = 0;
            while (first != last) {
                ++first;
                ++n;
            }
            return n;
        }

        template <typename RandomAccessIterator>
        inline constexpr typename iterator_difference<RandomAccessIterator>::type
        distance_impl(
            RandomAccessIterator first
          , RandomAccessIterator last
          , random_access_traversal_tag
        )
        {
            return last - first;
        }
    }

    namespace distance_adl_barrier {
        template <typename SinglePassIterator>
        inline constexpr typename iterator_difference<SinglePassIterator>::type
        distance(SinglePassIterator first, SinglePassIterator last)
        {
            return detail::distance_impl(
                first, last, typename iterator_traversal<SinglePassIterator>::type()
            );
        }
    }

    using namespace distance_adl_barrier;

}

using namespace iterators::distance_adl_barrier;

}
# 19 "/usr/include/boost/range/distance.hpp" 2 3 4




namespace boost
{

    namespace range_distance_adl_barrier
    {
        template< class T >
        inline constexpr typename range_difference<T>::type
        distance( const T& r )
        {
            return boost::iterators::distance( boost::begin( r ), boost::end( r ) );
        }
    }

    using namespace range_distance_adl_barrier;

}
# 22 "/usr/include/boost/range/functions.hpp" 2 3 4
# 1 "/usr/include/boost/range/empty.hpp" 1 3 4
# 22 "/usr/include/boost/range/empty.hpp" 3 4
namespace boost
{

    template< class T >
    inline bool empty( const T& r )
    {
        return boost::begin( r ) == boost::end( r );
    }

}
# 23 "/usr/include/boost/range/functions.hpp" 2 3 4
# 1 "/usr/include/boost/range/rbegin.hpp" 1 3 4
# 19 "/usr/include/boost/range/rbegin.hpp" 3 4
# 1 "/usr/include/boost/range/reverse_iterator.hpp" 1 3 4
# 24 "/usr/include/boost/range/reverse_iterator.hpp" 3 4
namespace boost
{




    template< typename T >
    struct range_reverse_iterator
    {
        typedef reverse_iterator<
            typename range_iterator<
                typename remove_reference<T>::type>::type > type;
    };


}
# 20 "/usr/include/boost/range/rbegin.hpp" 2 3 4

namespace boost
{

template< class C >
inline typename range_reverse_iterator<C>::type
rbegin( C& c )
{
    typedef typename range_reverse_iterator<C>::type
        iter_type;
    return iter_type( boost::end( c ) );
}

template< class C >
inline typename range_reverse_iterator<const C>::type
rbegin( const C& c )
{
    typedef typename range_reverse_iterator<const C>::type
        iter_type;
    return iter_type( boost::end( c ) );
}

template< class T >
inline typename range_reverse_iterator<const T>::type
const_rbegin( const T& r )
{
    return boost::rbegin( r );
}

}
# 24 "/usr/include/boost/range/functions.hpp" 2 3 4
# 1 "/usr/include/boost/range/rend.hpp" 1 3 4
# 21 "/usr/include/boost/range/rend.hpp" 3 4
namespace boost
{

template< class C >
inline typename range_reverse_iterator<C>::type
rend( C& c )
{
    typedef typename range_reverse_iterator<C>::type
               iter_type;
    return iter_type( boost::begin( c ) );
}

template< class C >
inline typename range_reverse_iterator<const C>::type
rend( const C& c )
{
    typedef typename range_reverse_iterator<const C>::type
        iter_type;
    return iter_type( boost::begin( c ) );
}

template< class T >
inline typename range_reverse_iterator<const T>::type
const_rend( const T& r )
{
    return boost::rend( r );
}

}
# 25 "/usr/include/boost/range/functions.hpp" 2 3 4
# 39 "/usr/include/boost/range/iterator_range_core.hpp" 2 3 4



# 1 "/usr/include/boost/range/algorithm/equal.hpp" 1 3 4
# 17 "/usr/include/boost/range/algorithm/equal.hpp" 3 4
namespace boost
{
    namespace range_detail
    {


        template< class SinglePassTraversalReadableIterator1,
                  class SinglePassTraversalReadableIterator2,
                  class IteratorCategoryTag1,
                  class IteratorCategoryTag2 >
        inline bool equal_impl( SinglePassTraversalReadableIterator1 first1,
                                SinglePassTraversalReadableIterator1 last1,
                                SinglePassTraversalReadableIterator2 first2,
                                SinglePassTraversalReadableIterator2 last2,
                                IteratorCategoryTag1,
                                IteratorCategoryTag2 )
        {
            for (;;)
            {



                if (first1 == last1)
                    return first2 == last2;




                if (first2 == last2)
                    return false;


                if (*first1 != *first2)
                    break;

                ++first1;
                ++first2;
            }



            return false;
        }

        template< class SinglePassTraversalReadableIterator1,
                  class SinglePassTraversalReadableIterator2,
                  class IteratorCategoryTag1,
                  class IteratorCategoryTag2,
                  class BinaryPredicate >
        inline bool equal_impl( SinglePassTraversalReadableIterator1 first1,
                                SinglePassTraversalReadableIterator1 last1,
                                SinglePassTraversalReadableIterator2 first2,
                                SinglePassTraversalReadableIterator2 last2,
                                BinaryPredicate pred,
                                IteratorCategoryTag1,
                                IteratorCategoryTag2 )
        {
            for (;;)
            {



                if (first1 == last1)
                    return first2 == last2;




                if (first2 == last2)
                    return false;


                if (!pred(*first1, *first2))
                    break;

                ++first1;
                ++first2;
            }



            return false;
        }



        template< class RandomAccessTraversalReadableIterator1,
                  class RandomAccessTraversalReadableIterator2 >
        inline bool equal_impl( RandomAccessTraversalReadableIterator1 first1,
                                RandomAccessTraversalReadableIterator1 last1,
                                RandomAccessTraversalReadableIterator2 first2,
                                RandomAccessTraversalReadableIterator2 last2,
                                std::random_access_iterator_tag,
                                std::random_access_iterator_tag )
        {
            return ((last1 - first1) == (last2 - first2))
                && std::equal(first1, last1, first2);
        }

        template< class RandomAccessTraversalReadableIterator1,
                  class RandomAccessTraversalReadableIterator2,
                  class BinaryPredicate >
        inline bool equal_impl( RandomAccessTraversalReadableIterator1 first1,
                                RandomAccessTraversalReadableIterator1 last1,
                                RandomAccessTraversalReadableIterator2 first2,
                                RandomAccessTraversalReadableIterator2 last2,
                                BinaryPredicate pred,
                                std::random_access_iterator_tag,
                                std::random_access_iterator_tag )
        {
            return ((last1 - first1) == (last2 - first2))
                && std::equal(first1, last1, first2, pred);
        }

        template< class SinglePassTraversalReadableIterator1,
                  class SinglePassTraversalReadableIterator2 >
        inline bool equal( SinglePassTraversalReadableIterator1 first1,
                           SinglePassTraversalReadableIterator1 last1,
                           SinglePassTraversalReadableIterator2 first2,
                           SinglePassTraversalReadableIterator2 last2 )
        {
            typename std::iterator_traits< SinglePassTraversalReadableIterator1 >::iterator_category tag1;
            typename std::iterator_traits< SinglePassTraversalReadableIterator2 >::iterator_category tag2;

            return equal_impl(first1, last1, first2, last2, tag1, tag2);
        }

        template< class SinglePassTraversalReadableIterator1,
                  class SinglePassTraversalReadableIterator2,
                  class BinaryPredicate >
        inline bool equal( SinglePassTraversalReadableIterator1 first1,
                           SinglePassTraversalReadableIterator1 last1,
                           SinglePassTraversalReadableIterator2 first2,
                           SinglePassTraversalReadableIterator2 last2,
                           BinaryPredicate pred )
        {
            typename std::iterator_traits< SinglePassTraversalReadableIterator1 >::iterator_category tag1;
            typename std::iterator_traits< SinglePassTraversalReadableIterator2 >::iterator_category tag2;

            return equal_impl(first1, last1, first2, last2, pred, tag1, tag2);
        }

    }

    namespace range
    {
# 171 "/usr/include/boost/range/algorithm/equal.hpp" 3 4
        template< class SinglePassRange1, class SinglePassRange2 >
        inline bool equal( const SinglePassRange1& rng1, const SinglePassRange2& rng2 )
        {
            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( SinglePassRangeConcept<const SinglePassRange1> )>::failed> boost_concept_check174 __attribute__((__unused__));
            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( SinglePassRangeConcept<const SinglePassRange2> )>::failed> boost_concept_check175 __attribute__((__unused__));

            return ::boost::range_detail::equal(
                ::boost::begin(rng1), ::boost::end(rng1),
                ::boost::begin(rng2), ::boost::end(rng2) );
        }


        template< class SinglePassRange1, class SinglePassRange2, class BinaryPredicate >
        inline bool equal( const SinglePassRange1& rng1, const SinglePassRange2& rng2,
                           BinaryPredicate pred )
        {
            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( SinglePassRangeConcept<const SinglePassRange1> )>::failed> boost_concept_check187 __attribute__((__unused__));
            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( SinglePassRangeConcept<const SinglePassRange2> )>::failed> boost_concept_check188 __attribute__((__unused__));

            return ::boost::range_detail::equal(
                ::boost::begin(rng1), ::boost::end(rng1),
                ::boost::begin(rng2), ::boost::end(rng2),
                pred);
        }

    }
    using ::boost::range::equal;
}
# 43 "/usr/include/boost/range/iterator_range_core.hpp" 2 3 4
# 1 "/usr/include/boost/range/detail/safe_bool.hpp" 1 3 4
# 16 "/usr/include/boost/range/detail/safe_bool.hpp" 3 4
namespace boost
{
    namespace range_detail
    {

template<class DataMemberPtr>
class safe_bool
{
public:
    typedef safe_bool this_type;
# 56 "/usr/include/boost/range/detail/safe_bool.hpp" 3 4
    typedef DataMemberPtr unspecified_bool_type;
    static unspecified_bool_type to_unspecified_bool(const bool x, DataMemberPtr p)
    {
        return x ? p : 0;
    }

private:
    safe_bool();
    safe_bool(const safe_bool&);
    void operator=(const safe_bool&);
    ~safe_bool();
};

    }
}
# 44 "/usr/include/boost/range/iterator_range_core.hpp" 2 3 4
# 57 "/usr/include/boost/range/iterator_range_core.hpp" 3 4
namespace boost
{
    namespace iterator_range_detail
    {




        template<class IteratorT>
        struct iterator_range_impl {
            template< class ForwardRange >
            static IteratorT adl_begin( ForwardRange& r )
            {
                return IteratorT( boost::begin( r ) );
            }

            template< class ForwardRange >
            static IteratorT adl_end( ForwardRange& r )
            {
                return IteratorT( boost::end( r ) );
            }
        };

        template< class Left, class Right >
        inline bool less_than( const Left& l, const Right& r )
        {
            return std::lexicographical_compare( boost::begin(l),
                                                 boost::end(l),
                                                 boost::begin(r),
                                                 boost::end(r) );
        }

        template< class Left, class Right >
        inline bool greater_than( const Left& l, const Right& r )
        {
            return iterator_range_detail::less_than(r,l);
        }

        template< class Left, class Right >
        inline bool less_or_equal_than( const Left& l, const Right& r )
        {
            return !iterator_range_detail::less_than(r,l);
        }

        template< class Left, class Right >
        inline bool greater_or_equal_than( const Left& l, const Right& r )
        {
            return !iterator_range_detail::less_than(l,r);
        }



        template< class Left, class Right >
        inline bool equal(const Left& l, const Right& r)
        {
            return boost::equal(l, r);
        }

struct range_tag
{
};

struct const_range_tag
{
};

struct iterator_range_tag
{
};

typedef char (&incrementable_t)[1];
typedef char (&bidirectional_t)[2];
typedef char (&random_access_t)[3];

incrementable_t test_traversal_tag(boost::incrementable_traversal_tag);
bidirectional_t test_traversal_tag(boost::bidirectional_traversal_tag);
random_access_t test_traversal_tag(boost::random_access_traversal_tag);

template<std::size_t S>
struct pure_iterator_traversal_impl
{
    typedef boost::incrementable_traversal_tag type;
};

template<>
struct pure_iterator_traversal_impl<sizeof(bidirectional_t)>
{
    typedef boost::bidirectional_traversal_tag type;
};

template<>
struct pure_iterator_traversal_impl<sizeof(random_access_t)>
{
    typedef boost::random_access_traversal_tag type;
};

template<typename IteratorT>
struct pure_iterator_traversal
{
    typedef
        typename iterator_traversal<IteratorT>::type
    traversal_t;
    static const std::size_t traversal_i = sizeof(iterator_range_detail::test_traversal_tag((traversal_t())));



    typedef
        typename pure_iterator_traversal_impl<traversal_i>::type
    type;
};

template<class IteratorT, class TraversalTag>
class iterator_range_base
    : public iterator_range_tag
{
    typedef range_detail::safe_bool<
                IteratorT iterator_range_base<IteratorT, TraversalTag>::*
    > safe_bool_t;

    typedef iterator_range_base<IteratorT, TraversalTag> type;

protected:
    typedef iterator_range_impl<IteratorT> impl;

public:
    typedef typename
        safe_bool_t::unspecified_bool_type unspecified_bool_type;

    typedef typename
        iterator_value<IteratorT>::type value_type;

    typedef typename
        iterator_difference<IteratorT>::type difference_type;

    typedef std::size_t size_type;



    typedef typename
                iterator_reference<IteratorT>::type reference;






    typedef IteratorT const_iterator;

    typedef IteratorT iterator;

protected:
    iterator_range_base()
        : m_Begin()
        , m_End()
    {
    }

    template<class Iterator>
    iterator_range_base(Iterator Begin, Iterator End)
        : m_Begin(Begin)
        , m_End(End)
    {
    }

public:
    IteratorT begin() const
    {
        return m_Begin;
    }

    IteratorT end() const
    {
        return m_End;
    }

    bool empty() const
    {
        return m_Begin == m_End;
    }

    operator unspecified_bool_type() const
    {
        return safe_bool_t::to_unspecified_bool(
                    m_Begin != m_End, &iterator_range_base::m_Begin);
    }

    bool operator!() const
    {
        return empty();
    }

    bool equal(const iterator_range_base& r) const
    {
        return m_Begin == r.m_Begin && m_End == r.m_End;
    }

   reference front() const
   {
       (static_cast <bool> (!empty()) ? void (0) : __assert_fail ("!empty()", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
       return *m_Begin;
   }

   void drop_front()
   {
       (static_cast <bool> (!empty()) ? void (0) : __assert_fail ("!empty()", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
       ++m_Begin;
   }

   void drop_front(difference_type n)
   {
       (static_cast <bool> (n >= difference_type()) ? void (0) : __assert_fail ("n >= difference_type()", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
       std::advance(this->m_Begin, n);
   }


   void pop_front() { drop_front(); }

protected:
    template<class Iterator>
    void assign(Iterator first, Iterator last)
    {
        m_Begin = first;
        m_End = last;
    }

    template<class SinglePassRange>
    void assign(const SinglePassRange& r)
    {
        m_Begin = impl::adl_begin(r);
        m_End = impl::adl_end(r);
    }

    template<class SinglePassRange>
    void assign(SinglePassRange& r)
    {
        m_Begin = impl::adl_begin(r);
        m_End = impl::adl_end(r);
    }

    IteratorT m_Begin;
    IteratorT m_End;
};

template<class IteratorT>
class iterator_range_base<IteratorT, bidirectional_traversal_tag>
        : public iterator_range_base<IteratorT, incrementable_traversal_tag>
{
    typedef iterator_range_base<IteratorT, incrementable_traversal_tag> base_type;

protected:
    iterator_range_base()
    {
    }

    template<class Iterator>
    iterator_range_base(Iterator first, Iterator last)
        : base_type(first, last)
    {
    }

public:
    typedef typename base_type::difference_type difference_type;
    typedef typename base_type::reference reference;

    reference back() const
    {
        (static_cast <bool> (!this->empty()) ? void (0) : __assert_fail ("!this->empty()", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        return *boost::prior(this->m_End);
    }

    void drop_back()
    {
        (static_cast <bool> (!this->empty()) ? void (0) : __assert_fail ("!this->empty()", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        --this->m_End;
    }

    void drop_back(difference_type n)
    {
        (static_cast <bool> (n >= difference_type()) ? void (0) : __assert_fail ("n >= difference_type()", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        std::advance(this->m_End, -n);
    }


    void pop_back() { drop_back(); }
};

template<class IteratorT>
class iterator_range_base<IteratorT, random_access_traversal_tag>
        : public iterator_range_base<IteratorT, bidirectional_traversal_tag>
{
    typedef iterator_range_base<
                IteratorT, bidirectional_traversal_tag> base_type;

public:
    typedef typename
        boost::mpl::if_<
            boost::mpl::or_<
                boost::is_abstract<
                    typename base_type::value_type
                >,
                boost::is_array<
                    typename base_type::value_type
                >,
                boost::is_function<
                    typename base_type::value_type
                >
            >,
            typename base_type::reference,
            typename base_type::value_type
        >::type abstract_value_type;




    typedef typename base_type::difference_type difference_type;
    typedef typename base_type::size_type size_type;
    typedef typename base_type::reference reference;

protected:
    iterator_range_base()
    {
    }

    template<class Iterator>
    iterator_range_base(Iterator first, Iterator last)
        : base_type(first, last)
    {
    }

public:
    reference operator[](difference_type at) const
    {
        (static_cast <bool> (at >= 0) ? void (0) : __assert_fail ("at >= 0", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        (static_cast <bool> (static_cast<typename base_type::size_type>(at) < size()) ? void (0) : __assert_fail ("static_cast<typename base_type::size_type>(at) < size()", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        return this->m_Begin[at];
    }






    abstract_value_type operator()(difference_type at) const
    {
        (static_cast <bool> (at >= 0) ? void (0) : __assert_fail ("at >= 0", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        (static_cast <bool> (static_cast<typename base_type::size_type>(at) < size()) ? void (0) : __assert_fail ("static_cast<typename base_type::size_type>(at) < size()", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        return this->m_Begin[at];
    }

    typename base_type::size_type size() const
    {
        return this->m_End - this->m_Begin;
    }
};

    }
# 433 "/usr/include/boost/range/iterator_range_core.hpp" 3 4
        template<class IteratorT>
        class iterator_range
            : public iterator_range_detail::iterator_range_base<
                    IteratorT,
                    typename iterator_range_detail::pure_iterator_traversal<IteratorT>::type
                >
        {
            typedef iterator_range_detail::iterator_range_base<
                    IteratorT,
                    typename iterator_range_detail::pure_iterator_traversal<IteratorT>::type
            > base_type;

            template<class Source>
            struct is_compatible_range_
              : is_convertible<
                    typename mpl::eval_if<
                        has_range_iterator<Source>,
                        range_iterator<Source>,
                        mpl::identity<void>
                    >::type,
                    typename base_type::iterator
                >
            {
            };

            template<class Source>
            struct is_compatible_range
                : mpl::and_<
                    mpl::not_<
                        is_convertible<
                            Source,
                            typename base_type::iterator
                        >
                    >,
                    is_compatible_range_<Source>
                >
            {
            };

        protected:
            typedef iterator_range_detail::iterator_range_impl<IteratorT> impl;

        public:
            typedef iterator_range<IteratorT> type;

            iterator_range()
            {
            }

            template<class Iterator>
            iterator_range(Iterator first, Iterator last)
                : base_type(first, last)
            {
            }

            template<class SinglePassRange>
            iterator_range(
                const SinglePassRange& r,
                typename ::boost::enable_if<
                    is_compatible_range<const SinglePassRange>
                >::type* = 0
            )
                : base_type(impl::adl_begin(r), impl::adl_end(r))
            {
            }

            template<class SinglePassRange>
            iterator_range(
                SinglePassRange& r,
                typename ::boost::enable_if<
                    is_compatible_range<SinglePassRange>
                >::type* = 0
            )
                : base_type(impl::adl_begin(r), impl::adl_end(r))
            {
            }

            template<class SinglePassRange>
            iterator_range(const SinglePassRange& r,
                           iterator_range_detail::const_range_tag)
                : base_type(impl::adl_begin(r), impl::adl_end(r))
            {
            }

            template<class SinglePassRange>
            iterator_range(SinglePassRange& r,
                           iterator_range_detail::range_tag)
                : base_type(impl::adl_begin(r), impl::adl_end(r))
            {
            }

            template<class Iterator>
            iterator_range& operator=(const iterator_range<Iterator>& other)
            {
                this->assign(other.begin(), other.end());
                return *this;
            }

            template<class Iterator>
            iterator_range& operator=(iterator_range<Iterator>& other)
            {
                this->assign(other.begin(), other.end());
                return *this;
            }

            template<class SinglePassRange>
            iterator_range& operator=(SinglePassRange& r)
            {
                this->assign(r);
                return *this;
            }

            template<class SinglePassRange>
            iterator_range& operator=(const SinglePassRange& r)
            {
                this->assign(r);
                return *this;
            }

            iterator_range& advance_begin(
                typename base_type::difference_type n)
            {
                std::advance(this->m_Begin, n);
                return *this;
            }

            iterator_range& advance_end(
                typename base_type::difference_type n)
            {
                std::advance(this->m_End, n);
                return *this;
            }

        protected:




            typedef iterator_range iterator_range_;
        };







        template< class IteratorT, class ForwardRange >
        inline typename boost::enable_if<
            mpl::not_<is_base_and_derived<iterator_range_detail::iterator_range_tag, ForwardRange> >,
            bool
        >::type
        operator==( const ForwardRange& l, const iterator_range<IteratorT>& r )
        {
            return boost::equal( l, r );
        }

        template< class IteratorT, class ForwardRange >
        inline typename boost::enable_if<
            mpl::not_<boost::is_base_and_derived<iterator_range_detail::iterator_range_tag, ForwardRange> >,
            bool
        >::type
        operator!=( const ForwardRange& l, const iterator_range<IteratorT>& r )
        {
            return !boost::equal( l, r );
        }

        template< class IteratorT, class ForwardRange >
        inline typename boost::enable_if<
            mpl::not_<boost::is_base_and_derived<iterator_range_detail::iterator_range_tag, ForwardRange> >,
            bool
        >::type
        operator<( const ForwardRange& l, const iterator_range<IteratorT>& r )
        {
            return iterator_range_detail::less_than( l, r );
        }

        template< class IteratorT, class ForwardRange >
        inline typename boost::enable_if<
            mpl::not_<boost::is_base_and_derived<iterator_range_detail::iterator_range_tag, ForwardRange> >,
            bool
        >::type
        operator<=( const ForwardRange& l, const iterator_range<IteratorT>& r )
        {
            return iterator_range_detail::less_or_equal_than( l, r );
        }

        template< class IteratorT, class ForwardRange >
        inline typename boost::enable_if<
            mpl::not_<boost::is_base_and_derived<iterator_range_detail::iterator_range_tag, ForwardRange> >,
            bool
        >::type
        operator>( const ForwardRange& l, const iterator_range<IteratorT>& r )
        {
            return iterator_range_detail::greater_than( l, r );
        }

        template< class IteratorT, class ForwardRange >
        inline typename boost::enable_if<
            mpl::not_<boost::is_base_and_derived<iterator_range_detail::iterator_range_tag, ForwardRange> >,
            bool
        >::type
        operator>=( const ForwardRange& l, const iterator_range<IteratorT>& r )
        {
            return iterator_range_detail::greater_or_equal_than( l, r );
        }

        template< class Iterator1T, class Iterator2T >
        inline bool
        operator==( const iterator_range<Iterator1T>& l, const iterator_range<Iterator2T>& r )
        {
            return boost::equal( l, r );
        }

        template< class IteratorT, class ForwardRange >
        inline typename boost::enable_if<
            mpl::not_<boost::is_base_and_derived<iterator_range_detail::iterator_range_tag, ForwardRange> >,
            bool
        >::type
        operator==( const iterator_range<IteratorT>& l, const ForwardRange& r )
        {
            return boost::equal( l, r );
        }


        template< class Iterator1T, class Iterator2T >
        inline bool
        operator!=( const iterator_range<Iterator1T>& l, const iterator_range<Iterator2T>& r )
        {
            return !boost::equal( l, r );
        }

        template< class IteratorT, class ForwardRange >
        inline typename boost::enable_if<
            mpl::not_<boost::is_base_and_derived<iterator_range_detail::iterator_range_tag, ForwardRange> >,
            bool
        >::type
        operator!=( const iterator_range<IteratorT>& l, const ForwardRange& r )
        {
            return !boost::equal( l, r );
        }


        template< class Iterator1T, class Iterator2T >
        inline bool
        operator<( const iterator_range<Iterator1T>& l, const iterator_range<Iterator2T>& r )
        {
            return iterator_range_detail::less_than( l, r );
        }

        template< class IteratorT, class ForwardRange >
        inline typename boost::enable_if<
            mpl::not_<boost::is_base_and_derived<iterator_range_detail::iterator_range_tag, ForwardRange> >,
            bool
        >::type
        operator<( const iterator_range<IteratorT>& l, const ForwardRange& r )
        {
            return iterator_range_detail::less_than( l, r );
        }

        template< class Iterator1T, class Iterator2T >
        inline bool
        operator<=( const iterator_range<Iterator1T>& l, const iterator_range<Iterator2T>& r )
        {
            return iterator_range_detail::less_or_equal_than( l, r );
        }

        template< class IteratorT, class ForwardRange >
        inline typename boost::enable_if<
            mpl::not_<boost::is_base_and_derived<iterator_range_detail::iterator_range_tag, ForwardRange> >,
            bool
        >::type
        operator<=( const iterator_range<IteratorT>& l, const ForwardRange& r )
        {
            return iterator_range_detail::less_or_equal_than( l, r );
        }

        template< class Iterator1T, class Iterator2T >
        inline bool
        operator>( const iterator_range<Iterator1T>& l, const iterator_range<Iterator2T>& r )
        {
            return iterator_range_detail::greater_than( l, r );
        }

        template< class IteratorT, class ForwardRange >
        inline typename boost::enable_if<
            mpl::not_<boost::is_base_and_derived<iterator_range_detail::iterator_range_tag, ForwardRange> >,
            bool
        >::type
        operator>( const iterator_range<IteratorT>& l, const ForwardRange& r )
        {
            return iterator_range_detail::greater_than( l, r );
        }

        template< class Iterator1T, class Iterator2T >
        inline bool
        operator>=( const iterator_range<Iterator1T>& l, const iterator_range<Iterator2T>& r )
        {
            return iterator_range_detail::greater_or_equal_than( l, r );
        }

        template< class IteratorT, class ForwardRange >
        inline typename boost::enable_if<
            mpl::not_<boost::is_base_and_derived<iterator_range_detail::iterator_range_tag, ForwardRange> >,
            bool
        >::type
        operator>=( const iterator_range<IteratorT>& l, const ForwardRange& r )
        {
            return iterator_range_detail::greater_or_equal_than( l, r );
        }
# 754 "/usr/include/boost/range/iterator_range_core.hpp" 3 4
        template< typename IteratorT >
        inline iterator_range< IteratorT >
        make_iterator_range( IteratorT Begin, IteratorT End )
        {
            return iterator_range<IteratorT>( Begin, End );
        }

        template<typename IteratorT, typename IntegerT>
        inline iterator_range<IteratorT>
        make_iterator_range_n(IteratorT first, IntegerT n)
        {
            return iterator_range<IteratorT>(first, boost::next(first, n));
        }






        template< class ForwardRange >
        inline iterator_range< typename range_iterator<ForwardRange>::type >
        make_iterator_range( ForwardRange& r )
        {
           return iterator_range< typename range_iterator<ForwardRange>::type >
                ( r, iterator_range_detail::range_tag() );
        }

        template< class ForwardRange >
        inline iterator_range< typename range_iterator<const ForwardRange>::type >
        make_iterator_range( const ForwardRange& r )
        {
           return iterator_range< typename range_iterator<const ForwardRange>::type >
                ( r, iterator_range_detail::const_range_tag() );
        }

        namespace iterator_range_detail
        {
            template< class Range >
            inline iterator_range< typename range_iterator<Range>::type >
            make_range_impl( Range& r,
                             typename range_difference<Range>::type advance_begin,
                             typename range_difference<Range>::type advance_end )
            {







                typename range_iterator<Range>::type
                    new_begin = boost::begin( r ),
                    new_end = boost::end( r );
                std::advance( new_begin, advance_begin );
                std::advance( new_end, advance_end );
                return make_iterator_range( new_begin, new_end );
            }
        }

        template< class Range >
        inline iterator_range< typename range_iterator<Range>::type >
        make_iterator_range( Range& r,
                    typename range_difference<Range>::type advance_begin,
                    typename range_difference<Range>::type advance_end )
        {
            return iterator_range_detail::make_range_impl( r, advance_begin, advance_end );
        }

        template< class Range >
        inline iterator_range< typename range_iterator<const Range>::type >
        make_iterator_range( const Range& r,
                    typename range_difference<Range>::type advance_begin,
                    typename range_difference<Range>::type advance_end )
        {
            return iterator_range_detail::make_range_impl( r, advance_begin, advance_end );
        }
# 839 "/usr/include/boost/range/iterator_range_core.hpp" 3 4
        template< typename SeqT, typename Range >
        inline SeqT copy_range( const Range& r )
        {
            return SeqT( boost::begin( r ), boost::end( r ) );
        }

}
# 14 "/usr/include/boost/range/iterator_range.hpp" 2 3 4
# 1 "/usr/include/boost/range/iterator_range_io.hpp" 1 3 4
# 43 "/usr/include/boost/range/iterator_range_io.hpp" 3 4
namespace boost
{
# 54 "/usr/include/boost/range/iterator_range_io.hpp" 3 4
        template< typename IteratorT, typename Elem, typename Traits >
        inline std::basic_ostream<Elem,Traits>& operator<<(
                    std::basic_ostream<Elem, Traits>& Os,
                    const iterator_range<IteratorT>& r )
        {
            std::copy( r.begin(), r.end(),
                       std::ostream_iterator< typename
                                              iterator_value<IteratorT>::type,
                                              Elem, Traits>(Os) );
            return Os;
        }
# 85 "/usr/include/boost/range/iterator_range_io.hpp" 3 4
}
# 15 "/usr/include/boost/range/iterator_range.hpp" 2 3 4
# 17 "/usr/include/boost/range/irange.hpp" 2 3 4

namespace boost
{
    namespace range_detail
    {
# 33 "/usr/include/boost/range/irange.hpp" 3 4
        template<typename Integer>
        class integer_iterator
            : public boost::iterator_facade<
                        integer_iterator<Integer>,
                        Integer,
                        boost::random_access_traversal_tag,
                        Integer,
                        std::ptrdiff_t
                    >
        {
            typedef boost::iterator_facade<
                        integer_iterator<Integer>,
                        Integer,
                        boost::random_access_traversal_tag,
                        Integer,
                        std::ptrdiff_t
                    > base_t;
        public:
            typedef typename base_t::value_type value_type;
            typedef typename base_t::difference_type difference_type;
            typedef typename base_t::reference reference;
            typedef std::random_access_iterator_tag iterator_category;

            integer_iterator() : m_value() {}
            explicit integer_iterator(value_type x) : m_value(x) {}

        private:
            void increment()
            {
                ++m_value;
            }

            void decrement()
            {
                --m_value;
            }

            void advance(difference_type offset)
            {
                m_value += offset;
            }

            difference_type distance_to(const integer_iterator& other) const
            {
                return is_signed<value_type>::value
                    ? (other.m_value - m_value)
                    : (other.m_value >= m_value)
                        ? static_cast<difference_type>(other.m_value - m_value)
                        : -static_cast<difference_type>(m_value - other.m_value);
            }

            bool equal(const integer_iterator& other) const
            {
                return m_value == other.m_value;
            }

            reference dereference() const
            {
                return m_value;
            }

            friend class ::boost::iterator_core_access;
            value_type m_value;
        };
# 110 "/usr/include/boost/range/irange.hpp" 3 4
        template<typename Integer>
        class integer_iterator_with_step
            : public boost::iterator_facade<
                        integer_iterator_with_step<Integer>,
                        Integer,
                        boost::random_access_traversal_tag,
                        Integer,
                        std::ptrdiff_t
                    >
        {
            typedef boost::iterator_facade<
                        integer_iterator_with_step<Integer>,
                        Integer,
                        boost::random_access_traversal_tag,
                        Integer,
                        std::ptrdiff_t
                    > base_t;
        public:
            typedef typename base_t::value_type value_type;
            typedef typename base_t::difference_type difference_type;
            typedef typename base_t::reference reference;
            typedef std::random_access_iterator_tag iterator_category;

            integer_iterator_with_step(value_type first, difference_type step, value_type step_size)
                : m_first(first)
                , m_step(step)
                , m_step_size(step_size)
            {
            }

        private:
            void increment()
            {
                ++m_step;
            }

            void decrement()
            {
                --m_step;
            }

            void advance(difference_type offset)
            {
                m_step += offset;
            }

            difference_type distance_to(const integer_iterator_with_step& other) const
            {
                return other.m_step - m_step;
            }

            bool equal(const integer_iterator_with_step& other) const
            {
                return m_step == other.m_step;
            }

            reference dereference() const
            {
                return m_first + (m_step * m_step_size);
            }

            friend class ::boost::iterator_core_access;
            value_type m_first;
            difference_type m_step;
            difference_type m_step_size;
        };

    }

    template<typename Integer>
    class integer_range
        : public iterator_range< range_detail::integer_iterator<Integer> >
    {
        typedef range_detail::integer_iterator<Integer> iterator_t;
        typedef iterator_range<iterator_t> base_t;
    public:
        integer_range(Integer first, Integer last)
            : base_t(iterator_t(first), iterator_t(last))
        {
        }
    };

    template<typename Integer>
    class strided_integer_range
    : public iterator_range< range_detail::integer_iterator_with_step<Integer> >
    {
        typedef range_detail::integer_iterator_with_step<Integer> iterator_t;
        typedef iterator_range<iterator_t> base_t;
    public:
        template<typename Iterator>
        strided_integer_range(Iterator first, Iterator last)
            : base_t(first, last)
        {
        }
    };

    template<typename Integer>
    integer_range<Integer>
    irange(Integer first, Integer last)
    {
        (static_cast <bool> (first <= last) ? void (0) : __assert_fail ("first <= last", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        return integer_range<Integer>(first, last);
    }

    template<typename Integer, typename StepSize>
    strided_integer_range<Integer>
        irange(Integer first, Integer last, StepSize step_size)
    {
        (static_cast <bool> (step_size != 0) ? void (0) : __assert_fail ("step_size != 0", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        (static_cast <bool> ((step_size > 0) ? (last >= first) : (last <= first)) ? void (0) : __assert_fail ("(step_size > 0) ? (last >= first) : (last <= first)", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));

        typedef typename range_detail::integer_iterator_with_step<Integer> iterator_t;

        const std::ptrdiff_t sz = static_cast<std::ptrdiff_t>(step_size >= 0 ? step_size : -step_size);
        const Integer l = step_size >= 0 ? last : first;
        const Integer f = step_size >= 0 ? first : last;
        const std::ptrdiff_t num_steps = (l - f) / sz + ((l - f) % sz ? 1 : 0);
        (static_cast <bool> (num_steps >= 0) ? void (0) : __assert_fail ("num_steps >= 0", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));

        return strided_integer_range<Integer>(
            iterator_t(first, 0, step_size),
            iterator_t(first, num_steps, step_size));
    }

    template<typename Integer>
    integer_range<Integer>
    irange(Integer last)
    {
        return integer_range<Integer>(static_cast<Integer>(0), last);
    }

}
# 38 "/home/avi/scylla-maint/seastar/include/seastar/core/smp.hh" 2
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/deque" 1 3
# 59 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/deque" 3







# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_deque.h" 1 3
# 72 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_deque.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 95 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_deque.h" 3
  template<typename _Tp, typename _Ref, typename _Ptr>
    struct _Deque_iterator
    {






    private:
      template<typename _CvTp>
 using __iter = _Deque_iterator<_Tp, _CvTp&, __ptr_rebind<_Ptr, _CvTp>>;
    public:
      typedef __iter<_Tp> iterator;
      typedef __iter<const _Tp> 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/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_deque.h" 3
      template<typename _Iter,
        typename = _Require<is_same<_Self, const_iterator>,
       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); }

      [[__nodiscard__]]
      reference
      operator*() const noexcept
      { return *_M_cur; }

      [[__nodiscard__]]
      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; }

      [[__nodiscard__]]
      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());
      }

      [[__nodiscard__]]
      friend bool
      operator==(const _Self& __x, const _Self& __y) noexcept
      { return __x._M_cur == __y._M_cur; }




      template<typename _RefR, typename _PtrR>
 [[__nodiscard__]]
 friend bool
 operator==(const _Self& __x,
     const _Deque_iterator<_Tp, _RefR, _PtrR>& __y)
 noexcept
 { return __x._M_cur == __y._M_cur; }


      [[nodiscard]]
      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;
      }
# 368 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_deque.h" 3
      [[__nodiscard__]]
      friend difference_type
      operator-(const _Self& __x, const _Self& __y) noexcept
      {
 return difference_type(_S_buffer_size())
   * (__x._M_node - __y._M_node - bool(__x._M_node))
   + (__x._M_cur - __x._M_first)
   + (__y._M_last - __y._M_cur);
      }





      template<typename _RefR, typename _PtrR>
 [[__nodiscard__]]
 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 - bool(__x._M_node))
     + (__x._M_cur - __x._M_first)
     + (__y._M_last - __y._M_cur);
 }

      [[__nodiscard__]]
      friend _Self
      operator+(const _Self& __x, difference_type __n) noexcept
      {
 _Self __tmp = __x;
 __tmp += __n;
 return __tmp;
      }

      [[__nodiscard__]]
      friend _Self
      operator-(const _Self& __x, difference_type __n) noexcept
      {
 _Self __tmp = __x;
 __tmp -= __n;
 return __tmp;
      }

      [[__nodiscard__]]
      friend _Self
      operator+(difference_type __n, const _Self& __x) noexcept
      { return __x + __n; }
    };
# 429 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_deque.h" 3
  template<typename _Tp, typename _Alloc>
    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<typename _Tp, typename _Alloc>
    _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);
 }
    }
# 636 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_deque.h" 3
  template<typename _Tp, typename _Alloc>
    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<typename _Tp, typename _Alloc>
    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<typename _Tp, typename _Alloc>
    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);
    }
# 787 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_deque.h" 3
  template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
    class deque : protected _Deque_base<_Tp, _Alloc>
    {
# 800 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_deque.h" 3
      static_assert(is_same<typename remove_cv<_Tp>::type, _Tp>::value,
   "std::deque must have a non-const, non-volatile value_type");

      static_assert(is_same<typename _Alloc::value_type, _Tp>::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_iterator> const_reverse_iterator;
      typedef std::reverse_iterator<iterator> reverse_iterator;
      typedef size_t size_type;
      typedef ptrdiff_t difference_type;
      typedef _Alloc allocator_type;

    private:
      static 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;
# 864 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_deque.h" 3
      explicit
      deque(const allocator_type& __a)
      : _Base(__a, 0) { }
# 877 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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(); }
# 890 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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); }
# 917 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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()); }
# 933 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_deque.h" 3
      deque(deque&&) = default;


      deque(const deque& __x, const __type_identity_t<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 __type_identity_t<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:
# 976 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_deque.h" 3
      deque(initializer_list<value_type> __l,
     const allocator_type& __a = allocator_type())
      : _Base(__a)
      {
 _M_range_initialize(__l.begin(), __l.end(),
       random_access_iterator_tag());
      }
# 1001 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_deque.h" 3
      template<typename _InputIterator,
        typename = std::_RequireInputIter<_InputIterator>>
 deque(_InputIterator __first, _InputIterator __last,
       const allocator_type& __a = allocator_type())
 : _Base(__a)
 {
   _M_range_initialize(__first, __last,
         std::__iterator_category(__first));
 }
# 1027 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_deque.h" 3
      ~deque()
      { _M_destroy_data(begin(), end(), _M_get_Tp_allocator()); }
# 1039 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_deque.h" 3
      deque&
      operator=(const deque& __x);
# 1051 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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;
      }
# 1070 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_deque.h" 3
      deque&
      operator=(initializer_list<value_type> __l)
      {
 _M_assign_aux(__l.begin(), __l.end(),
        random_access_iterator_tag());
 return *this;
      }
# 1089 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_deque.h" 3
      void
      assign(size_type __n, const value_type& __val)
      { _M_fill_assign(__n, __val); }
# 1106 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_deque.h" 3
      template<typename _InputIterator,
        typename = std::_RequireInputIter<_InputIterator>>
 void
 assign(_InputIterator __first, _InputIterator __last)
 { _M_assign_aux(__first, __last, std::__iterator_category(__first)); }
# 1133 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_deque.h" 3
      void
      assign(initializer_list<value_type> __l)
      { _M_assign_aux(__l.begin(), __l.end(), random_access_iterator_tag()); }



      [[__nodiscard__]]
      allocator_type
      get_allocator() const noexcept
      { return _Base::get_allocator(); }






      [[__nodiscard__]]
      iterator
      begin() noexcept
      { return this->_M_impl._M_start; }





      [[__nodiscard__]]
      const_iterator
      begin() const noexcept
      { return this->_M_impl._M_start; }






      [[__nodiscard__]]
      iterator
      end() noexcept
      { return this->_M_impl._M_finish; }






      [[__nodiscard__]]
      const_iterator
      end() const noexcept
      { return this->_M_impl._M_finish; }






      [[__nodiscard__]]
      reverse_iterator
      rbegin() noexcept
      { return reverse_iterator(this->_M_impl._M_finish); }






      [[__nodiscard__]]
      const_reverse_iterator
      rbegin() const noexcept
      { return const_reverse_iterator(this->_M_impl._M_finish); }






      [[__nodiscard__]]
      reverse_iterator
      rend() noexcept
      { return reverse_iterator(this->_M_impl._M_start); }






      [[__nodiscard__]]
      const_reverse_iterator
      rend() const noexcept
      { return const_reverse_iterator(this->_M_impl._M_start); }






      [[__nodiscard__]]
      const_iterator
      cbegin() const noexcept
      { return this->_M_impl._M_start; }






      [[__nodiscard__]]
      const_iterator
      cend() const noexcept
      { return this->_M_impl._M_finish; }






      [[__nodiscard__]]
      const_reverse_iterator
      crbegin() const noexcept
      { return const_reverse_iterator(this->_M_impl._M_finish); }






      [[__nodiscard__]]
      const_reverse_iterator
      crend() const noexcept
      { return const_reverse_iterator(this->_M_impl._M_start); }




      [[__nodiscard__]]
      size_type
      size() const noexcept
      { return this->_M_impl._M_finish - this->_M_impl._M_start; }


      [[__nodiscard__]]
      size_type
      max_size() const noexcept
      { return _S_max_size(_M_get_Tp_allocator()); }
# 1287 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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));
      }
# 1309 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_deque.h" 3
      void
      resize(size_type __new_size, const value_type& __x)
# 1326 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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; }
# 1362 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_deque.h" 3
      [[__nodiscard__]]
      reference
      operator[](size_type __n) noexcept
      {
                                  ;
 return this->_M_impl._M_start[difference_type(__n)];
      }
# 1381 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_deque.h" 3
      [[__nodiscard__]]
      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:
# 1413 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_deque.h" 3
      reference
      at(size_type __n)
      {
 _M_range_check(__n);
 return (*this)[__n];
      }
# 1431 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_deque.h" 3
      const_reference
      at(size_type __n) const
      {
 _M_range_check(__n);
 return (*this)[__n];
      }





      [[__nodiscard__]]
      reference
      front() noexcept
      {
                              ;
 return *begin();
      }





      [[__nodiscard__]]
      const_reference
      front() const noexcept
      {
                              ;
 return *begin();
      }





      [[__nodiscard__]]
      reference
      back() noexcept
      {
                              ;
 iterator __tmp = end();
 --__tmp;
 return *__tmp;
      }





      [[__nodiscard__]]
      const_reference
      back() const noexcept
      {
                              ;
 const_iterator __tmp = end();
 --__tmp;
 return *__tmp;
      }
# 1500 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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<typename... _Args>

 reference



 emplace_front(_Args&&... __args);
# 1537 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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<typename... _Args>

 reference



 emplace_back(_Args&&... __args);
# 1573 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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();
      }
# 1596 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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();
      }
# 1621 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_deque.h" 3
      template<typename... _Args>
 iterator
 emplace(const_iterator __position, _Args&&... __args);
# 1634 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_deque.h" 3
      iterator
      insert(const_iterator __position, const value_type& __x);
# 1660 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_deque.h" 3
      iterator
      insert(const_iterator __position, value_type&& __x)
      { return emplace(__position, std::move(__x)); }
# 1674 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_deque.h" 3
      iterator
      insert(const_iterator __p, initializer_list<value_type> __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;
      }
# 1693 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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;
      }
# 1727 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_deque.h" 3
      template<typename _InputIterator,
        typename = std::_RequireInputIter<_InputIterator>>
 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;
 }
# 1773 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_deque.h" 3
      iterator

      erase(const_iterator __position)



      { return _M_erase(__position._M_const_cast()); }
# 1797 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_deque.h" 3
      iterator

      erase(const_iterator __first, const_iterator __last)



      { return _M_erase(__first._M_const_cast(), __last._M_const_cast()); }
# 1816 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_deque.h" 3
      void
      swap(deque& __x) noexcept
      {

 do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(_Alloc_traits::propagate_on_container_swap::value || _M_get_Tp_allocator() == __x._M_get_Tp_allocator()), false)) std::__glibcxx_assert_fail(); } while (false);


 _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:
# 1866 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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<ptrdiff_t>::__max;
 const size_t __allocmax = _Alloc_traits::max_size(__a);
 return (std::min)(__diffmax, __allocmax);
      }
# 1895 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_deque.h" 3
      template<typename _InputIterator>
 void
 _M_range_initialize(_InputIterator __first, _InputIterator __last,
       std::input_iterator_tag);


      template<typename _ForwardIterator>
 void
 _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last,
       std::forward_iterator_tag);
# 1917 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_deque.h" 3
      void
      _M_fill_initialize(const value_type& __value);



      void
      _M_default_initialize();
# 1948 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_deque.h" 3
      template<typename _InputIterator>
 void
 _M_assign_aux(_InputIterator __first, _InputIterator __last,
        std::input_iterator_tag);


      template<typename _ForwardIterator>
 void
 _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last,
        std::forward_iterator_tag)
 {
   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);
   }
      }
# 1996 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_deque.h" 3
      template<typename... _Args>
 void _M_push_back_aux(_Args&&... __args);

      template<typename... _Args>
 void _M_push_front_aux(_Args&&... __args);


      void _M_pop_back_aux();

      void _M_pop_front_aux();
# 2035 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_deque.h" 3
      template<typename _InputIterator>
 void
 _M_range_insert_aux(iterator __pos, _InputIterator __first,
       _InputIterator __last, std::input_iterator_tag);


      template<typename _ForwardIterator>
 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<typename... _Args>
 iterator
 _M_insert_aux(iterator __pos, _Args&&... __args);



      void
      _M_insert_aux(iterator __pos, size_type __n, const value_type& __x);


      template<typename _ForwardIterator>
 void
 _M_insert_aux(iterator __pos,
        _ForwardIterator __first, _ForwardIterator __last,
        size_type __n);




      void
      _M_destroy_data_aux(iterator __first, iterator __last);



      template<typename _Alloc1>
 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);
# 2167 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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)
      {
 if (_M_get_Tp_allocator() == __x._M_get_Tp_allocator())
   return _M_move_assign1(std::move(__x), true_type());

 constexpr bool __move_storage =
   _Alloc_traits::_S_propagate_on_move_assign();
 _M_move_assign2(std::move(__x), __bool_constant<__move_storage>());
      }



      template<typename... _Args>
      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<typename _InputIterator, typename _ValT
      = typename iterator_traits<_InputIterator>::value_type,
    typename _Allocator = allocator<_ValT>,
    typename = _RequireInputIter<_InputIterator>,
    typename = _RequireAllocator<_Allocator>>
    deque(_InputIterator, _InputIterator, _Allocator = _Allocator())
      -> deque<_ValT, _Allocator>;
# 2287 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_deque.h" 3
  template<typename _Tp, typename _Alloc>
    [[__nodiscard__]]
    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()); }
# 2306 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_deque.h" 3
  template<typename _Tp, typename _Alloc>
    [[nodiscard]]
    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);
    }
# 2364 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_deque.h" 3
  template<typename _Tp, typename _Alloc>
    inline void
    swap(deque<_Tp,_Alloc>& __x, deque<_Tp,_Alloc>& __y)
    noexcept(noexcept(__x.swap(__y)))
    { __x.swap(__y); }
# 2377 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_deque.h" 3
  template<class _Tp>
    struct __is_bitwise_relocatable<std::deque<_Tp>>
    : true_type { };



}
# 67 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/deque" 2 3


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/deque.tcc" 1 3
# 61 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/deque.tcc" 3
namespace std __attribute__ ((__visibility__ ("default")))
{




  template <typename _Tp, typename _Alloc>
    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 <typename _Tp, typename _Alloc>
    deque<_Tp, _Alloc>&
    deque<_Tp, _Alloc>::
    operator=(const deque& __x)
    {
      if (std::__addressof(__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<typename _Tp, typename _Alloc>
    template<typename... _Args>

      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<typename _Tp, typename _Alloc>
    template<typename... _Args>

      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<typename _Tp, typename _Alloc>
    template<typename... _Args>
      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 _Tp, typename _Alloc>
    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 _Tp, typename _Alloc>
    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<size_type>(__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 _Tp, typename _Alloc>
    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<size_type>(__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 <typename _Tp, class _Alloc>
    template <typename _InputIterator>
      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 <typename _Tp, typename _Alloc>
    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 <typename _Tp, typename _Alloc>
    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 <typename _Tp, typename _Alloc>
    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<deque>::_S_do_it(*this);
    }


  template <typename _Tp, typename _Alloc>
    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 <typename _Tp, typename _Alloc>
    template <typename _InputIterator>
      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 <typename _Tp, typename _Alloc>
    template <typename _ForwardIterator>
      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)
       {
  if (__n < _S_buffer_size())
    __builtin_unreachable();

  _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<typename _Tp, typename _Alloc>

    template<typename... _Args>
      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<typename _Tp, typename _Alloc>

    template<typename... _Args>
      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 <typename _Tp, typename _Alloc>
    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 <typename _Tp, typename _Alloc>
    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 <typename _Tp, typename _Alloc>
    template <typename _InputIterator>
      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 <typename _Tp, typename _Alloc>
    template <typename _ForwardIterator>
      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<typename _Tp, typename _Alloc>

    template<typename... _Args>
      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<size_type>(__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 <typename _Tp, typename _Alloc>
    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 <typename _Tp, typename _Alloc>
    template <typename _ForwardIterator>
      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<size_type>(__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<typename _Tp, typename _Alloc>
     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 <typename _Tp, typename _Alloc>
    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 <typename _Tp, typename _Alloc>
    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 <typename _Tp, typename _Alloc>
    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<typename _Tp, typename _VTp>
    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<bool _IsMove,
    typename _Tp, typename _Ref, typename _Ptr, typename _OI>
    _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<bool _IsMove,
    typename _Tp, typename _Ref, typename _Ptr, typename _OI>
    _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<bool _IsMove,
    typename _ITp, typename _IRef, typename _IPtr, typename _OTp>
    std::_Deque_iterator<_OTp, _OTp&, _OTp*>
    __copy_move_a1(std::_Deque_iterator<_ITp, _IRef, _IPtr> __first,
     std::_Deque_iterator<_ITp, _IRef, _IPtr> __last,
     std::_Deque_iterator<_OTp, _OTp&, _OTp*> __result)
    { return __copy_move_dit<_IsMove>(__first, __last, __result); }

  template<bool _IsMove, typename _II, typename _Tp>
    typename __gnu_cxx::__enable_if<
      __is_random_access_iter<_II>::__value,
      std::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type
    __copy_move_a1(_II __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<bool _IsMove, typename _CharT>
    typename __gnu_cxx::__enable_if<
      __is_char<_CharT>::__value,
      std::_Deque_iterator<_CharT, _CharT&, _CharT*> >::__type
    __copy_move_a2(
 istreambuf_iterator<_CharT, char_traits<_CharT> > __first,
 istreambuf_iterator<_CharT, char_traits<_CharT> > __last,
 std::_Deque_iterator<_CharT, _CharT&, _CharT*> __result)
    {
      if (__first == __last)
 return __result;

      for (;;)
 {
   const std::ptrdiff_t __len = __result._M_last - __result._M_cur;
   const std::ptrdiff_t __nb
     = std::__copy_n_a(__first, __len, __result._M_cur, false)
     - __result._M_cur;
   __result += __nb;

   if (__nb != __len)
     break;
 }

      return __result;
    }

  template<typename _CharT, typename _Size>
    typename __gnu_cxx::__enable_if<
      __is_char<_CharT>::__value,
      std::_Deque_iterator<_CharT, _CharT&, _CharT*> >::__type
    __copy_n_a(
      istreambuf_iterator<_CharT, char_traits<_CharT> > __it, _Size __size,
      std::_Deque_iterator<_CharT, _CharT&, _CharT*> __result,
      bool __strict)
    {
      if (__size == 0)
 return __result;

      do
 {
   const _Size __len
     = std::min<_Size>(__result._M_last - __result._M_cur, __size);
   std::__copy_n_a(__it, __len, __result._M_cur, __strict);
   __result += __len;
   __size -= __len;
 }
      while (__size != 0);
      return __result;
    }

  template<bool _IsMove,
    typename _Tp, typename _Ref, typename _Ptr, typename _OI>
    _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<bool _IsMove,
    typename _Tp, typename _Ref, typename _Ptr, typename _OI>
    _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<bool _IsMove,
    typename _ITp, typename _IRef, typename _IPtr, typename _OTp>
    std::_Deque_iterator<_OTp, _OTp&, _OTp*>
    __copy_move_backward_a1(
  std::_Deque_iterator<_ITp, _IRef, _IPtr> __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<bool _IsMove, typename _II, typename _Tp>
    typename __gnu_cxx::__enable_if<
      __is_random_access_iter<_II>::__value,
      std::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type
    __copy_move_backward_a1(_II __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<typename _Tp, typename _Ref, typename _Ptr, typename _II>
    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 _Tp, typename _Ref, typename _Ptr, typename _II>
    typename __gnu_cxx::__enable_if<
      __is_random_access_iter<_II>::__value, bool>::__type
    __equal_aux1(std::_Deque_iterator<_Tp, _Ref, _Ptr> __first1,
   std::_Deque_iterator<_Tp, _Ref, _Ptr> __last1,
   _II __first2)
    { return std::__equal_dit(__first1, __last1, __first2); }

  template<typename _Tp1, typename _Ref1, typename _Ptr1,
    typename _Tp2, typename _Ref2, typename _Ptr2>
    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 _II, typename _Tp, typename _Ref, typename _Ptr>
    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;
    }

  template<typename _Tp1, typename _Ref, typename _Ptr, typename _Tp2>
    int
    __lex_cmp_dit(
 std::_Deque_iterator<_Tp1, _Ref, _Ptr> __first1,
 std::_Deque_iterator<_Tp1, _Ref, _Ptr> __last1,
 const _Tp2* __first2, const _Tp2* __last2)
    {
      const bool __simple =
 (__is_memcmp_ordered_with<_Tp1, _Tp2>::__value
  && __is_pointer<_Ptr>::__value




  && !is_volatile_v<_Tp1>
  && !is_volatile_v<_Tp2>

  );
      typedef std::__lexicographical_compare<__simple> _Lc;

      while (__first1._M_node != __last1._M_node)
 {
   const ptrdiff_t __len1 = __first1._M_last - __first1._M_cur;
   const ptrdiff_t __len2 = __last2 - __first2;
   const ptrdiff_t __len = std::min(__len1, __len2);

   if (int __ret = _Lc::__3way(__first1._M_cur, __first1._M_last,
          __first2, __first2 + __len))
     return __ret;

   __first1 += __len;
   __first2 += __len;
 }
      return _Lc::__3way(__first1._M_cur, __last1._M_cur,
    __first2, __last2);
    }

  template<typename _Tp1, typename _Ref1, typename _Ptr1,
    typename _Tp2>
    inline bool
    __lexicographical_compare_aux1(
 std::_Deque_iterator<_Tp1, _Ref1, _Ptr1> __first1,
 std::_Deque_iterator<_Tp1, _Ref1, _Ptr1> __last1,
 _Tp2* __first2, _Tp2* __last2)
    { return std::__lex_cmp_dit(__first1, __last1, __first2, __last2) < 0; }

  template<typename _Tp1,
    typename _Tp2, typename _Ref2, typename _Ptr2>
    inline bool
    __lexicographical_compare_aux1(_Tp1* __first1, _Tp1* __last1,
 std::_Deque_iterator<_Tp2, _Ref2, _Ptr2> __first2,
 std::_Deque_iterator<_Tp2, _Ref2, _Ptr2> __last2)
    { return std::__lex_cmp_dit(__first2, __last2, __first1, __last1) > 0; }

  template<typename _Tp1, typename _Ref1, typename _Ptr1,
    typename _Tp2, typename _Ref2, typename _Ptr2>
    inline bool
    __lexicographical_compare_aux1(
  std::_Deque_iterator<_Tp1, _Ref1, _Ptr1> __first1,
  std::_Deque_iterator<_Tp1, _Ref1, _Ptr1> __last1,
  std::_Deque_iterator<_Tp2, _Ref2, _Ptr2> __first2,
  std::_Deque_iterator<_Tp2, _Ref2, _Ptr2> __last2)
    {
      const bool __simple =
 (__is_memcmp_ordered_with<_Tp1, _Tp2>::__value
  && __is_pointer<_Ptr1>::__value
  && __is_pointer<_Ptr2>::__value




  && !is_volatile_v<_Tp1>
  && !is_volatile_v<_Tp2>

  );
      typedef std::__lexicographical_compare<__simple> _Lc;

      while (__first1 != __last1)
 {
   const ptrdiff_t __len2 = __first2._M_node == __last2._M_node
     ? __last2._M_cur - __first2._M_cur
     : __first2._M_last - __first2._M_cur;
   if (__len2 == 0)
     return false;
   const ptrdiff_t __len1 = __first1._M_node == __last1._M_node
     ? __last1._M_cur - __first1._M_cur
     : __first1._M_last - __first1._M_cur;
   const ptrdiff_t __len = std::min(__len1, __len2);
   if (int __ret = _Lc::__3way(__first1._M_cur, __first1._M_cur + __len,
          __first2._M_cur, __first2._M_cur + __len))
     return __ret < 0;

   __first1 += __len;
   __first2 += __len;
 }

      return __last2 != __first2;
    }


}
# 70 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/deque" 2 3



# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 74 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/deque" 2 3







namespace std __attribute__ ((__visibility__ ("default")))
{

  namespace pmr
  {
    template<typename _Tp>
      using deque = std::deque<_Tp, polymorphic_allocator<_Tp>>;
  }

}



namespace std __attribute__ ((__visibility__ ("default")))
{


  template<typename _Tp, typename _Alloc, typename _Predicate>
    inline typename deque<_Tp, _Alloc>::size_type
    erase_if(deque<_Tp, _Alloc>& __cont, _Predicate __pred)
    {
      using namespace __gnu_cxx;
      std::deque<_Tp, _Alloc>& __ucont = __cont;
      const auto __osz = __cont.size();
      const auto __end = __ucont.end();
      auto __removed = std::__remove_if(__ucont.begin(), __end,
     __ops::__pred_iter(std::ref(__pred)));
      if (__removed != __end)
 {
   __cont.erase(__niter_wrap(__cont.begin(), __removed),
         __cont.end());
   return __osz - __cont.size();
 }

      return 0;
    }

  template<typename _Tp, typename _Alloc, typename _Up>
    inline typename deque<_Tp, _Alloc>::size_type
    erase(deque<_Tp, _Alloc>& __cont, const _Up& __value)
    {
      using namespace __gnu_cxx;
      std::deque<_Tp, _Alloc>& __ucont = __cont;
      const auto __osz = __cont.size();
      const auto __end = __ucont.end();
      auto __removed = std::__remove_if(__ucont.begin(), __end,
     __ops::__iter_equals_val(__value));
      if (__removed != __end)
 {
   __cont.erase(__niter_wrap(__cont.begin(), __removed),
         __cont.end());
   return __osz - __cont.size();
 }

      return 0;
    }

}
# 39 "/home/avi/scylla-maint/seastar/include/seastar/core/smp.hh" 2






namespace seastar {

class reactor_backend_selector;



class smp_service_group;

namespace alien {

class instance;

}


namespace internal {

unsigned smp_service_group_id(smp_service_group ssg) noexcept;

class memory_prefaulter;

}

namespace memory::internal {

struct numa_layout;

}






struct smp_service_group_config {



    unsigned max_nonlocal_requests = 0;




    std::optional<sstring> group_name;
};
# 111 "/home/avi/scylla-maint/seastar/include/seastar/core/smp.hh"
class smp_service_group {
    unsigned _id;



private:
    explicit smp_service_group(unsigned id) noexcept : _id(id) {}

    friend unsigned internal::smp_service_group_id(smp_service_group ssg) noexcept;
    friend smp_service_group default_smp_service_group() noexcept;
    friend future<smp_service_group> create_smp_service_group(smp_service_group_config ssgc) noexcept;
    friend future<> destroy_smp_service_group(smp_service_group) noexcept;
};



inline
unsigned
internal::smp_service_group_id(smp_service_group ssg) noexcept {
    return ssg._id;
}







smp_service_group default_smp_service_group() noexcept;





future<smp_service_group> create_smp_service_group(smp_service_group_config ssgc) noexcept;





future<> destroy_smp_service_group(smp_service_group ssg) noexcept;

inline
smp_service_group default_smp_service_group() noexcept {
    return smp_service_group(0);
}

using smp_timeout_clock = lowres_clock;
using smp_service_group_semaphore = basic_semaphore<named_semaphore_exception_factory, smp_timeout_clock>;
using smp_service_group_semaphore_units = semaphore_units<named_semaphore_exception_factory, smp_timeout_clock>;



static constexpr smp_timeout_clock::time_point smp_no_timeout = smp_timeout_clock::time_point::max();



struct smp_submit_to_options {

    smp_service_group service_group = default_smp_service_group();



    smp_timeout_clock::time_point timeout = smp_no_timeout;

    smp_submit_to_options(smp_service_group service_group = default_smp_service_group(), smp_timeout_clock::time_point timeout = smp_no_timeout) noexcept
        : service_group(service_group)
        , timeout(timeout) {
    }
};

void init_default_smp_service_group(shard_id cpu);

smp_service_group_semaphore& get_smp_service_groups_semaphore(unsigned ssg_id, shard_id t) noexcept;

class smp_message_queue {
    static constexpr size_t queue_length = 128;
    static constexpr size_t batch_size = 16;
    static constexpr size_t prefetch_cnt = 2;
    struct work_item;
    struct lf_queue_remote {
        reactor* remote;
    };
    using lf_queue_base = boost::lockfree::spsc_queue<work_item*,
                            boost::lockfree::capacity<queue_length>>;

    struct lf_queue : lf_queue_remote, lf_queue_base {
        lf_queue(reactor* remote) : lf_queue_remote{remote} {}
        void maybe_wakeup();
        ~lf_queue();
    };
    lf_queue _pending;
    lf_queue _completed;
    struct alignas(seastar::cache_line_size) {
        size_t _sent = 0;
        size_t _compl = 0;
        size_t _last_snt_batch = 0;
        size_t _last_cmpl_batch = 0;
        size_t _current_queue_length = 0;
    };




    metrics::metric_groups _metrics;
    struct alignas(seastar::cache_line_size) {
        size_t _received = 0;
        size_t _last_rcv_batch = 0;
    };
    struct work_item : public task {
        explicit work_item(smp_service_group ssg) : task(current_scheduling_group()), ssg(ssg) {}
        smp_service_group ssg;
        virtual ~work_item() {}
        virtual void fail_with(std::exception_ptr) = 0;
        void process();
        virtual void complete() = 0;
    };
    template <typename Func>
    struct async_work_item : work_item {
        smp_message_queue& _queue;
        Func _func;
        using futurator = futurize<std::invoke_result_t<Func>>;
        using future_type = typename futurator::type;
        using value_type = typename future_type::value_type;
        std::optional<value_type> _result;
        std::exception_ptr _ex;
        typename futurator::promise_type _promise;
        async_work_item(smp_message_queue& queue, smp_service_group ssg, Func&& func) : work_item(ssg), _queue(queue), _func(std::move(func)) {}
        virtual void fail_with(std::exception_ptr ex) override {
            _promise.set_exception(std::move(ex));
        }
        virtual task* waiting_task() noexcept override {

            return nullptr;
        }
        virtual void run_and_dispose() noexcept override {


            (void)futurator::invoke(this->_func).then_wrapped([this] (auto f) {
                if (f.failed()) {
                    _ex = f.get_exception();
                } else {
                    _result = f.get();
                }
                _queue.respond(this);
            });


        }
        virtual void complete() override {
            if (_result) {
                _promise.set_value(std::move(*_result));
            } else {

                _promise.set_exception(std::move(_ex));
            }
        }
        future_type get_future() { return _promise.get_future(); }
    };
    union tx_side {
        tx_side() {}
        ~tx_side() {}
        void init() { new (&a) aa; }
        struct aa {
            std::deque<work_item*> pending_fifo;
        } a;
    } _tx;
    std::vector<work_item*> _completed_fifo;
public:
    smp_message_queue(reactor* from, reactor* to);
    ~smp_message_queue();
    template <typename Func>
    futurize_t<std::invoke_result_t<Func>> submit(shard_id t, smp_submit_to_options options, Func&& func) noexcept {
        memory::scoped_critical_alloc_section _;
        auto wi = std::make_unique<async_work_item<Func>>(*this, options.service_group, std::forward<Func>(func));
        auto fut = wi->get_future();
        submit_item(t, options.timeout, std::move(wi));
        return fut;
    }
    void start(unsigned cpuid);
    template<size_t PrefetchCnt, typename Func>
    size_t process_queue(lf_queue& q, Func process);
    size_t process_incoming();
    size_t process_completions(shard_id t);
    void stop();
private:
    void work();
    void submit_item(shard_id t, smp_timeout_clock::time_point timeout, std::unique_ptr<work_item> wi);
    void respond(work_item* wi);
    void move_pending();
    void flush_request_batch();
    void flush_response_batch();
    bool has_unflushed_responses() const;
    bool pure_poll_rx() const;
    bool pure_poll_tx() const;

    friend class smp;
};

class smp_message_queue;
struct reactor_options;
struct smp_options;

class smp : public std::enable_shared_from_this<smp> {
    alien::instance& _alien;
    std::vector<posix_thread> _threads;
    std::vector<std::function<void ()>> _thread_loops;
    std::optional<boost::barrier> _all_event_loops_done;
    std::unique_ptr<internal::memory_prefaulter> _prefaulter;
    struct qs_deleter {
      void operator()(smp_message_queue** qs) const;
    };
    std::unique_ptr<smp_message_queue*[], qs_deleter> _qs_owner;
    static thread_local smp_message_queue**_qs;
    static thread_local std::thread::id _tmain;
    bool _using_dpdk = false;

private:
    void setup_prefaulter(const seastar::resource::resources& res, seastar::memory::internal::numa_layout layout);
public:
    explicit smp(alien::instance& alien);
    ~smp();
    void configure(const smp_options& smp_opts, const reactor_options& reactor_opts);
    void cleanup() noexcept;
    void cleanup_cpu();
    void arrive_at_event_loop_end();
    void join_all();
    static bool main_thread() { return std::this_thread::get_id() == _tmain; }
# 353 "/home/avi/scylla-maint/seastar/include/seastar/core/smp.hh"
    template <typename Func>
    static futurize_t<std::invoke_result_t<Func>> submit_to(unsigned t, smp_submit_to_options options, Func&& func) noexcept {
        using ret_type = std::invoke_result_t<Func>;
        if (t == this_shard_id()) {
            try {
                if (!is_future<ret_type>::value) {

                    return futurize<ret_type>::invoke(std::forward<Func>(func));
                } else if (std::is_lvalue_reference_v<Func>) {

                    return futurize<ret_type>::invoke(func);
                } else {

                    auto w = std::make_unique<std::decay_t<Func>>(std::move(func));
                    auto ret = futurize<ret_type>::invoke(*w);
                    return ret.finally([w = std::move(w)] {});
                }
            } catch (...) {

                return futurize<std::invoke_result_t<Func>>::make_exception_future(std::current_exception());
            }
        } else {
            return _qs[t][this_shard_id()].submit(t, options, std::forward<Func>(func));
        }
    }
# 392 "/home/avi/scylla-maint/seastar/include/seastar/core/smp.hh"
    template <typename Func>
    static futurize_t<std::invoke_result_t<Func>> submit_to(unsigned t, Func&& func) noexcept {
        return submit_to(t, default_smp_service_group(), std::forward<Func>(func));
    }
    static bool poll_queues();
    static bool pure_poll_queues();
    static boost::integer_range<unsigned> all_cpus() noexcept {
        return boost::irange(0u, count);
    }
# 409 "/home/avi/scylla-maint/seastar/include/seastar/core/smp.hh"
    template<typename Func>
     requires std::is_nothrow_move_constructible_v<Func>
    static future<> invoke_on_all(smp_submit_to_options options, Func&& func) noexcept {
        static_assert(std::is_same_v<future<>, typename futurize<std::invoke_result_t<Func>>::type>, "bad Func signature");
        static_assert(std::is_nothrow_move_constructible_v<Func>);
        return parallel_for_each(all_cpus(), [options, &func] (unsigned id) {
            return smp::submit_to(id, options, Func(func));
        });
    }
# 427 "/home/avi/scylla-maint/seastar/include/seastar/core/smp.hh"
    template<typename Func>
    static future<> invoke_on_all(Func&& func) noexcept {
        return invoke_on_all(smp_submit_to_options{}, std::forward<Func>(func));
    }
# 440 "/home/avi/scylla-maint/seastar/include/seastar/core/smp.hh"
    template<typename Func>
    requires std::is_nothrow_move_constructible_v<Func> &&
            std::is_nothrow_copy_constructible_v<Func>
    static future<> invoke_on_others(unsigned cpu_id, smp_submit_to_options options, Func func) noexcept {
        static_assert(std::is_same_v<future<>, typename futurize<std::invoke_result_t<Func>>::type>, "bad Func signature");
        static_assert(std::is_nothrow_move_constructible_v<Func>);
        return parallel_for_each(all_cpus(), [cpu_id, options, func = std::move(func)] (unsigned id) {
            return id != cpu_id ? smp::submit_to(id, options, Func(func)) : make_ready_future<>();
        });
    }
# 460 "/home/avi/scylla-maint/seastar/include/seastar/core/smp.hh"
    template<typename Func>
    requires std::is_nothrow_move_constructible_v<Func>
    static future<> invoke_on_others(unsigned cpu_id, Func func) noexcept {
        return invoke_on_others(cpu_id, smp_submit_to_options{}, std::move(func));
    }






    template<typename Func>
    requires std::is_nothrow_move_constructible_v<Func>
    static future<> invoke_on_others(Func func) noexcept {
        return invoke_on_others(this_shard_id(), std::move(func));
    }
private:
    void start_all_queues();
    void pin(unsigned cpu_id);
    void allocate_reactor(unsigned id, reactor_backend_selector rbs, reactor_config cfg);
    void create_thread(std::function<void ()> thread_loop);
    unsigned adjust_max_networking_aio_io_control_blocks(unsigned network_iocbs);
public:
    static unsigned count;
};



}
# 25 "/home/avi/scylla-maint/seastar/include/seastar/core/sharded.hh" 2

# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/map_reduce.hh" 1
# 33 "/home/avi/scylla-maint/seastar/include/seastar/core/map_reduce.hh"
namespace seastar {
# 42 "/home/avi/scylla-maint/seastar/include/seastar/core/map_reduce.hh"
template <typename T, typename Ptr, bool IsFuture>
struct reducer_with_get_traits;

template <typename T, typename Ptr>
struct reducer_with_get_traits<T, Ptr, false> {
    using result_type = decltype(std::declval<T>().get());
    using future_type = future<result_type>;
    static future_type maybe_call_get(future<> f, Ptr r) {
        return f.then([r = std::move(r)] () mutable {
            return make_ready_future<result_type>(std::move(r->reducer).get());
        });
    }
};

template <typename T, typename Ptr>
struct reducer_with_get_traits<T, Ptr, true> {
    using future_type = decltype(std::declval<T>().get());
    static future_type maybe_call_get(future<> f, Ptr r) {
        return f.then([r = r.get()] {
            return r->reducer.get();
        }).then_wrapped([r] (future_type f) {
            return f;
        });
    }
};

template <typename T, typename Ptr = lw_shared_ptr<T>, typename V = void>
struct reducer_traits {
    using future_type = future<>;
    static future_type maybe_call_get(future<> f, Ptr r) {
        return f.then([r = std::move(r)] {});
    }
};

template <typename T, typename Ptr>
struct reducer_traits<T, Ptr, decltype(std::declval<T>().get(), void())> : public reducer_with_get_traits<T, Ptr, is_future<std::invoke_result_t<decltype(&T::get),T>>::value> {};
# 98 "/home/avi/scylla-maint/seastar/include/seastar/core/map_reduce.hh"
template <typename Iterator, typename Mapper, typename Reducer>
requires requires (Iterator i, Mapper mapper, Reducer reduce) {
     *i++;
     { i != i } -> std::convertible_to<bool>;
     mapper(*i);
     reduce(futurize_invoke(mapper, *i).get());
}
inline
auto
map_reduce(Iterator begin, Iterator end, Mapper&& mapper, Reducer&& r)
    -> typename reducer_traits<Reducer>::future_type
{
    struct state {
        Mapper mapper;
        Reducer reducer;
    };
    auto s = make_lw_shared(state{std::forward<Mapper>(mapper), std::forward<Reducer>(r)});
    future<> ret = make_ready_future<>();
    while (begin != end) {
        ret = futurize_invoke(s->mapper, *begin++).then_wrapped([ret = std::move(ret), s] (auto f) mutable {
            return ret.then_wrapped([f = std::move(f), s] (auto rf) mutable {
                if (rf.failed()) {
                    f.ignore_ready_future();
                    return rf;
                } else {
                    return futurize_invoke(s->reducer, std::move(f.get()));
                }
            });
        });
    }
    return reducer_traits<Reducer, lw_shared_ptr<state>>::maybe_call_get(std::move(ret), s);
}
# 173 "/home/avi/scylla-maint/seastar/include/seastar/core/map_reduce.hh"
template <typename Iterator, typename Mapper, typename Initial, typename Reduce>
requires requires (Iterator i, Mapper mapper, Initial initial, Reduce reduce) {
     *i++;
     { i != i} -> std::convertible_to<bool>;
     mapper(*i);
     requires is_future<decltype(mapper(*i))>::value;
     { reduce(std::move(initial), mapper(*i).get()) } -> std::convertible_to<Initial>;
}
inline
future<Initial>
map_reduce(Iterator begin, Iterator end, Mapper&& mapper, Initial initial, Reduce reduce) {
    struct state {
        Mapper mapper;
        Initial result;
        Reduce reduce;
    };
    auto s = make_lw_shared(state{std::forward<Mapper>(mapper), std::move(initial), std::move(reduce)});
    future<> ret = make_ready_future<>();
    while (begin != end) {
        ret = futurize_invoke(s->mapper, *begin++).then_wrapped([s = s.get(), ret = std::move(ret)] (auto f) mutable {
            try {
                s->result = s->reduce(std::move(s->result), f.get());
                return std::move(ret);
            } catch (...) {
                return std::move(ret).then_wrapped([ex = std::current_exception()] (auto f) {
                    f.ignore_ready_future();
                    return make_exception_future<>(ex);
                });
            }
        });
    }
    return ret.then([s] {
        return make_ready_future<Initial>(std::move(s->result));
    });
}
# 251 "/home/avi/scylla-maint/seastar/include/seastar/core/map_reduce.hh"
template <typename Range, typename Mapper, typename Initial, typename Reduce>
requires requires (Range range, Mapper mapper, Initial initial, Reduce reduce) {
     std::begin(range);
     std::end(range);
     mapper(*std::begin(range));
     requires is_future<std::remove_reference_t<decltype(mapper(*std::begin(range)))>>::value;
     { reduce(std::move(initial), mapper(*std::begin(range)).get()) } -> std::convertible_to<Initial>;
}
inline
future<Initial>
map_reduce(Range&& range, Mapper&& mapper, Initial initial, Reduce reduce) {
    return map_reduce(std::begin(range), std::end(range), std::forward<Mapper>(mapper),
            std::move(initial), std::move(reduce));
}



template <typename Result, typename Addend = Result>
class adder {
private:
    Result _result;
public:
    future<> operator()(const Addend& value) {
        _result += value;
        return make_ready_future<>();
    }
    Result get() && {
        return std::move(_result);
    }
};





}
# 27 "/home/avi/scylla-maint/seastar/include/seastar/core/sharded.hh" 2
# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/internal/run_in_background.hh" 1
# 26 "/home/avi/scylla-maint/seastar/include/seastar/core/internal/run_in_background.hh"
namespace seastar::internal {

void run_in_background(future<> f);

template <typename Func>
void run_in_background(Func&& func) {
    run_in_background(futurize_invoke(std::forward<Func>(func)));
}

}
# 28 "/home/avi/scylla-maint/seastar/include/seastar/core/sharded.hh" 2

# 1 "/home/avi/scylla-maint/seastar/include/seastar/util/tuple_utils.hh" 1
# 26 "/home/avi/scylla-maint/seastar/include/seastar/util/tuple_utils.hh"
# 1 "/usr/bin/../lib/clang/18/include/stddef.h" 1 3
# 72 "/usr/bin/../lib/clang/18/include/stddef.h" 3
# 1 "/usr/bin/../lib/clang/18/include/__stddef_ptrdiff_t.h" 1 3
# 18 "/usr/bin/../lib/clang/18/include/__stddef_ptrdiff_t.h" 3
typedef long int ptrdiff_t;
# 73 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3




# 1 "/usr/bin/../lib/clang/18/include/__stddef_size_t.h" 1 3
# 18 "/usr/bin/../lib/clang/18/include/__stddef_size_t.h" 3
typedef long unsigned int size_t;
# 78 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3
# 87 "/usr/bin/../lib/clang/18/include/stddef.h" 3
# 1 "/usr/bin/../lib/clang/18/include/__stddef_wchar_t.h" 1 3
# 88 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3




# 1 "/usr/bin/../lib/clang/18/include/__stddef_null.h" 1 3
# 93 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3




# 1 "/usr/bin/../lib/clang/18/include/__stddef_nullptr_t.h" 1 3
# 98 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3
# 112 "/usr/bin/../lib/clang/18/include/stddef.h" 3
# 1 "/usr/bin/../lib/clang/18/include/__stddef_offsetof.h" 1 3
# 113 "/usr/bin/../lib/clang/18/include/stddef.h" 2 3
# 27 "/home/avi/scylla-maint/seastar/include/seastar/util/tuple_utils.hh" 2

namespace seastar {


namespace internal {

template<typename Tuple>
Tuple untuple(Tuple t) {
    return t;
}

template<typename T>
T untuple(std::tuple<T> t) {
    return std::get<0>(std::move(t));
}

template<typename Tuple, typename Function, size_t... I>
void tuple_for_each_helper(Tuple&& t, Function&& f, std::index_sequence<I...>&&) {
    auto ignore_me = { (f(std::get<I>(std::forward<Tuple>(t))), 1)... };
    (void)ignore_me;
}

template<typename Tuple, typename MapFunction, size_t... I>
auto tuple_map_helper(Tuple&& t, MapFunction&& f, std::index_sequence<I...>&&) {
    return std::make_tuple(f(std::get<I>(std::forward<Tuple>(t)))...);
}

template<size_t I, typename IndexSequence>
struct prepend;

template<size_t I, size_t... Is>
struct prepend<I, std::index_sequence<Is...>> {
    using type = std::index_sequence<I, Is...>;
};

template<template<typename> class Filter, typename Tuple, typename IndexSequence>
struct tuple_filter;

template<template<typename> class Filter, typename T, typename... Ts, size_t I, size_t... Is>
struct tuple_filter<Filter, std::tuple<T, Ts...>, std::index_sequence<I, Is...>> {
    using tail = typename tuple_filter<Filter, std::tuple<Ts...>, std::index_sequence<Is...>>::type;
    using type = std::conditional_t<Filter<T>::value, typename prepend<I, tail>::type, tail>;
};

template<template<typename> class Filter>
struct tuple_filter<Filter, std::tuple<>, std::index_sequence<>> {
    using type = std::index_sequence<>;
};

template<typename Tuple, size_t... I>
auto tuple_filter_helper(Tuple&& t, std::index_sequence<I...>&&) {
    return std::make_tuple(std::get<I>(std::forward<Tuple>(t))...);
}

}
# 95 "/home/avi/scylla-maint/seastar/include/seastar/util/tuple_utils.hh"
template<template<typename> class MapClass, typename Tuple>
struct tuple_map_types;



template<template<typename> class MapClass, typename... Elements>
struct tuple_map_types<MapClass, std::tuple<Elements...>> {
    using type = std::tuple<typename MapClass<Elements>::type...>;
};
# 117 "/home/avi/scylla-maint/seastar/include/seastar/util/tuple_utils.hh"
template<template<typename> class FilterClass, typename... Elements>
auto tuple_filter_by_type(const std::tuple<Elements...>& t) {
    using sequence = typename internal::tuple_filter<FilterClass, std::tuple<Elements...>,
                                                     std::index_sequence_for<Elements...>>::type;
    return internal::tuple_filter_helper(t, sequence());
}
template<template<typename> class FilterClass, typename... Elements>
auto tuple_filter_by_type(std::tuple<Elements...>&& t) {
    using sequence = typename internal::tuple_filter<FilterClass, std::tuple<Elements...>,
                                                     std::index_sequence_for<Elements...>>::type;
    return internal::tuple_filter_helper(std::move(t), sequence());
}
# 138 "/home/avi/scylla-maint/seastar/include/seastar/util/tuple_utils.hh"
template<typename Function, typename... Elements>
auto tuple_map(const std::tuple<Elements...>& t, Function&& f) {
    return internal::tuple_map_helper(t, std::forward<Function>(f),
                                      std::index_sequence_for<Elements...>());
}
template<typename Function, typename... Elements>
auto tuple_map(std::tuple<Elements...>&& t, Function&& f) {
    return internal::tuple_map_helper(std::move(t), std::forward<Function>(f),
                                      std::index_sequence_for<Elements...>());
}
# 156 "/home/avi/scylla-maint/seastar/include/seastar/util/tuple_utils.hh"
template<typename Function, typename... Elements>
void tuple_for_each(const std::tuple<Elements...>& t, Function&& f) {
    return internal::tuple_for_each_helper(t, std::forward<Function>(f),
                                           std::index_sequence_for<Elements...>());
}
template<typename Function, typename... Elements>
void tuple_for_each(std::tuple<Elements...>& t, Function&& f) {
    return internal::tuple_for_each_helper(t, std::forward<Function>(f),
                                           std::index_sequence_for<Elements...>());
}
template<typename Function, typename... Elements>
void tuple_for_each(std::tuple<Elements...>&& t, Function&& f) {
    return internal::tuple_for_each_helper(std::move(t), std::forward<Function>(f),
                                           std::index_sequence_for<Elements...>());
}



}
# 30 "/home/avi/scylla-maint/seastar/include/seastar/core/sharded.hh" 2

# 1 "/home/avi/scylla-maint/seastar/include/seastar/util/log.hh" 1
# 25 "/home/avi/scylla-maint/seastar/include/seastar/util/log.hh"
# 1 "/home/avi/scylla-maint/seastar/include/seastar/util/log-impl.hh" 1
# 29 "/home/avi/scylla-maint/seastar/include/seastar/util/log-impl.hh"
namespace seastar {


namespace internal {
# 42 "/home/avi/scylla-maint/seastar/include/seastar/util/log-impl.hh"
class log_buf {
    char* _begin;
    char* _end;
    char* _current;
    bool _own_buf;
    bool _alloc_failure = false;
private:
    void free_buffer() noexcept;
    void realloc_buffer_and_append(char c) noexcept;

public:
# 61 "/home/avi/scylla-maint/seastar/include/seastar/util/log-impl.hh"
    class inserter_iterator {
    public:
        using iterator_category = std::output_iterator_tag;
        using difference_type = std::ptrdiff_t;
        using value_type = void;
        using pointer = void;
        using reference = void;

    private:
        log_buf* _buf;

    public:
        explicit inserter_iterator(log_buf& buf) noexcept : _buf(&buf) { }

        inserter_iterator& operator=(char c) noexcept {
            if (__builtin_expect(_buf->_current == _buf->_end, false)) {
                _buf->realloc_buffer_and_append(c);
                return *this;
            }
            *_buf->_current++ = c;
            return *this;
        }
        inserter_iterator& operator*() noexcept {
            return *this;
        }
        inserter_iterator& operator++() noexcept {
            return *this;
        }
        inserter_iterator operator++(int) noexcept {
            return *this;
        }
    };




    log_buf();




    log_buf(char* external_buf, size_t size) noexcept;
    ~log_buf();



    void clear() { _current = _begin; }

    inserter_iterator back_insert_begin() noexcept { return inserter_iterator(*this); }

    size_t size() const noexcept { return _current - _begin; }

    size_t capacity() const noexcept { return _end - _begin; }



    const char* data() const noexcept { return _begin; }

    std::string_view view() const noexcept { return std::string_view(_begin, size()); }
};

}


}
# 26 "/home/avi/scylla-maint/seastar/include/seastar/util/log.hh" 2
# 38 "/home/avi/scylla-maint/seastar/include/seastar/util/log.hh"
# 1 "/usr/include/boost/lexical_cast.hpp" 1 3 4
# 49 "/usr/include/boost/lexical_cast.hpp" 3 4
# 1 "/usr/include/boost/lexical_cast/bad_lexical_cast.hpp" 1 3 4
# 30 "/usr/include/boost/lexical_cast/bad_lexical_cast.hpp" 3 4
namespace boost
{

    class __attribute__((__visibility__("default"))) bad_lexical_cast :




        public std::bad_cast







    {
    public:
        bad_lexical_cast() noexcept

           : source(&typeid(void)), target(&typeid(void))

        {}

        const char *what() const noexcept override {
            return "bad lexical cast: "
                   "source type value could not be interpreted as target";
        }

        ~bad_lexical_cast() noexcept override
        {}


    private:



        typedef ::std::type_info type_info_t;

    public:
        bad_lexical_cast(
                const type_info_t &source_type_arg,
                const type_info_t &target_type_arg) noexcept
            : source(&source_type_arg), target(&target_type_arg)
        {}

        const type_info_t &source_type() const noexcept {
            return *source;
        }

        const type_info_t &target_type() const noexcept {
            return *target;
        }

    private:
        const type_info_t *source;
        const type_info_t *target;

    };

    namespace conversion { namespace detail {






        template <class S, class T>
        inline void throw_bad_cast() {
            boost::throw_exception(bad_lexical_cast(typeid(S), typeid(T)));
        }

    }}

}
# 50 "/usr/include/boost/lexical_cast.hpp" 2 3 4
# 1 "/usr/include/boost/lexical_cast/try_lexical_convert.hpp" 1 3 4
# 29 "/usr/include/boost/lexical_cast/try_lexical_convert.hpp" 3 4
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wuninitialized"
#pragma GCC diagnostic ignored "-Wsign-conversion"
# 42 "/usr/include/boost/lexical_cast/try_lexical_convert.hpp" 3 4
# 1 "/usr/include/boost/lexical_cast/detail/is_character.hpp" 1 3 4
# 29 "/usr/include/boost/lexical_cast/detail/is_character.hpp" 3 4
namespace boost {

    namespace detail
    {

        template < typename T >
        struct is_character
        {
            typedef typename boost::integral_constant<
                bool,
                boost::is_same< T, char >::value ||

                        boost::is_same< T, wchar_t >::value ||


                        boost::is_same< T, char16_t >::value ||


                        boost::is_same< T, char32_t >::value ||

                        boost::is_same< T, unsigned char >::value ||
                        boost::is_same< T, signed char >::value
            > type;

            static const bool value = (type::value);
        };
    }
}
# 43 "/usr/include/boost/lexical_cast/try_lexical_convert.hpp" 2 3 4
# 1 "/usr/include/boost/lexical_cast/detail/converter_numeric.hpp" 1 3 4
# 34 "/usr/include/boost/lexical_cast/detail/converter_numeric.hpp" 3 4
# 1 "/usr/include/boost/type_traits/is_float.hpp" 1 3 4
# 14 "/usr/include/boost/type_traits/is_float.hpp" 3 4
namespace boost {


   template <class T> struct is_float : public is_floating_point<T> {};
}
# 35 "/usr/include/boost/lexical_cast/detail/converter_numeric.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/remove_volatile.hpp" 1 3 4
# 18 "/usr/include/boost/type_traits/remove_volatile.hpp" 3 4
namespace boost {


   template <class T> struct remove_volatile{ typedef T type; };
   template <class T> struct remove_volatile<T volatile>{ typedef T type; };


   template <class T, std::size_t N> struct remove_volatile<T volatile[N]>{ typedef T type[N]; };

   template <class T> struct remove_volatile<T volatile[]>{ typedef T type[]; };





   template <class T> using remove_volatile_t = typename remove_volatile<T>::type;



}
# 36 "/usr/include/boost/lexical_cast/detail/converter_numeric.hpp" 2 3 4



namespace boost { namespace detail {

template <class Source >
struct detect_precision_loss
{
    typedef Source source_type;
    typedef boost::numeric::Trunc<Source> Rounder;
    typedef typename conditional<
        boost::is_arithmetic<Source>::value, Source, Source const&
    >::type argument_type ;

    static inline source_type nearbyint(argument_type s, bool& is_ok) noexcept {
        const source_type near_int = Rounder::nearbyint(s);
        if (near_int && is_ok) {
            const source_type orig_div_round = s / near_int;
            const source_type eps = std::numeric_limits<source_type>::epsilon();

            is_ok = !((orig_div_round > 1 ? orig_div_round - 1 : 1 - orig_div_round) > eps);
        }

        return s;
    }

    typedef typename Rounder::round_style round_style;
};

template <typename Base, class Source>
struct fake_precision_loss: public Base
{
    typedef Source source_type ;
    typedef typename conditional<
        boost::is_arithmetic<Source>::value, Source, Source const&
    >::type argument_type ;

    static inline source_type nearbyint(argument_type s, bool& ) noexcept {
        return s;
    }
};

struct nothrow_overflow_handler
{
    inline bool operator() ( boost::numeric::range_check_result r ) const noexcept {
        return (r == boost::numeric::cInRange);
    }
};

template <typename Target, typename Source>
inline bool noexcept_numeric_convert(const Source& arg, Target& result) noexcept {
    typedef boost::numeric::converter<
            Target,
            Source,
            boost::numeric::conversion_traits<Target, Source >,
            nothrow_overflow_handler,
            detect_precision_loss<Source >
    > converter_orig_t;

    typedef typename boost::conditional<
        boost::is_base_of< detect_precision_loss<Source >, converter_orig_t >::value,
        converter_orig_t,
        fake_precision_loss<converter_orig_t, Source>
    >::type converter_t;

    bool res = nothrow_overflow_handler()(converter_t::out_of_range(arg));
    if (res) {
        result = converter_t::low_level_convert(converter_t::nearbyint(arg, res));
    }

    return res;
}

template <typename Target, typename Source>
struct lexical_cast_dynamic_num_not_ignoring_minus
{
    static inline bool try_convert(const Source &arg, Target& result) noexcept {
        return noexcept_numeric_convert<Target, Source >(arg, result);
    }
};

template <typename Target, typename Source>
struct lexical_cast_dynamic_num_ignoring_minus
{
    static inline bool try_convert(const Source &arg, Target& result) noexcept {
        typedef typename boost::conditional<
                boost::is_float<Source>::value,
                boost::type_identity<Source>,
                boost::make_unsigned<Source>
        >::type usource_lazy_t;
        typedef typename usource_lazy_t::type usource_t;

        if (arg < 0) {
            const bool res = noexcept_numeric_convert<Target, usource_t>(0u - arg, result);
            result = static_cast<Target>(0u - result);
            return res;
        } else {
            return noexcept_numeric_convert<Target, usource_t>(arg, result);
        }
    }
};
# 156 "/usr/include/boost/lexical_cast/detail/converter_numeric.hpp" 3 4
template <typename Target, typename Source>
struct dynamic_num_converter_impl
{
    typedef typename boost::remove_volatile<Source>::type source_type;

    static inline bool try_convert(source_type arg, Target& result) noexcept {
        typedef typename boost::conditional<
            boost::is_unsigned<Target>::value &&
            (boost::is_signed<source_type>::value || boost::is_float<source_type>::value) &&
            !(boost::is_same<source_type, bool>::value) &&
            !(boost::is_same<Target, bool>::value),
            lexical_cast_dynamic_num_ignoring_minus<Target, source_type>,
            lexical_cast_dynamic_num_not_ignoring_minus<Target, source_type>
        >::type caster_type;

        return caster_type::try_convert(arg, result);
    }
};

}}
# 44 "/usr/include/boost/lexical_cast/try_lexical_convert.hpp" 2 3 4
# 1 "/usr/include/boost/lexical_cast/detail/converter_lexical.hpp" 1 3 4
# 38 "/usr/include/boost/lexical_cast/detail/converter_lexical.hpp" 3 4
# 1 "/usr/include/boost/type_traits/has_left_shift.hpp" 1 3 4
# 43 "/usr/include/boost/type_traits/has_left_shift.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 1 3 4
# 26 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
# 43 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
namespace boost
{

   namespace binary_op_detail {

      struct dont_care;

      template <class T, class U, class Ret, class = void>
      struct has_left_shift_ret_imp : public boost::false_type {};

      template <class T, class U, class Ret>
      struct has_left_shift_ret_imp<T, U, Ret, typename boost::make_void<decltype(std::declval<typename add_reference<T>::type>() << std::declval<typename add_reference<U>::type>())>::type>
         : public boost::integral_constant<bool, ::boost::is_convertible<decltype(std::declval<typename add_reference<T>::type>() << std::declval<typename add_reference<U>::type>()), Ret>::value> {};

      template <class T, class U, class = void >
      struct has_left_shift_void_imp : public boost::false_type {};

      template <class T, class U>
      struct has_left_shift_void_imp<T, U, typename boost::make_void<decltype(std::declval<typename add_reference<T>::type>() << std::declval<typename add_reference<U>::type>())>::type>
         : public boost::integral_constant<bool, ::boost::is_void<decltype(std::declval<typename add_reference<T>::type>() << std::declval<typename add_reference<U>::type>())>::value> {};

      template <class T, class U, class = void>
      struct has_left_shift_dc_imp : public boost::false_type {};

      template <class T, class U>
      struct has_left_shift_dc_imp<T, U, typename boost::make_void<decltype(std::declval<typename add_reference<T>::type>() << std::declval<typename add_reference<U>::type>())>::type>
         : public boost::true_type {};

   }

   template <class T, class U = T, class Ret = boost::binary_op_detail::dont_care>
   struct has_left_shift : public boost::binary_op_detail:: has_left_shift_ret_imp <T, U, Ret> {};
   template <class T, class U>
   struct has_left_shift<T, U, void> : public boost::binary_op_detail:: has_left_shift_void_imp <T, U> {};
   template <class T, class U>
   struct has_left_shift<T, U, boost::binary_op_detail::dont_care> : public boost::binary_op_detail:: has_left_shift_dc_imp <T, U> {};


}
# 44 "/usr/include/boost/type_traits/has_left_shift.hpp" 2 3 4
# 39 "/usr/include/boost/lexical_cast/detail/converter_lexical.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/has_right_shift.hpp" 1 3 4
# 43 "/usr/include/boost/type_traits/has_right_shift.hpp" 3 4
# 1 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 1 3 4
# 26 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
# 43 "/usr/include/boost/type_traits/detail/has_binary_operator.hpp" 3
namespace boost
{

   namespace binary_op_detail {

      struct dont_care;

      template <class T, class U, class Ret, class = void>
      struct has_right_shift_ret_imp : public boost::false_type {};

      template <class T, class U, class Ret>
      struct has_right_shift_ret_imp<T, U, Ret, typename boost::make_void<decltype(std::declval<typename add_reference<T>::type>() >> std::declval<typename add_reference<U>::type>())>::type>
         : public boost::integral_constant<bool, ::boost::is_convertible<decltype(std::declval<typename add_reference<T>::type>() >> std::declval<typename add_reference<U>::type>()), Ret>::value> {};

      template <class T, class U, class = void >
      struct has_right_shift_void_imp : public boost::false_type {};

      template <class T, class U>
      struct has_right_shift_void_imp<T, U, typename boost::make_void<decltype(std::declval<typename add_reference<T>::type>() >> std::declval<typename add_reference<U>::type>())>::type>
         : public boost::integral_constant<bool, ::boost::is_void<decltype(std::declval<typename add_reference<T>::type>() >> std::declval<typename add_reference<U>::type>())>::value> {};

      template <class T, class U, class = void>
      struct has_right_shift_dc_imp : public boost::false_type {};

      template <class T, class U>
      struct has_right_shift_dc_imp<T, U, typename boost::make_void<decltype(std::declval<typename add_reference<T>::type>() >> std::declval<typename add_reference<U>::type>())>::type>
         : public boost::true_type {};

   }

   template <class T, class U = T, class Ret = boost::binary_op_detail::dont_care>
   struct has_right_shift : public boost::binary_op_detail:: has_right_shift_ret_imp <T, U, Ret> {};
   template <class T, class U>
   struct has_right_shift<T, U, void> : public boost::binary_op_detail:: has_right_shift_void_imp <T, U> {};
   template <class T, class U>
   struct has_right_shift<T, U, boost::binary_op_detail::dont_care> : public boost::binary_op_detail:: has_right_shift_dc_imp <T, U> {};


}
# 44 "/usr/include/boost/type_traits/has_right_shift.hpp" 2 3 4
# 40 "/usr/include/boost/lexical_cast/detail/converter_lexical.hpp" 2 3 4

# 1 "/usr/include/boost/detail/lcast_precision.hpp" 1 3 4
# 11 "/usr/include/boost/detail/lcast_precision.hpp" 3 4
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/climits" 1 3 4
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/climits" 3
# 12 "/usr/include/boost/detail/lcast_precision.hpp" 2 3 4
# 36 "/usr/include/boost/detail/lcast_precision.hpp" 3 4
namespace boost { namespace detail {

class lcast_abstract_stub {};





template<class T>
struct lcast_precision
{



    typedef typename boost::conditional<
        boost::is_abstract<T>::value
      , std::numeric_limits<lcast_abstract_stub>
      , std::numeric_limits<T>
      >::type limits;


    static const bool use_default_precision = !limits::is_specialized || limits::is_exact;



    static const bool is_specialized_bin = !use_default_precision && limits::radix == 2 && limits::digits > 0;




    static const bool is_specialized_dec = !use_default_precision && limits::radix == 10 && limits::digits10 > 0;




    static const std::streamsize streamsize_max = boost::integer_traits<std::streamsize>::const_max;



    static const unsigned int precision_dec = limits::digits10 + 1U;

    static_assert(!is_specialized_dec || precision_dec <= streamsize_max + 0UL, "!is_specialized_dec || precision_dec <= streamsize_max + 0UL");



    static const unsigned long precision_bin = 2UL + limits::digits * 30103UL / 100000UL;



    static_assert(!is_specialized_bin || (limits::digits + 0UL < (9223372036854775807L *2UL+1UL) / 30103UL && precision_bin > limits::digits10 + 0UL && precision_bin <= streamsize_max + 0UL), "!is_specialized_bin || (limits::digits + 0UL < ULONG_MAX / 30103UL && precision_bin > limits::digits10 + 0UL && precision_bin <= streamsize_max + 0UL)");





    static const std::streamsize value = is_specialized_bin ? precision_bin : is_specialized_dec ? precision_dec : 6;



};


template<class T>
inline std::streamsize lcast_get_precision(T* = 0)
{

    return lcast_precision<T>::value;
# 166 "/usr/include/boost/detail/lcast_precision.hpp" 3 4
}

template<class T>
inline void lcast_set_precision(std::ios_base& stream, T*)
{
    stream.precision(lcast_get_precision<T>());
}

template<class Source, class Target>
inline void lcast_set_precision(std::ios_base& stream, Source*, Target*)
{
    std::streamsize const s = lcast_get_precision(static_cast<Source*>(0));
    std::streamsize const t = lcast_get_precision(static_cast<Target*>(0));
    stream.precision(s > t ? s : t);
}

}}
# 42 "/usr/include/boost/lexical_cast/detail/converter_lexical.hpp" 2 3 4

# 1 "/usr/include/boost/lexical_cast/detail/widest_char.hpp" 1 3 4
# 29 "/usr/include/boost/lexical_cast/detail/widest_char.hpp" 3 4
namespace boost { namespace detail {

    template <typename TargetChar, typename SourceChar>
    struct widest_char {
        typedef typename boost::conditional<
            (sizeof(TargetChar) > sizeof(SourceChar))
            , TargetChar
            , SourceChar
        >::type type;
    };

}}
# 44 "/usr/include/boost/lexical_cast/detail/converter_lexical.hpp" 2 3 4






# 1 "/usr/include/boost/array.hpp" 1 3 4
# 46 "/usr/include/boost/array.hpp" 3 4
# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 58 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 59 "/usr/include/boost/assert.hpp" 2 3 4
# 47 "/usr/include/boost/array.hpp" 2 3 4
# 1 "/usr/include/boost/core/swap.hpp" 1 3 4
# 44 "/usr/include/boost/core/swap.hpp" 3 4
namespace boost_swap_impl
{


  template<class T> struct is_const { enum _vt { value = 0 }; };
  template<class T> struct is_const<T const> { enum _vt { value = 1 }; };




  using namespace std;

  template<class T>

  void swap_impl(T& left, T& right) noexcept((noexcept((swap(left, right)))))
  {
    swap(left, right);
  }

  template<class T, std::size_t N>

  void swap_impl(T (& left)[N], T (& right)[N])
    noexcept((noexcept((::boost_swap_impl::swap_impl(left[0], right[0])))))
  {
    for (std::size_t i = 0; i < N; ++i)
    {
      ::boost_swap_impl::swap_impl(left[i], right[i]);
    }
  }
}

namespace boost
{
  template<class T1, class T2>

  typename enable_if_c< !boost_swap_impl::is_const<T1>::value && !boost_swap_impl::is_const<T2>::value >::type
  swap(T1& left, T2& right)
    noexcept((noexcept((::boost_swap_impl::swap_impl(left, right)))))
  {
    ::boost_swap_impl::swap_impl(left, right);
  }
}
# 48 "/usr/include/boost/array.hpp" 2 3 4
# 57 "/usr/include/boost/array.hpp" 3 4
namespace boost {

    template<class T, std::size_t N>
    class array {
      public:
        T elems[N];

      public:

        typedef T value_type;
        typedef T* iterator;
        typedef const T* const_iterator;
        typedef T& reference;
        typedef const T& const_reference;
        typedef std::size_t size_type;
        typedef std::ptrdiff_t difference_type;


        iterator begin() { return elems; }
        const_iterator begin() const { return elems; }
        const_iterator cbegin() const { return elems; }

        iterator end() { return elems+N; }
        const_iterator end() const { return elems+N; }
        const_iterator cend() const { return elems+N; }



        typedef std::reverse_iterator<iterator> reverse_iterator;
        typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
# 98 "/usr/include/boost/array.hpp" 3 4
        reverse_iterator rbegin() { return reverse_iterator(end()); }
        const_reverse_iterator rbegin() const {
            return const_reverse_iterator(end());
        }
        const_reverse_iterator crbegin() const {
            return const_reverse_iterator(end());
        }

        reverse_iterator rend() { return reverse_iterator(begin()); }
        const_reverse_iterator rend() const {
            return const_reverse_iterator(begin());
        }
        const_reverse_iterator crend() const {
            return const_reverse_iterator(begin());
        }


        reference operator[](size_type i)
        {
            return (static_cast <bool> ((i < N)&&("out of range")) ? void (0) : __assert_fail ("(i < N)&&(\"out of range\")", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)), elems[i];
        }

                            const_reference operator[](size_type i) const
        {
            return (static_cast <bool> ((i < N)&&("out of range")) ? void (0) : __assert_fail ("(i < N)&&(\"out of range\")", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)), elems[i];
        }


        reference at(size_type i) { return rangecheck(i), elems[i]; }
                            const_reference at(size_type i) const { return rangecheck(i), elems[i]; }


        reference front()
        {
            return elems[0];
        }

        constexpr const_reference front() const
        {
            return elems[0];
        }

        reference back()
        {
            return elems[N-1];
        }

        constexpr const_reference back() const
        {
            return elems[N-1];
        }


        static constexpr size_type size() { return N; }
        static constexpr bool empty() { return false; }
        static constexpr size_type max_size() { return N; }
        enum { static_size = N };


        void swap (array<T,N>& y) {
            for (size_type i = 0; i < N; ++i)
                boost::swap(elems[i],y.elems[i]);
        }


        const T* data() const { return elems; }
        T* data() { return elems; }


        T* c_array() { return elems; }


        template <typename T2>
        array<T,N>& operator= (const array<T2,N>& rhs) {
            std::copy(rhs.begin(),rhs.end(), begin());
            return *this;
        }


        void assign (const T& value) { fill ( value ); }
        void fill (const T& value)
        {
            std::fill_n(begin(),size(),value);
        }


        static constexpr bool rangecheck (size_type i) {
            return i >= size() ? boost::throw_exception(std::out_of_range ("array<>: index out of range")), true : true;
        }

    };

    template< class T >
    class array< T, 0 > {

      public:

        typedef T value_type;
        typedef T* iterator;
        typedef const T* const_iterator;
        typedef T& reference;
        typedef const T& const_reference;
        typedef std::size_t size_type;
        typedef std::ptrdiff_t difference_type;


        iterator begin() { return iterator( reinterpret_cast< T * >( this ) ); }
        const_iterator begin() const { return const_iterator( reinterpret_cast< const T * >( this ) ); }
        const_iterator cbegin() const { return const_iterator( reinterpret_cast< const T * >( this ) ); }

        iterator end() { return begin(); }
        const_iterator end() const { return begin(); }
        const_iterator cend() const { return cbegin(); }



        typedef std::reverse_iterator<iterator> reverse_iterator;
        typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
# 227 "/usr/include/boost/array.hpp" 3 4
        reverse_iterator rbegin() { return reverse_iterator(end()); }
        const_reverse_iterator rbegin() const {
            return const_reverse_iterator(end());
        }
        const_reverse_iterator crbegin() const {
            return const_reverse_iterator(end());
        }

        reverse_iterator rend() { return reverse_iterator(begin()); }
        const_reverse_iterator rend() const {
            return const_reverse_iterator(begin());
        }
        const_reverse_iterator crend() const {
            return const_reverse_iterator(begin());
        }


        reference operator[](size_type )
        {
            return failed_rangecheck();
        }

                            const_reference operator[](size_type ) const
        {
            return failed_rangecheck();
        }


        reference at(size_type ) { return failed_rangecheck(); }
                            const_reference at(size_type ) const { return failed_rangecheck(); }


        reference front()
        {
            return failed_rangecheck();
        }

        constexpr const_reference front() const
        {
            return failed_rangecheck();
        }

        reference back()
        {
            return failed_rangecheck();
        }

        constexpr const_reference back() const
        {
            return failed_rangecheck();
        }


        static constexpr size_type size() { return 0; }
        static constexpr bool empty() { return true; }
        static constexpr size_type max_size() { return 0; }
        enum { static_size = 0 };

        void swap (array<T,0>& ) {
        }


        const T* data() const { return 0; }
        T* data() { return 0; }


        T* c_array() { return 0; }


        template <typename T2>
        array<T,0>& operator= (const array<T2,0>& ) {
            return *this;
        }


        void assign (const T& value) { fill ( value ); }
        void fill (const T& ) {}


        static reference failed_rangecheck () {
                std::out_of_range e("attempt to access element of an empty array");
                boost::throw_exception(e);






                static T placeholder;
                return placeholder;

            }
    };


    template<class T, std::size_t N>
    bool operator== (const array<T,N>& x, const array<T,N>& y) {
        return std::equal(x.begin(), x.end(), y.begin());
    }
    template<class T, std::size_t N>
    bool operator< (const array<T,N>& x, const array<T,N>& y) {
        return std::lexicographical_compare(x.begin(),x.end(),y.begin(),y.end());
    }
    template<class T, std::size_t N>
    bool operator!= (const array<T,N>& x, const array<T,N>& y) {
        return !(x==y);
    }
    template<class T, std::size_t N>
    bool operator> (const array<T,N>& x, const array<T,N>& y) {
        return y<x;
    }
    template<class T, std::size_t N>
    bool operator<= (const array<T,N>& x, const array<T,N>& y) {
        return !(y<x);
    }
    template<class T, std::size_t N>
    bool operator>= (const array<T,N>& x, const array<T,N>& y) {
        return !(x<y);
    }


    template<class T, std::size_t N>
    inline void swap (array<T,N>& x, array<T,N>& y) {
        x.swap(y);
    }
# 381 "/usr/include/boost/array.hpp" 3 4
    template <typename T, std::size_t N>
    T(&get_c_array(boost::array<T,N>& arg))[N]
    {
        return arg.elems;
    }


    template <typename T, std::size_t N>
    const T(&get_c_array(const boost::array<T,N>& arg))[N]
    {
        return arg.elems;
    }
# 413 "/usr/include/boost/array.hpp" 3 4
    template <class It> std::size_t hash_range(It, It);

    template<class T, std::size_t N>
    std::size_t hash_value(const array<T,N>& arr)
    {
        return boost::hash_range(arr.begin(), arr.end());
    }

   template <size_t Idx, typename T, size_t N>
   T &get(boost::array<T,N> &arr) noexcept {
       static_assert(Idx < N, "boost::get<>(boost::array &) index out of range");
       return arr[Idx];
       }

   template <size_t Idx, typename T, size_t N>
   const T &get(const boost::array<T,N> &arr) noexcept {
       static_assert(Idx < N, "boost::get<>(const boost::array &) index out of range");
       return arr[Idx];
       }

}



namespace std {
   template <size_t Idx, typename T, size_t N>
   T &get(boost::array<T,N> &arr) noexcept {
       static_assert(Idx < N, "std::get<>(boost::array &) index out of range");
       return arr[Idx];
       }

   template <size_t Idx, typename T, size_t N>
   const T &get(const boost::array<T,N> &arr) noexcept {
       static_assert(Idx < N, "std::get<>(const boost::array &) index out of range");
       return arr[Idx];
       }
}
# 51 "/usr/include/boost/lexical_cast/detail/converter_lexical.hpp" 2 3 4



# 1 "/usr/include/boost/lexical_cast/detail/converter_lexical_streams.hpp" 1 3 4
# 33 "/usr/include/boost/lexical_cast/detail/converter_lexical_streams.hpp" 3 4
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 1 3 4
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 3


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 43 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 2 3
# 34 "/usr/include/boost/lexical_cast/detail/converter_lexical_streams.hpp" 2 3 4
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdio" 1 3 4
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdio" 3
# 35 "/usr/include/boost/lexical_cast/detail/converter_lexical_streams.hpp" 2 3 4






# 1 "/usr/include/boost/core/snprintf.hpp" 1 3 4
# 49 "/usr/include/boost/core/snprintf.hpp" 3 4
namespace boost {

namespace core {
# 161 "/usr/include/boost/core/snprintf.hpp" 3 4
using ::snprintf;
using ::vsnprintf;

using ::swprintf;
using ::vswprintf;



}

}
# 42 "/usr/include/boost/lexical_cast/detail/converter_lexical_streams.hpp" 2 3 4
# 62 "/usr/include/boost/lexical_cast/detail/converter_lexical_streams.hpp" 3 4
# 1 "/usr/include/boost/lexical_cast/detail/lcast_char_constants.hpp" 1 3 4
# 26 "/usr/include/boost/lexical_cast/detail/lcast_char_constants.hpp" 3 4
namespace boost
{
    namespace detail
    {
        template < typename Char >
        struct lcast_char_constants {


            static const Char zero = static_cast<Char>('0');
            static const Char minus = static_cast<Char>('-');
            static const Char plus = static_cast<Char>('+');
            static const Char lowercase_e = static_cast<Char>('e');
            static const Char capital_e = static_cast<Char>('E');
            static const Char c_decimal_separator = static_cast<Char>('.');
        };
    }
}
# 63 "/usr/include/boost/lexical_cast/detail/converter_lexical_streams.hpp" 2 3 4
# 1 "/usr/include/boost/lexical_cast/detail/lcast_unsigned_converters.hpp" 1 3 4
# 26 "/usr/include/boost/lexical_cast/detail/lcast_unsigned_converters.hpp" 3 4
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/climits" 1 3 4
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/climits" 3
# 27 "/usr/include/boost/lexical_cast/detail/lcast_unsigned_converters.hpp" 2 3 4


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 1 3 4
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 3


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 43 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 2 3
# 30 "/usr/include/boost/lexical_cast/detail/lcast_unsigned_converters.hpp" 2 3 4
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdio" 1 3 4
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdio" 3
# 31 "/usr/include/boost/lexical_cast/detail/lcast_unsigned_converters.hpp" 2 3 4
# 55 "/usr/include/boost/lexical_cast/detail/lcast_unsigned_converters.hpp" 3 4
namespace boost
{
    namespace detail
    {
        template<class T>
        inline
        typename boost::make_unsigned<T>::type lcast_to_unsigned(const T value) noexcept {
            typedef typename boost::make_unsigned<T>::type result_type;
            return value < 0
                ? static_cast<result_type>(0u - static_cast<result_type>(value))
                : static_cast<result_type>(value);
        }
    }

    namespace detail
    {
        template <class Traits, class T, class CharT>
        class lcast_put_unsigned: boost::noncopyable {
            typedef typename Traits::int_type int_type;
            typename boost::conditional<
                    (sizeof(unsigned) > sizeof(T))
                    , unsigned
                    , T
            >::type m_value;
            CharT* m_finish;
            CharT const m_czero;
            int_type const m_zero;

        public:
            lcast_put_unsigned(const T n_param, CharT* finish) noexcept
                : m_value(n_param), m_finish(finish)
                , m_czero(lcast_char_constants<CharT>::zero), m_zero(Traits::to_int_type(m_czero))
            {

                static_assert(!std::numeric_limits<T>::is_signed, "!std::numeric_limits<T>::is_signed");

            }

            CharT* convert() {

                std::locale loc;
                if (loc == std::locale::classic()) {
                    return main_convert_loop();
                }

                typedef std::numpunct<CharT> numpunct;
                numpunct const& np = std::use_facet< numpunct >(loc);
                std::string const grouping = np.grouping();
                std::string::size_type const grouping_size = grouping.size();

                if (!grouping_size || grouping[0] <= 0) {
                    return main_convert_loop();
                }



                static_assert(std::numeric_limits<T>::digits10 < 127, "std::numeric_limits<T>::digits10 < CHAR_MAX");

                CharT const thousands_sep = np.thousands_sep();
                std::string::size_type group = 0;
                char last_grp_size = grouping[0];
                char left = last_grp_size;

                do {
                    if (left == 0) {
                        ++group;
                        if (group < grouping_size) {
                            char const grp_size = grouping[group];
                            last_grp_size = (grp_size <= 0 ? static_cast<char>(127) : grp_size);
                        }

                        left = last_grp_size;
                        --m_finish;
                        Traits::assign(*m_finish, thousands_sep);
                    }

                    --left;
                } while (main_convert_iteration());

                return m_finish;



            }

        private:
            inline bool main_convert_iteration() noexcept {
                --m_finish;
                int_type const digit = static_cast<int_type>(m_value % 10U);
                Traits::assign(*m_finish, Traits::to_char_type(m_zero + digit));
                m_value /= 10;
                return !!m_value;
            }

            inline CharT* main_convert_loop() noexcept {
                while (main_convert_iteration());
                return m_finish;
            }
        };
    }

    namespace detail
    {
        template <class Traits, class T, class CharT>
        class lcast_ret_unsigned: boost::noncopyable {
            bool m_multiplier_overflowed;
            T m_multiplier;
            T& m_value;
            const CharT* const m_begin;
            const CharT* m_end;

        public:
            lcast_ret_unsigned(T& value, const CharT* const begin, const CharT* end) noexcept
                : m_multiplier_overflowed(false), m_multiplier(1), m_value(value), m_begin(begin), m_end(end)
            {

                static_assert(!std::numeric_limits<T>::is_signed, "!std::numeric_limits<T>::is_signed");






                static_assert(std::numeric_limits<T>::is_specialized, "std::numeric_limits are not specialized for integral type passed to boost::lexical_cast");



            }

            inline bool convert() {
                CharT const czero = lcast_char_constants<CharT>::zero;
                --m_end;
                m_value = static_cast<T>(0);

                if (m_begin > m_end || *m_end < czero || *m_end >= czero + 10)
                    return false;
                m_value = static_cast<T>(*m_end - czero);
                --m_end;




                std::locale loc;
                if (loc == std::locale::classic()) {
                    return main_convert_loop();
                }

                typedef std::numpunct<CharT> numpunct;
                numpunct const& np = std::use_facet< numpunct >(loc);
                std::string const& grouping = np.grouping();
                std::string::size_type const grouping_size = grouping.size();




                if (!grouping_size || grouping[0] <= 0) {
                    return main_convert_loop();
                }

                unsigned char current_grouping = 0;
                CharT const thousands_sep = np.thousands_sep();
                char remained = static_cast<char>(grouping[current_grouping] - 1);

                for (;m_end >= m_begin; --m_end)
                {
                    if (remained) {
                        if (!main_convert_iteration()) {
                            return false;
                        }
                        --remained;
                    } else {
                        if ( !Traits::eq(*m_end, thousands_sep) )
                        {
# 239 "/usr/include/boost/lexical_cast/detail/lcast_unsigned_converters.hpp" 3 4
                            return main_convert_loop();
                        } else {
                            if (m_begin == m_end) return false;
                            if (current_grouping < grouping_size - 1) ++current_grouping;
                            remained = grouping[current_grouping];
                        }
                    }
                }

                return true;

            }

        private:


            inline bool main_convert_iteration() noexcept {
                CharT const czero = lcast_char_constants<CharT>::zero;
                T const maxv = (std::numeric_limits<T>::max)();

                m_multiplier_overflowed = m_multiplier_overflowed || (maxv/10 < m_multiplier);
                m_multiplier = static_cast<T>(m_multiplier * 10);

                T const dig_value = static_cast<T>(*m_end - czero);
                T const new_sub_value = static_cast<T>(m_multiplier * dig_value);



                if (*m_end < czero || *m_end >= czero + 10
                    || (dig_value && (
                        m_multiplier_overflowed
                        || static_cast<T>(maxv / dig_value) < m_multiplier
                        || static_cast<T>(maxv - new_sub_value) < m_value
                    ))
                ) return false;

                m_value = static_cast<T>(m_value + new_sub_value);

                return true;
            }

            bool main_convert_loop() noexcept {
                for ( ; m_end >= m_begin; --m_end) {
                    if (!main_convert_iteration()) {
                        return false;
                    }
                }

                return true;
            }
        };
    }
}
# 64 "/usr/include/boost/lexical_cast/detail/converter_lexical_streams.hpp" 2 3 4
# 1 "/usr/include/boost/lexical_cast/detail/inf_nan.hpp" 1 3 4
# 32 "/usr/include/boost/lexical_cast/detail/inf_nan.hpp" 3 4
# 1 "/usr/include/boost/core/cmath.hpp" 1 3 4
# 19 "/usr/include/boost/core/cmath.hpp" 3 4
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cmath" 1 3 4
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cmath" 3
# 20 "/usr/include/boost/core/cmath.hpp" 2 3 4
# 121 "/usr/include/boost/core/cmath.hpp" 3 4
namespace boost
{
namespace core
{
# 238 "/usr/include/boost/core/cmath.hpp" 3 4
using std::isfinite;
using std::isnan;
using std::isinf;
using std::isnormal;
using std::fpclassify;

int const fp_zero = 2;
int const fp_subnormal = 3;
int const fp_normal = 4;
int const fp_infinite = 1;
int const fp_nan = 0;

using std::signbit;
# 263 "/usr/include/boost/core/cmath.hpp" 3 4
namespace detail
{



inline float copysign_impl( float x, float y )
{
    return __builtin_copysignf( x, y );
}

inline double copysign_impl( double x, double y )
{
    return __builtin_copysign( x, y );
}

inline long double copysign_impl( long double x, long double y )
{
    return __builtin_copysignl( x, y );
}

}

template<class T> T copysign( T x, T y )
{
    return boost::core::detail::copysign_impl( x, y );
}




}
}
# 33 "/usr/include/boost/lexical_cast/detail/inf_nan.hpp" 2 3 4

# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 1 3 4
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 3


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 43 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 2 3
# 35 "/usr/include/boost/lexical_cast/detail/inf_nan.hpp" 2 3 4



namespace boost {
    namespace detail
    {
        template <class CharT>
        bool lc_iequal(const CharT* val, const CharT* lcase, const CharT* ucase, unsigned int len) noexcept {
            for( unsigned int i=0; i < len; ++i ) {
                if ( val[i] != lcase[i] && val[i] != ucase[i] ) return false;
            }

            return true;
        }


        template <class CharT, class T>
        inline bool parse_inf_nan_impl(const CharT* begin, const CharT* end, T& value
            , const CharT* lc_NAN, const CharT* lc_nan
            , const CharT* lc_INFINITY, const CharT* lc_infinity
            , const CharT opening_brace, const CharT closing_brace) noexcept
        {
            if (begin == end) return false;
            const CharT minus = lcast_char_constants<CharT>::minus;
            const CharT plus = lcast_char_constants<CharT>::plus;
            const int inifinity_size = 8;


            bool const has_minus = (*begin == minus);
            if (has_minus || *begin == plus) {
                ++ begin;
            }

            if (end - begin < 3) return false;
            if (lc_iequal(begin, lc_nan, lc_NAN, 3)) {
                begin += 3;
                if (end != begin) {


                    if (end - begin < 2) return false;
                    -- end;
                    if (*begin != opening_brace || *end != closing_brace) return false;
                }

                if( !has_minus ) value = std::numeric_limits<T>::quiet_NaN();
                else value = boost::core::copysign(std::numeric_limits<T>::quiet_NaN(), static_cast<T>(-1));
                return true;
            } else if (
                (
                  end - begin == 3
                  && lc_iequal(begin, lc_infinity, lc_INFINITY, 3)
                )
                ||
                (
                  end - begin == inifinity_size
                  && lc_iequal(begin, lc_infinity, lc_INFINITY, inifinity_size)
                )
             )
            {
                if( !has_minus ) value = std::numeric_limits<T>::infinity();
                else value = -std::numeric_limits<T>::infinity();
                return true;
            }

            return false;
        }

        template <class CharT, class T>
        bool put_inf_nan_impl(CharT* begin, CharT*& end, const T& value
                         , const CharT* lc_nan
                         , const CharT* lc_infinity) noexcept
        {
            const CharT minus = lcast_char_constants<CharT>::minus;
            if (boost::core::isnan(value)) {
                if (boost::core::signbit(value)) {
                    *begin = minus;
                    ++ begin;
                }

                std::memcpy(begin, lc_nan, 3 * sizeof(CharT));
                end = begin + 3;
                return true;
            } else if (boost::core::isinf(value)) {
                if (boost::core::signbit(value)) {
                    *begin = minus;
                    ++ begin;
                }

                std::memcpy(begin, lc_infinity, 3 * sizeof(CharT));
                end = begin + 3;
                return true;
            }

            return false;
        }



        template <class T>
        bool parse_inf_nan(const wchar_t* begin, const wchar_t* end, T& value) noexcept {
            return parse_inf_nan_impl(begin, end, value
                               , L"NAN", L"nan"
                               , L"INFINITY", L"infinity"
                               , L'(', L')');
        }

        template <class T>
        bool put_inf_nan(wchar_t* begin, wchar_t*& end, const T& value) noexcept {
            return put_inf_nan_impl(begin, end, value, L"nan", L"infinity");
        }



        template <class T>
        bool parse_inf_nan(const char16_t* begin, const char16_t* end, T& value) noexcept {
            return parse_inf_nan_impl(begin, end, value
                               , u"NAN", u"nan"
                               , u"INFINITY", u"infinity"
                               , u'(', u')');
        }

        template <class T>
        bool put_inf_nan(char16_t* begin, char16_t*& end, const T& value) noexcept {
            return put_inf_nan_impl(begin, end, value, u"nan", u"infinity");
        }


        template <class T>
        bool parse_inf_nan(const char32_t* begin, const char32_t* end, T& value) noexcept {
            return parse_inf_nan_impl(begin, end, value
                               , U"NAN", U"nan"
                               , U"INFINITY", U"infinity"
                               , U'(', U')');
        }

        template <class T>
        bool put_inf_nan(char32_t* begin, char32_t*& end, const T& value) noexcept {
            return put_inf_nan_impl(begin, end, value, U"nan", U"infinity");
        }


        template <class CharT, class T>
        bool parse_inf_nan(const CharT* begin, const CharT* end, T& value) noexcept {
            return parse_inf_nan_impl(begin, end, value
                               , "NAN", "nan"
                               , "INFINITY", "infinity"
                               , '(', ')');
        }

        template <class CharT, class T>
        bool put_inf_nan(CharT* begin, CharT*& end, const T& value) noexcept {
            return put_inf_nan_impl(begin, end, value, "nan", "infinity");
        }
    }
}
# 65 "/usr/include/boost/lexical_cast/detail/converter_lexical_streams.hpp" 2 3 4
# 78 "/usr/include/boost/lexical_cast/detail/converter_lexical_streams.hpp" 3 4
# 1 "/usr/include/boost/integer.hpp" 1 3 4
# 18 "/usr/include/boost/integer.hpp" 3 4
# 1 "/usr/include/boost/integer_fwd.hpp" 1 3 4
# 12 "/usr/include/boost/integer_fwd.hpp" 3 4
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/climits" 1 3 4
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/climits" 3
# 13 "/usr/include/boost/integer_fwd.hpp" 2 3 4




# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 18 "/usr/include/boost/integer_fwd.hpp" 2 3 4


namespace boost
{







     typedef boost::uintmax_t static_min_max_unsigned_type;
     typedef boost::intmax_t static_min_max_signed_type;
     typedef boost::uintmax_t static_log2_argument_type;
     typedef int static_log2_result_type;
# 42 "/usr/include/boost/integer_fwd.hpp" 3 4
template < class T >
    class integer_traits;

template < >
    class integer_traits< bool >;

template < >
    class integer_traits< char >;

template < >
    class integer_traits< signed char >;

template < >
    class integer_traits< unsigned char >;


template < >
    class integer_traits< wchar_t >;


template < >
    class integer_traits< short >;

template < >
    class integer_traits< unsigned short >;

template < >
    class integer_traits< int >;

template < >
    class integer_traits< unsigned int >;

template < >
    class integer_traits< long >;

template < >
    class integer_traits< unsigned long >;


template < >
class integer_traits< ::boost::long_long_type>;

template < >
class integer_traits< ::boost::ulong_long_type >;
# 97 "/usr/include/boost/integer_fwd.hpp" 3 4
template < typename LeastInt >
    struct int_fast_t;

template< int Bits >
    struct int_t;

template< int Bits >
    struct uint_t;


    template< boost::long_long_type MaxValue >



    struct int_max_value_t;


  template< boost::long_long_type MinValue >



    struct int_min_value_t;


  template< boost::ulong_long_type MaxValue >



    struct uint_value_t;




template < std::size_t Bit >
    struct high_bit_mask_t;

template < std::size_t Bits >
    struct low_bits_mask_t;

template < >
    struct low_bits_mask_t< ::std::numeric_limits<unsigned char>::digits >;



template <static_log2_argument_type Value >
    struct static_log2;

template <> struct static_log2<0u>;




template <static_min_max_signed_type Value1, static_min_max_signed_type Value2>
    struct static_signed_min;

template <static_min_max_signed_type Value1, static_min_max_signed_type Value2>
    struct static_signed_max;

template <static_min_max_unsigned_type Value1, static_min_max_unsigned_type Value2>
    struct static_unsigned_min;

template <static_min_max_unsigned_type Value1, static_min_max_unsigned_type Value2>
    struct static_unsigned_max;


namespace integer
{





     typedef boost::uintmax_t static_gcd_type;


template < static_gcd_type Value1, static_gcd_type Value2 >
    struct static_gcd;
template < static_gcd_type Value1, static_gcd_type Value2 >
    struct static_lcm;




template < typename IntegerType >
    class gcd_evaluator;
template < typename IntegerType >
    class lcm_evaluator;

}

}
# 19 "/usr/include/boost/integer.hpp" 2 3 4



# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 23 "/usr/include/boost/integer.hpp" 2 3 4
# 35 "/usr/include/boost/integer.hpp" 3


namespace boost
{





  template< typename LeastInt >
  struct int_fast_t
  {
     typedef LeastInt fast;
     typedef fast type;
  };

  namespace detail{


  template< int Category > struct int_least_helper {};
  template< int Category > struct uint_least_helper {};





  template<> struct int_least_helper<1> { typedef boost::long_long_type least; };



  template<> struct int_least_helper<2> { typedef long least; };
  template<> struct int_least_helper<3> { typedef int least; };
  template<> struct int_least_helper<4> { typedef short least; };
  template<> struct int_least_helper<5> { typedef signed char least; };

  template<> struct uint_least_helper<1> { typedef boost::ulong_long_type least; };



  template<> struct uint_least_helper<2> { typedef unsigned long least; };
  template<> struct uint_least_helper<3> { typedef unsigned int least; };
  template<> struct uint_least_helper<4> { typedef unsigned short least; };
  template<> struct uint_least_helper<5> { typedef unsigned char least; };

  template <int Bits>
  struct exact_signed_base_helper{};
  template <int Bits>
  struct exact_unsigned_base_helper{};

  template <> struct exact_signed_base_helper<sizeof(signed char)* 8> { typedef signed char exact; };
  template <> struct exact_unsigned_base_helper<sizeof(unsigned char)* 8> { typedef unsigned char exact; };

  template <> struct exact_signed_base_helper<sizeof(short)* 8> { typedef short exact; };
  template <> struct exact_unsigned_base_helper<sizeof(unsigned short)* 8> { typedef unsigned short exact; };


  template <> struct exact_signed_base_helper<sizeof(int)* 8> { typedef int exact; };
  template <> struct exact_unsigned_base_helper<sizeof(unsigned int)* 8> { typedef unsigned int exact; };



  template <> struct exact_signed_base_helper<sizeof(long)* 8> { typedef long exact; };
  template <> struct exact_unsigned_base_helper<sizeof(unsigned long)* 8> { typedef unsigned long exact; };
# 109 "/usr/include/boost/integer.hpp" 3
  }




  template< int Bits >
  struct int_t : public boost::detail::exact_signed_base_helper<Bits>
  {
      static_assert(Bits <= (int)(sizeof(boost::intmax_t) * 8), "No suitable signed integer type with the requested number of bits is available.");

      typedef typename boost::detail::int_least_helper
        <

          (Bits <= (int)(sizeof(boost::long_long_type) * 8)) +



          (Bits-1 <= ::std::numeric_limits<long>::digits) +
          (Bits-1 <= ::std::numeric_limits<int>::digits) +
          (Bits-1 <= ::std::numeric_limits<short>::digits) +
          (Bits-1 <= ::std::numeric_limits<signed char>::digits)
        >::least least;
      typedef typename int_fast_t<least>::type fast;
  };


  template< int Bits >
  struct uint_t : public boost::detail::exact_unsigned_base_helper<Bits>
  {
     static_assert(Bits <= (int)(sizeof(boost::uintmax_t) * 8), "No suitable unsigned integer type with the requested number of bits is available.");
# 150 "/usr/include/boost/integer.hpp" 3
      typedef typename boost::detail::uint_least_helper
        <

          (Bits <= (int)(sizeof(boost::long_long_type) * 8)) +



          (Bits <= ::std::numeric_limits<unsigned long>::digits) +
          (Bits <= ::std::numeric_limits<unsigned int>::digits) +
          (Bits <= ::std::numeric_limits<unsigned short>::digits) +
          (Bits <= ::std::numeric_limits<unsigned char>::digits)
        >::least least;

      typedef typename int_fast_t<least>::type fast;

  };





  template< boost::long_long_type MaxValue >



  struct int_max_value_t
  {
      typedef typename boost::detail::int_least_helper
        <

          (MaxValue <= ::boost::integer_traits<boost::long_long_type>::const_max) +



          (MaxValue <= ::boost::integer_traits<long>::const_max) +
          (MaxValue <= ::boost::integer_traits<int>::const_max) +
          (MaxValue <= ::boost::integer_traits<short>::const_max) +
          (MaxValue <= ::boost::integer_traits<signed char>::const_max)
        >::least least;
      typedef typename int_fast_t<least>::type fast;
  };


  template< boost::long_long_type MinValue >



  struct int_min_value_t
  {
      typedef typename boost::detail::int_least_helper
        <

          (MinValue >= ::boost::integer_traits<boost::long_long_type>::const_min) +



          (MinValue >= ::boost::integer_traits<long>::const_min) +
          (MinValue >= ::boost::integer_traits<int>::const_min) +
          (MinValue >= ::boost::integer_traits<short>::const_min) +
          (MinValue >= ::boost::integer_traits<signed char>::const_min)
        >::least least;
      typedef typename int_fast_t<least>::type fast;
  };



  template< boost::ulong_long_type MaxValue >



  struct uint_value_t
  {
# 243 "/usr/include/boost/integer.hpp" 3
      typedef typename boost::detail::uint_least_helper
        <

          (MaxValue <= ::boost::integer_traits<boost::ulong_long_type>::const_max) +



          (MaxValue <= ::boost::integer_traits<unsigned long>::const_max) +
          (MaxValue <= ::boost::integer_traits<unsigned int>::const_max) +
          (MaxValue <= ::boost::integer_traits<unsigned short>::const_max) +
          (MaxValue <= ::boost::integer_traits<unsigned char>::const_max)
        >::least least;

      typedef typename int_fast_t<least>::type fast;
  };


}
# 79 "/usr/include/boost/lexical_cast/detail/converter_lexical_streams.hpp" 2 3 4
# 1 "/usr/include/boost/detail/basic_pointerbuf.hpp" 1 3 4
# 24 "/usr/include/boost/detail/basic_pointerbuf.hpp" 3 4
namespace boost { namespace detail {





template <class charT, class BufferT >
class basic_pointerbuf : public BufferT {
protected:
   typedef BufferT base_type;
   typedef basic_pointerbuf<charT, BufferT> this_type;
   typedef typename base_type::int_type int_type;
   typedef typename base_type::char_type char_type;
   typedef typename base_type::pos_type pos_type;
   typedef ::std::streamsize streamsize;
   typedef typename base_type::off_type off_type;

public:
   basic_pointerbuf() : base_type() { this_type::setbuf(0, 0); }
   const charT* getnext() { return this->gptr(); }


    using base_type::pptr;
    using base_type::pbase;





protected:




   inline base_type* setbuf(char_type* s, streamsize n) override;
   inline typename this_type::pos_type seekpos(pos_type sp, ::std::ios_base::openmode which) override;
   inline typename this_type::pos_type seekoff(off_type off, ::std::ios_base::seekdir way, ::std::ios_base::openmode which) override;

private:
   basic_pointerbuf& operator=(const basic_pointerbuf&);
   basic_pointerbuf(const basic_pointerbuf&);
};

template<class charT, class BufferT>
BufferT*
basic_pointerbuf<charT, BufferT>::setbuf(char_type* s, streamsize n)
{
   this->setg(s, s, s + n);
   return this;
}

template<class charT, class BufferT>
typename basic_pointerbuf<charT, BufferT>::pos_type
basic_pointerbuf<charT, BufferT>::seekoff(off_type off, ::std::ios_base::seekdir way, ::std::ios_base::openmode which)
{
   typedef typename boost::int_t<sizeof(way) * 8>::least cast_type;

   if(which & ::std::ios_base::out)
      return pos_type(off_type(-1));
   std::ptrdiff_t size = this->egptr() - this->eback();
   std::ptrdiff_t pos = this->gptr() - this->eback();
   charT* g = this->eback();
   switch(static_cast<cast_type>(way))
   {
   case ::std::ios_base::beg:
      if((off < 0) || (off > size))
         return pos_type(off_type(-1));
      else
         this->setg(g, g + off, g + size);
      break;
   case ::std::ios_base::end:
      if((off < 0) || (off > size))
         return pos_type(off_type(-1));
      else
         this->setg(g, g + size - off, g + size);
      break;
   case ::std::ios_base::cur:
   {
      std::ptrdiff_t newpos = static_cast<std::ptrdiff_t>(pos + off);
      if((newpos < 0) || (newpos > size))
         return pos_type(off_type(-1));
      else
         this->setg(g, g + newpos, g + size);
      break;
   }
   default: ;
   }




   return static_cast<pos_type>(this->gptr() - this->eback());



}

template<class charT, class BufferT>
typename basic_pointerbuf<charT, BufferT>::pos_type
basic_pointerbuf<charT, BufferT>::seekpos(pos_type sp, ::std::ios_base::openmode which)
{
   if(which & ::std::ios_base::out)
      return pos_type(off_type(-1));
   off_type size = static_cast<off_type>(this->egptr() - this->eback());
   charT* g = this->eback();
   if(off_type(sp) <= size)
   {
      this->setg(g, g + off_type(sp), g + size);
   }
   return pos_type(off_type(-1));
}

}}
# 80 "/usr/include/boost/lexical_cast/detail/converter_lexical_streams.hpp" 2 3 4


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cwchar" 1 3 4
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cwchar" 3
# 83 "/usr/include/boost/lexical_cast/detail/converter_lexical_streams.hpp" 2 3 4


namespace boost {

    namespace detail
    {


        template <class BufferType, class CharT>
        class basic_unlockedbuf : public basic_pointerbuf<CharT, BufferType> {
        public:
           typedef basic_pointerbuf<CharT, BufferType> base_type;
           typedef typename base_type::streamsize streamsize;


            using base_type::pptr;
            using base_type::pbase;
            using base_type::setbuf;





        };
    }

    namespace detail
    {
        struct do_not_construct_out_buffer_t{};
        struct do_not_construct_out_stream_t{
            do_not_construct_out_stream_t(do_not_construct_out_buffer_t*){}
        };

        template <class CharT, class Traits>
        struct out_stream_helper_trait {
# 126 "/usr/include/boost/lexical_cast/detail/converter_lexical_streams.hpp" 3 4
            typedef std::basic_ostream<CharT, Traits> out_stream_t;
            typedef basic_unlockedbuf<std::basic_stringbuf<CharT, Traits>, CharT> stringbuffer_t;
            typedef basic_unlockedbuf<std::basic_streambuf<CharT, Traits>, CharT> buffer_t;

        };
    }

    namespace detail
    {
        template< class CharT
                , class Traits
                , bool RequiresStringbuffer
                , std::size_t CharacterBufferSize
                >
        class lexical_istream_limited_src: boost::noncopyable {
            typedef typename boost::conditional<
                RequiresStringbuffer,
                typename out_stream_helper_trait<CharT, Traits>::out_stream_t,
                do_not_construct_out_stream_t
            >::type deduced_out_stream_t;

            typedef typename boost::conditional<
                RequiresStringbuffer,
                typename out_stream_helper_trait<CharT, Traits>::stringbuffer_t,
                do_not_construct_out_buffer_t
            >::type deduced_out_buffer_t;

            deduced_out_buffer_t out_buffer;
            deduced_out_stream_t out_stream;
            CharT buffer[CharacterBufferSize];



            const CharT* start;
            const CharT* finish;

        public:
            lexical_istream_limited_src() noexcept
              : out_buffer()
              , out_stream(&out_buffer)
              , start(buffer)
              , finish(buffer + CharacterBufferSize)
            {}

            const CharT* cbegin() const noexcept {
                return start;
            }

            const CharT* cend() const noexcept {
                return finish;
            }

        private:

            bool shl_char(CharT ch) noexcept {
                Traits::assign(buffer[0], ch);
                finish = start + 1;
                return true;
            }


            template <class T>
            bool shl_char(T ch) {
                static_assert(( sizeof(T) <= sizeof(CharT)) , "boost::lexical_cast does not support narrowing of char types." "Use boost::locale instead");



                std::locale loc;
                CharT const w = std::use_facet< std::ctype<CharT> >(loc).widen(ch);



                Traits::assign(buffer[0], w);
                finish = start + 1;
                return true;
            }


            bool shl_char_array(CharT const* str_value) noexcept {
                start = str_value;
                finish = start + Traits::length(str_value);
                return true;
            }

            template <class T>
            bool shl_char_array(T const* str_value) {
                static_assert(( sizeof(T) <= sizeof(CharT)), "boost::lexical_cast does not support narrowing of char types." "Use boost::locale instead");


                return shl_input_streamable(str_value);
            }

            bool shl_char_array_limited(CharT const* str, std::size_t max_size) noexcept {
                start = str;
                finish = std::find(start, start + max_size, Traits::to_char_type(0));
                return true;
            }

            template<typename InputStreamable>
            bool shl_input_streamable(InputStreamable& input) {







                out_stream.exceptions(std::ios::badbit);
                try {

                bool const result = !(out_stream << input).fail();
                const deduced_out_buffer_t* const p = static_cast<deduced_out_buffer_t*>(
                    out_stream.rdbuf()
                );
                start = p->pbase();
                finish = p->pptr();
                return result;

                } catch (const ::std::ios_base::failure& ) {
                    return false;
                }

            }

            template <class T>
            inline bool shl_unsigned(const T n) {
                CharT* tmp_finish = buffer + CharacterBufferSize;
                start = lcast_put_unsigned<Traits, T, CharT>(n, tmp_finish).convert();
                finish = tmp_finish;
                return true;
            }

            template <class T>
            inline bool shl_signed(const T n) {
                CharT* tmp_finish = buffer + CharacterBufferSize;
                typedef typename boost::make_unsigned<T>::type utype;
                CharT* tmp_start = lcast_put_unsigned<Traits, utype, CharT>(lcast_to_unsigned(n), tmp_finish).convert();
                if (n < 0) {
                    --tmp_start;
                    CharT const minus = lcast_char_constants<CharT>::minus;
                    Traits::assign(*tmp_start, minus);
                }
                start = tmp_start;
                finish = tmp_finish;
                return true;
            }

            template <class T, class SomeCharT>
            bool shl_real_type(const T& val, SomeCharT* ) {
                lcast_set_precision(out_stream, &val);
                return shl_input_streamable(val);
            }

            bool shl_real_type(float val, char* begin) {
                using namespace std;
                const double val_as_double = val;
                finish = start +
                    boost::core::snprintf(begin, CharacterBufferSize,
                    "%.*g", static_cast<int>(boost::detail::lcast_get_precision<float>()), val_as_double);
                return finish > start;
            }

            bool shl_real_type(double val, char* begin) {
                using namespace std;
                finish = start +
                    boost::core::snprintf(begin, CharacterBufferSize,
                    "%.*g", static_cast<int>(boost::detail::lcast_get_precision<double>()), val);
                return finish > start;
            }


            bool shl_real_type(long double val, char* begin) {
                using namespace std;
                finish = start +
                    boost::core::snprintf(begin, CharacterBufferSize,
                    "%.*Lg", static_cast<int>(boost::detail::lcast_get_precision<long double>()), val );
                return finish > start;
            }




            bool shl_real_type(float val, wchar_t* begin) {
                using namespace std;
                const double val_as_double = val;
                finish = start + swprintf(begin, CharacterBufferSize,
                                       L"%.*g",
                                       static_cast<int>(boost::detail::lcast_get_precision<float >()),
                                       val_as_double );
                return finish > start;
            }

            bool shl_real_type(double val, wchar_t* begin) {
                using namespace std;
                finish = start + swprintf(begin, CharacterBufferSize,
                                          L"%.*g", static_cast<int>(boost::detail::lcast_get_precision<double >()), val );
                return finish > start;
            }

            bool shl_real_type(long double val, wchar_t* begin) {
                using namespace std;
                finish = start + swprintf(begin, CharacterBufferSize,
                                          L"%.*Lg", static_cast<int>(boost::detail::lcast_get_precision<long double >()), val );
                return finish > start;
            }

            template <class T>
            bool shl_real(T val) {
                CharT* tmp_finish = buffer + CharacterBufferSize;
                if (put_inf_nan(buffer, tmp_finish, val)) {
                    finish = tmp_finish;
                    return true;
                }

                return shl_real_type(val, static_cast<CharT*>(buffer));
            }


        public:
            template<class Alloc>
            bool operator<<(std::basic_string<CharT,Traits,Alloc> const& str) noexcept {
                start = str.data();
                finish = start + str.length();
                return true;
            }

            template<class Alloc>
            bool operator<<(boost::container::basic_string<CharT,Traits,Alloc> const& str) noexcept {
                start = str.data();
                finish = start + str.length();
                return true;
            }

            bool operator<<(bool value) noexcept {
                CharT const czero = lcast_char_constants<CharT>::zero;
                Traits::assign(buffer[0], Traits::to_char_type(czero + value));
                finish = start + 1;
                return true;
            }

            template <class C>
            typename boost::disable_if<boost::is_const<C>, bool>::type
            operator<<(const iterator_range<C*>& rng) noexcept {
                return (*this) << iterator_range<const C*>(rng.begin(), rng.end());
            }

            bool operator<<(const iterator_range<const CharT*>& rng) noexcept {
                start = rng.begin();
                finish = rng.end();
                return true;
            }

            bool operator<<(const iterator_range<const signed char*>& rng) noexcept {
                return (*this) << iterator_range<const char*>(
                    reinterpret_cast<const char*>(rng.begin()),
                    reinterpret_cast<const char*>(rng.end())
                );
            }

            bool operator<<(const iterator_range<const unsigned char*>& rng) noexcept {
                return (*this) << iterator_range<const char*>(
                    reinterpret_cast<const char*>(rng.begin()),
                    reinterpret_cast<const char*>(rng.end())
                );
            }

            bool operator<<(char ch) { return shl_char(ch); }
            bool operator<<(unsigned char ch) { return ((*this) << static_cast<char>(ch)); }
            bool operator<<(signed char ch) { return ((*this) << static_cast<char>(ch)); }

            bool operator<<(wchar_t const* str) { return shl_char_array(str); }
            bool operator<<(wchar_t * str) { return shl_char_array(str); }

            bool operator<<(wchar_t ch) { return shl_char(ch); }



            bool operator<<(char16_t ch) { return shl_char(ch); }
            bool operator<<(char16_t * str) { return shl_char_array(str); }
            bool operator<<(char16_t const * str) { return shl_char_array(str); }


            bool operator<<(char32_t ch) { return shl_char(ch); }
            bool operator<<(char32_t * str) { return shl_char_array(str); }
            bool operator<<(char32_t const * str) { return shl_char_array(str); }

            bool operator<<(unsigned char const* ch) { return ((*this) << reinterpret_cast<char const*>(ch)); }
            bool operator<<(unsigned char * ch) { return ((*this) << reinterpret_cast<char *>(ch)); }
            bool operator<<(signed char const* ch) { return ((*this) << reinterpret_cast<char const*>(ch)); }
            bool operator<<(signed char * ch) { return ((*this) << reinterpret_cast<char *>(ch)); }
            bool operator<<(char const* str_value) { return shl_char_array(str_value); }
            bool operator<<(char* str_value) { return shl_char_array(str_value); }
            bool operator<<(short n) { return shl_signed(n); }
            bool operator<<(int n) { return shl_signed(n); }
            bool operator<<(long n) { return shl_signed(n); }
            bool operator<<(unsigned short n) { return shl_unsigned(n); }
            bool operator<<(unsigned int n) { return shl_unsigned(n); }
            bool operator<<(unsigned long n) { return shl_unsigned(n); }


            bool operator<<(boost::ulong_long_type n) { return shl_unsigned(n); }
            bool operator<<(boost::long_long_type n) { return shl_signed(n); }






            bool operator<<(const boost::uint128_type& n) { return shl_unsigned(n); }
            bool operator<<(const boost::int128_type& n) { return shl_signed(n); }

            bool operator<<(float val) { return shl_real(val); }
            bool operator<<(double val) { return shl_real(val); }
            bool operator<<(long double val) {

                return shl_real(val);



            }


            template <class C, std::size_t N>
            typename boost::disable_if<boost::is_const<C>, bool>::type
            operator<<(boost::array<C, N> const& input) noexcept {
                static_assert((sizeof(boost::array<const C, N>) == sizeof(boost::array<C, N>)), "boost::array<C, N> and boost::array<const C, N> must have exactly the same layout.");



                return ((*this) << reinterpret_cast<boost::array<const C, N> const& >(input));
            }

            template <std::size_t N>
            bool operator<<(boost::array<const CharT, N> const& input) noexcept {
                return shl_char_array_limited(input.data(), N);
            }

            template <std::size_t N>
            bool operator<<(boost::array<const unsigned char, N> const& input) noexcept {
                return ((*this) << reinterpret_cast<boost::array<const char, N> const& >(input));
            }

            template <std::size_t N>
            bool operator<<(boost::array<const signed char, N> const& input) noexcept {
                return ((*this) << reinterpret_cast<boost::array<const char, N> const& >(input));
            }



            template <class C, std::size_t N>
            bool operator<<(std::array<C, N> const& input) noexcept {
                static_assert((sizeof(std::array<C, N>) == sizeof(boost::array<C, N>)), "std::array and boost::array must have exactly the same layout. " "Bug in implementation of std::array or boost::array.");




                return ((*this) << reinterpret_cast<boost::array<C, N> const& >(input));
            }

            template <class InStreamable>
            bool operator<<(const InStreamable& input) { return shl_input_streamable(input); }
        };


        template <class CharT, class Traits>
        class lexical_ostream_limited_src: boost::noncopyable {

            const CharT* start;
            const CharT* const finish;

        public:
            lexical_ostream_limited_src(const CharT* begin, const CharT* end) noexcept
              : start(begin)
              , finish(end)
            {}


        private:
            template <typename Type>
            bool shr_unsigned(Type& output) {
                if (start == finish) return false;
                CharT const minus = lcast_char_constants<CharT>::minus;
                CharT const plus = lcast_char_constants<CharT>::plus;
                bool const has_minus = Traits::eq(minus, *start);


                if (has_minus || Traits::eq(plus, *start)) {
                    ++start;
                }

                bool const succeed = lcast_ret_unsigned<Traits, Type, CharT>(output, start, finish).convert();

                if (has_minus) {
                    output = static_cast<Type>(0u - output);
                }

                return succeed;
            }

            template <typename Type>
            bool shr_signed(Type& output) {
                if (start == finish) return false;
                CharT const minus = lcast_char_constants<CharT>::minus;
                CharT const plus = lcast_char_constants<CharT>::plus;
                typedef typename make_unsigned<Type>::type utype;
                utype out_tmp = 0;
                bool const has_minus = Traits::eq(minus, *start);


                if (has_minus || Traits::eq(plus, *start)) {
                    ++start;
                }

                bool succeed = lcast_ret_unsigned<Traits, utype, CharT>(out_tmp, start, finish).convert();
                if (has_minus) {
                    utype const comp_val = (static_cast<utype>(1) << std::numeric_limits<Type>::digits);
                    succeed = succeed && out_tmp<=comp_val;
                    output = static_cast<Type>(0u - out_tmp);
                } else {
                    utype const comp_val = static_cast<utype>((std::numeric_limits<Type>::max)());
                    succeed = succeed && out_tmp<=comp_val;
                    output = static_cast<Type>(out_tmp);
                }
                return succeed;
            }

            template<typename InputStreamable>
            bool shr_using_base_class(InputStreamable& output)
            {
                static_assert((!boost::is_pointer<InputStreamable>::value), "boost::lexical_cast can not convert to pointers");
# 570 "/usr/include/boost/lexical_cast/detail/converter_lexical_streams.hpp" 3 4
                typedef typename out_stream_helper_trait<CharT, Traits>::buffer_t buffer_t;
                buffer_t buf;


                buf.setbuf(const_cast<CharT*>(start), static_cast<typename buffer_t::streamsize>(finish - start));



                std::basic_istream<CharT, Traits> stream(&buf);




                stream.exceptions(std::ios::badbit);
                try {

                stream.unsetf(std::ios::skipws);
                lcast_set_precision(stream, static_cast<InputStreamable*>(0));

                return (stream >> output)
                    && (stream.get() == Traits::eof());


                } catch (const ::std::ios_base::failure& ) {
                    return false;
                }

            }

            template<class T>
            inline bool shr_xchar(T& output) noexcept {
                static_assert(( sizeof(CharT) == sizeof(T) ), "boost::lexical_cast does not support narrowing of character types." "Use boost::locale instead");


                bool const ok = (finish - start == 1);
                if (ok) {
                    CharT out;
                    Traits::assign(out, *start);
                    output = static_cast<T>(out);
                }
                return ok;
            }

            template <std::size_t N, class ArrayT>
            bool shr_std_array(ArrayT& output) noexcept {
                using namespace std;
                const std::size_t size = static_cast<std::size_t>(finish - start);
                if (size > N - 1) {
                    return false;
                }

                memcpy(&output[0], start, size * sizeof(CharT));
                output[size] = Traits::to_char_type(0);
                return true;
            }


        public:
            bool operator>>(unsigned short& output) { return shr_unsigned(output); }
            bool operator>>(unsigned int& output) { return shr_unsigned(output); }
            bool operator>>(unsigned long int& output) { return shr_unsigned(output); }
            bool operator>>(short& output) { return shr_signed(output); }
            bool operator>>(int& output) { return shr_signed(output); }
            bool operator>>(long int& output) { return shr_signed(output); }

            bool operator>>(boost::ulong_long_type& output) { return shr_unsigned(output); }
            bool operator>>(boost::long_long_type& output) { return shr_signed(output); }






            bool operator>>(boost::uint128_type& output) { return shr_unsigned(output); }
            bool operator>>(boost::int128_type& output) { return shr_signed(output); }


            bool operator>>(char& output) { return shr_xchar(output); }
            bool operator>>(unsigned char& output) { return shr_xchar(output); }
            bool operator>>(signed char& output) { return shr_xchar(output); }

            bool operator>>(wchar_t& output) { return shr_xchar(output); }


            bool operator>>(char16_t& output) { return shr_xchar(output); }


            bool operator>>(char32_t& output) { return shr_xchar(output); }

            template<class Alloc>
            bool operator>>(std::basic_string<CharT,Traits,Alloc>& str) {
                str.assign(start, finish); return true;
            }

            template<class Alloc>
            bool operator>>(boost::container::basic_string<CharT,Traits,Alloc>& str) {
                str.assign(start, finish); return true;
            }

            template <std::size_t N>
            bool operator>>(boost::array<CharT, N>& output) noexcept {
                return shr_std_array<N>(output);
            }

            template <std::size_t N>
            bool operator>>(boost::array<unsigned char, N>& output) noexcept {
                return ((*this) >> reinterpret_cast<boost::array<char, N>& >(output));
            }

            template <std::size_t N>
            bool operator>>(boost::array<signed char, N>& output) noexcept {
                return ((*this) >> reinterpret_cast<boost::array<char, N>& >(output));
            }


            template <class C, std::size_t N>
            bool operator>>(std::array<C, N>& output) noexcept {
                static_assert((sizeof(std::array<C, N>) == sizeof(boost::array<C, N>)), "std::array<C, N> and boost::array<C, N> must have exactly the same layout.");



                return ((*this) >> reinterpret_cast<boost::array<C, N>& >(output));
            }


            bool operator>>(bool& output) noexcept {
                output = false;

                if (start == finish) return false;
                CharT const zero = lcast_char_constants<CharT>::zero;
                CharT const plus = lcast_char_constants<CharT>::plus;
                CharT const minus = lcast_char_constants<CharT>::minus;

                const CharT* const dec_finish = finish - 1;
                output = Traits::eq(*dec_finish, zero + 1);
                if (!output && !Traits::eq(*dec_finish, zero)) {
                    return false;
                }

                if (start == dec_finish) return true;


                if (Traits::eq(plus, *start) || (Traits::eq(minus, *start) && !output)) {
                    ++ start;
                }


                while (start != dec_finish) {
                    if (!Traits::eq(zero, *start)) {
                        return false;
                    }

                    ++ start;
                }

                return true;
            }

        private:

            template <class T>
            bool float_types_converter_internal(T& output) {
                if (parse_inf_nan(start, finish, output)) return true;
                bool const return_value = shr_using_base_class(output);







                CharT const minus = lcast_char_constants<CharT>::minus;
                CharT const plus = lcast_char_constants<CharT>::plus;
                CharT const capital_e = lcast_char_constants<CharT>::capital_e;
                CharT const lowercase_e = lcast_char_constants<CharT>::lowercase_e;
                if ( return_value &&
                     (
                        Traits::eq(*(finish-1), lowercase_e)
                        || Traits::eq(*(finish-1), capital_e)
                        || Traits::eq(*(finish-1), minus)
                        || Traits::eq(*(finish-1), plus)
                     )
                ) return false;

                return return_value;
            }

        public:
            bool operator>>(float& output) { return float_types_converter_internal(output); }
            bool operator>>(double& output) { return float_types_converter_internal(output); }
            bool operator>>(long double& output) { return float_types_converter_internal(output); }



            template <typename InputStreamable>
            bool operator>>(InputStreamable& output) {
                return shr_using_base_class(output);
            }
        };
    }
}
# 55 "/usr/include/boost/lexical_cast/detail/converter_lexical.hpp" 2 3 4

namespace boost {

    namespace detail
    {

        template < class Char >
        struct normalize_single_byte_char
        {
            typedef Char type;
        };

        template <>
        struct normalize_single_byte_char< signed char >
        {
            typedef char type;
        };

        template <>
        struct normalize_single_byte_char< unsigned char >
        {
            typedef char type;
        };
    }

    namespace detail
    {


        template < class T > struct deduce_character_type_later {};
    }

    namespace detail
    {



        template < typename Type >
        struct stream_char_common: public boost::conditional<
            boost::detail::is_character< Type >::value,
            Type,
            boost::detail::deduce_character_type_later< Type >
        > {};

        template < typename Char >
        struct stream_char_common< Char* >: public boost::conditional<
            boost::detail::is_character< Char >::value,
            Char,
            boost::detail::deduce_character_type_later< Char* >
        > {};

        template < typename Char >
        struct stream_char_common< const Char* >: public boost::conditional<
            boost::detail::is_character< Char >::value,
            Char,
            boost::detail::deduce_character_type_later< const Char* >
        > {};

        template < typename Char >
        struct stream_char_common< boost::iterator_range< Char* > >: public boost::conditional<
            boost::detail::is_character< Char >::value,
            Char,
            boost::detail::deduce_character_type_later< boost::iterator_range< Char* > >
        > {};

        template < typename Char >
        struct stream_char_common< boost::iterator_range< const Char* > >: public boost::conditional<
            boost::detail::is_character< Char >::value,
            Char,
            boost::detail::deduce_character_type_later< boost::iterator_range< const Char* > >
        > {};

        template < class Char, class Traits, class Alloc >
        struct stream_char_common< std::basic_string< Char, Traits, Alloc > >
        {
            typedef Char type;
        };

        template < class Char, class Traits, class Alloc >
        struct stream_char_common< boost::container::basic_string< Char, Traits, Alloc > >
        {
            typedef Char type;
        };

        template < typename Char, std::size_t N >
        struct stream_char_common< boost::array< Char, N > >: public boost::conditional<
            boost::detail::is_character< Char >::value,
            Char,
            boost::detail::deduce_character_type_later< boost::array< Char, N > >
        > {};

        template < typename Char, std::size_t N >
        struct stream_char_common< boost::array< const Char, N > >: public boost::conditional<
            boost::detail::is_character< Char >::value,
            Char,
            boost::detail::deduce_character_type_later< boost::array< const Char, N > >
        > {};


        template < typename Char, std::size_t N >
        struct stream_char_common< std::array<Char, N > >: public boost::conditional<
            boost::detail::is_character< Char >::value,
            Char,
            boost::detail::deduce_character_type_later< std::array< Char, N > >
        > {};

        template < typename Char, std::size_t N >
        struct stream_char_common< std::array< const Char, N > >: public boost::conditional<
            boost::detail::is_character< Char >::value,
            Char,
            boost::detail::deduce_character_type_later< std::array< const Char, N > >
        > {};



        template <> struct stream_char_common< boost::int128_type >: public boost::type_identity< char > {};
        template <> struct stream_char_common< boost::uint128_type >: public boost::type_identity< char > {};
# 181 "/usr/include/boost/lexical_cast/detail/converter_lexical.hpp" 3 4
    }

    namespace detail
    {





        template < class Char >
        struct deduce_source_char_impl
        {
            typedef typename boost::detail::normalize_single_byte_char< Char >::type type;
        };

        template < class T >
        struct deduce_source_char_impl< deduce_character_type_later< T > >
        {
            typedef boost::has_left_shift< std::basic_ostream< char >, T > result_t;






            typedef typename boost::conditional<
                result_t::value, char, wchar_t
            >::type type;

            static_assert((result_t::value || boost::has_left_shift< std::basic_ostream< type >, T >::value), "Source type is neither std::ostream`able nor std::wostream`able");


        };
    }

    namespace detail
    {





        template < class Char >
        struct deduce_target_char_impl
        {
            typedef typename normalize_single_byte_char< Char >::type type;
        };

        template < class T >
        struct deduce_target_char_impl< deduce_character_type_later<T> >
        {
            typedef boost::has_right_shift<std::basic_istream<char>, T > result_t;






            typedef typename boost::conditional<
                result_t::value, char, wchar_t
            >::type type;

            static_assert((result_t::value || boost::has_right_shift<std::basic_istream<wchar_t>, T >::value), "Target type is neither std::istream`able nor std::wistream`able");


        };
    }

    namespace detail
    {
# 266 "/usr/include/boost/lexical_cast/detail/converter_lexical.hpp" 3 4
        template < class T >
        struct deduce_target_char
        {
            typedef typename stream_char_common< T >::type stage1_type;
            typedef typename deduce_target_char_impl< stage1_type >::type stage2_type;

            typedef stage2_type type;
        };

        template < class T >
        struct deduce_source_char
        {
            typedef typename stream_char_common< T >::type stage1_type;
            typedef typename deduce_source_char_impl< stage1_type >::type stage2_type;

            typedef stage2_type type;
        };
    }

    namespace detail
    {


        template < class Char, class T >
        struct extract_char_traits
                : boost::false_type
        {
            typedef std::char_traits< Char > trait_t;
        };

        template < class Char, class Traits, class Alloc >
        struct extract_char_traits< Char, std::basic_string< Char, Traits, Alloc > >
            : boost::true_type
        {
            typedef Traits trait_t;
        };

        template < class Char, class Traits, class Alloc>
        struct extract_char_traits< Char, boost::container::basic_string< Char, Traits, Alloc > >
            : boost::true_type
        {
            typedef Traits trait_t;
        };
    }

    namespace detail
    {
        template<class T>
        struct array_to_pointer_decay
        {
            typedef T type;
        };

        template<class T, std::size_t N>
        struct array_to_pointer_decay<T[N]>
        {
            typedef const T * type;
        };
    }

    namespace detail
    {

        template< class Source,
                  class Enable = void
                >
        struct lcast_src_length
        {
            static const std::size_t value = 1;
        };
# 350 "/usr/include/boost/lexical_cast/detail/converter_lexical.hpp" 3 4
        template <class Source>
        struct lcast_src_length<
                    Source, typename boost::enable_if<boost::is_integral<Source> >::type
                >
        {

            static const std::size_t value = std::numeric_limits<Source>::is_signed + std::numeric_limits<Source>::is_specialized + std::numeric_limits<Source>::digits10 * 2;
# 365 "/usr/include/boost/lexical_cast/detail/converter_lexical.hpp" 3 4
        };
# 377 "/usr/include/boost/lexical_cast/detail/converter_lexical.hpp" 3 4
        template<class Source>
        struct lcast_src_length<
                Source, typename boost::enable_if<boost::is_float<Source> >::type
            >
        {


            static_assert(std::numeric_limits<Source>::max_exponent10 <= 999999L && std::numeric_limits<Source>::min_exponent10 >= -999999L, "std::numeric_limits<Source>::max_exponent10 <= 999999L && std::numeric_limits<Source>::min_exponent10 >= -999999L");




            static const std::size_t value = 5 + lcast_precision<Source>::value + 6;





        };
    }

    namespace detail
    {
        template <class Source, class Target>
        struct lexical_cast_stream_traits {
            typedef typename boost::detail::array_to_pointer_decay<Source>::type src;
            typedef typename boost::remove_cv<src>::type no_cv_src;

            typedef boost::detail::deduce_source_char<no_cv_src> deduce_src_char_metafunc;
            typedef typename deduce_src_char_metafunc::type src_char_t;
            typedef typename boost::detail::deduce_target_char<Target>::type target_char_t;

            typedef typename boost::detail::widest_char<
                target_char_t, src_char_t
            >::type char_type;
# 424 "/usr/include/boost/lexical_cast/detail/converter_lexical.hpp" 3 4
            typedef typename boost::conditional<
                boost::detail::extract_char_traits<char_type, Target>::value,
                typename boost::detail::extract_char_traits<char_type, Target>,
                typename boost::detail::extract_char_traits<char_type, no_cv_src>
            >::type::trait_t traits;

            typedef boost::integral_constant<
              bool,
              boost::is_same<char, src_char_t>::value &&
                (sizeof(char) != sizeof(target_char_t)) &&
                (!(boost::detail::is_character<no_cv_src>::value))
                > is_string_widening_required_t;

            typedef boost::integral_constant<
              bool,
                !(boost::is_integral<no_cv_src>::value ||
                  boost::detail::is_character<
                    typename deduce_src_char_metafunc::stage1_type
                  >::value
                 )
                > is_source_input_not_optimized_t;



            static const bool requires_stringbuf = (is_string_widening_required_t::value || is_source_input_not_optimized_t::value);



            typedef boost::detail::lcast_src_length<no_cv_src> len_t;
        };
    }

    namespace detail
    {
        template<typename Target, typename Source>
        struct lexical_converter_impl
        {
            typedef lexical_cast_stream_traits<Source, Target> stream_trait;

            typedef detail::lexical_istream_limited_src<
                typename stream_trait::char_type,
                typename stream_trait::traits,
                stream_trait::requires_stringbuf,
                stream_trait::len_t::value + 1
            > i_interpreter_type;

            typedef detail::lexical_ostream_limited_src<
                typename stream_trait::char_type,
                typename stream_trait::traits
            > o_interpreter_type;

            static inline bool try_convert(const Source& arg, Target& result) {
                i_interpreter_type i_interpreter;


                if (!(i_interpreter.operator <<(arg)))
                    return false;

                o_interpreter_type out(i_interpreter.cbegin(), i_interpreter.cend());


                if(!(out.operator >>(result)))
                    return false;

                return true;
            }
        };
    }

}
# 45 "/usr/include/boost/lexical_cast/try_lexical_convert.hpp" 2 3 4




namespace boost {
    namespace detail
    {
        template<typename T>
        struct is_stdstring
            : boost::false_type
        {};

        template<typename CharT, typename Traits, typename Alloc>
        struct is_stdstring< std::basic_string<CharT, Traits, Alloc> >
            : boost::true_type
        {};



        template<typename T>
        struct is_booststring
            : boost::false_type
        {};

        template<typename CharT, typename Traits, typename Alloc>
        struct is_booststring< boost::container::basic_string<CharT, Traits, Alloc> >
            : boost::true_type
        {};

        template<typename Target, typename Source>
        struct is_arithmetic_and_not_xchars
        {
            typedef boost::integral_constant<
                bool,
                !(boost::detail::is_character<Target>::value) &&
                    !(boost::detail::is_character<Source>::value) &&
                    boost::is_arithmetic<Source>::value &&
                    boost::is_arithmetic<Target>::value
                > type;

            static const bool value = ( type::value );


        };





        template<typename Target, typename Source>
        struct is_xchar_to_xchar
        {
            typedef boost::integral_constant<
                bool,
                sizeof(Source) == sizeof(Target) &&
                     sizeof(Source) == sizeof(char) &&
                     boost::detail::is_character<Target>::value &&
                     boost::detail::is_character<Source>::value
                > type;

            static const bool value = ( type::value );


        };

        template<typename Target, typename Source>
        struct is_char_array_to_stdstring
            : boost::false_type
        {};

        template<typename CharT, typename Traits, typename Alloc>
        struct is_char_array_to_stdstring< std::basic_string<CharT, Traits, Alloc>, CharT* >
            : boost::true_type
        {};

        template<typename CharT, typename Traits, typename Alloc>
        struct is_char_array_to_stdstring< std::basic_string<CharT, Traits, Alloc>, const CharT* >
            : boost::true_type
        {};



        template<typename Target, typename Source>
        struct is_char_array_to_booststring
            : boost::false_type
        {};

        template<typename CharT, typename Traits, typename Alloc>
        struct is_char_array_to_booststring< boost::container::basic_string<CharT, Traits, Alloc>, CharT* >
            : boost::true_type
        {};

        template<typename CharT, typename Traits, typename Alloc>
        struct is_char_array_to_booststring< boost::container::basic_string<CharT, Traits, Alloc>, const CharT* >
            : boost::true_type
        {};

        template <typename Target, typename Source>
        struct copy_converter_impl
        {



            template <class T>
            static inline bool try_convert(T&& arg, Target& result) {
                result = static_cast<T&&>(arg);
                return true;
            }






        };
    }

    namespace conversion { namespace detail {

        template <typename Target, typename Source>
        inline bool try_lexical_convert(const Source& arg, Target& result)
        {
            typedef typename boost::detail::array_to_pointer_decay<Source>::type src;

            typedef boost::integral_constant<
                bool,
                boost::detail::is_xchar_to_xchar<Target, src >::value ||
                boost::detail::is_char_array_to_stdstring<Target, src >::value ||
                boost::detail::is_char_array_to_booststring<Target, src >::value ||
                (
                     boost::is_same<Target, src >::value &&
                     (boost::detail::is_stdstring<Target >::value || boost::detail::is_booststring<Target >::value)
                ) ||
                (
                     boost::is_same<Target, src >::value &&
                     boost::detail::is_character<Target >::value
                )
            > shall_we_copy_t;

            typedef boost::detail::is_arithmetic_and_not_xchars<Target, src >
                shall_we_copy_with_dynamic_check_t;



            typedef typename boost::conditional<
                shall_we_copy_t::value,
                boost::type_identity<boost::detail::copy_converter_impl<Target, src > >,
                boost::conditional<
                     shall_we_copy_with_dynamic_check_t::value,
                     boost::detail::dynamic_num_converter_impl<Target, src >,
                     boost::detail::lexical_converter_impl<Target, src >
                >
            >::type caster_type_lazy;

            typedef typename caster_type_lazy::type caster_type;

            return caster_type::try_convert(arg, result);
        }

        template <typename Target, typename CharacterT>
        inline bool try_lexical_convert(const CharacterT* chars, std::size_t count, Target& result)
        {
            static_assert(boost::detail::is_character<CharacterT>::value, "This overload of try_lexical_convert is meant to be used only with arrays of characters.");



            return ::boost::conversion::detail::try_lexical_convert(
                ::boost::iterator_range<const CharacterT*>(chars, chars + count), result
            );
        }

    }}

    namespace conversion {

        using ::boost::conversion::detail::try_lexical_convert;
    }

}




#pragma GCC diagnostic pop
# 51 "/usr/include/boost/lexical_cast.hpp" 2 3 4

namespace boost
{
    template <typename Target, typename Source>
    inline Target lexical_cast(const Source &arg)
    {
        Target result = Target();

        if (!boost::conversion::detail::try_lexical_convert(arg, result)) {
            boost::conversion::detail::throw_bad_cast<Source, Target>();
        }

        return result;
    }

    template <typename Target>
    inline Target lexical_cast(const char* chars, std::size_t count)
    {
        return ::boost::lexical_cast<Target>(
            ::boost::iterator_range<const char*>(chars, chars + count)
        );
    }

    template <typename Target>
    inline Target lexical_cast(const unsigned char* chars, std::size_t count)
    {
        return ::boost::lexical_cast<Target>(
            ::boost::iterator_range<const unsigned char*>(chars, chars + count)
        );
    }

    template <typename Target>
    inline Target lexical_cast(const signed char* chars, std::size_t count)
    {
        return ::boost::lexical_cast<Target>(
            ::boost::iterator_range<const signed char*>(chars, chars + count)
        );
    }


    template <typename Target>
    inline Target lexical_cast(const wchar_t* chars, std::size_t count)
    {
        return ::boost::lexical_cast<Target>(
            ::boost::iterator_range<const wchar_t*>(chars, chars + count)
        );
    }


    template <typename Target>
    inline Target lexical_cast(const char16_t* chars, std::size_t count)
    {
        return ::boost::lexical_cast<Target>(
            ::boost::iterator_range<const char16_t*>(chars, chars + count)
        );
    }


    template <typename Target>
    inline Target lexical_cast(const char32_t* chars, std::size_t count)
    {
        return ::boost::lexical_cast<Target>(
            ::boost::iterator_range<const char32_t*>(chars, chars + count)
        );
    }


}
# 39 "/home/avi/scylla-maint/seastar/include/seastar/util/log.hh" 2







namespace seastar {
# 55 "/home/avi/scylla-maint/seastar/include/seastar/util/log.hh"
enum class log_level {
    error,
    warn,
    info,
    debug,
    trace,
};

std::ostream& operator<<(std::ostream& out, log_level level);
std::istream& operator>>(std::istream& in, log_level& level);


}

template <>
struct fmt::formatter<seastar::log_level> {
    constexpr auto parse(format_parse_context& ctx) { return ctx.begin(); }
    auto format(seastar::log_level level, fmt::format_context& ctx) const -> decltype(ctx.out());
};



namespace boost {
template<>
seastar::log_level lexical_cast(const std::string& source);

}

namespace seastar {

class logger;
class logger_registry;
# 99 "/home/avi/scylla-maint/seastar/include/seastar/util/log.hh"
class logger {
    sstring _name;
    std::atomic<log_level> _level = { log_level::info };
    static std::ostream* _out;
    static std::atomic<bool> _ostream;
    static std::atomic<bool> _syslog;
    static unsigned _shard_field_width;



    static inline thread_local bool silent = false;


public:
    class log_writer {
    public:
        virtual ~log_writer() = default;
        virtual internal::log_buf::inserter_iterator operator()(internal::log_buf::inserter_iterator) = 0;
    };
    template <typename Func>
    requires requires (Func fn, internal::log_buf::inserter_iterator it) {
        it = fn(it);
    }
    class lambda_log_writer : public log_writer {
        Func _func;
    public:
        lambda_log_writer(Func&& func) : _func(std::forward<Func>(func)) { }
        virtual ~lambda_log_writer() override = default;
        virtual internal::log_buf::inserter_iterator operator()(internal::log_buf::inserter_iterator it) override { return _func(it); }
    };




    template<typename... Args>
    struct format_info {


        template<
            typename S,
            std::enable_if_t<std::is_convertible_v<const S&, std::string_view>, int> = 0>
        consteval inline format_info(const S& format,
                           compat::source_location loc = compat::source_location::current()) noexcept
            : format(format)
            , loc(loc)
        {}




        inline format_info(fmt::format_string<Args...> s,
                           compat::source_location loc = compat::source_location::current()) noexcept
            : format(s)
            , loc(loc)
        {}

        using runtime_format_string_t = fmt::runtime_format_string<char>;



        inline format_info(runtime_format_string_t s,
                           compat::source_location loc = compat::source_location::current()) noexcept
            : format(s)
            , loc(loc)
        {}

        consteval format_info() noexcept
            : format_info("")
        {}
        fmt::format_string<Args...> format;
        compat::source_location loc;
    };

    template <typename T>
    using type_identity_t = typename std::type_identity<T>::type;




    template <typename... Args>
    using format_info_t = format_info<type_identity_t<Args>...>;
# 210 "/home/avi/scylla-maint/seastar/include/seastar/util/log.hh"
private:


    void do_log(log_level level, log_writer& writer);
    void failed_to_log(std::exception_ptr ex,
                       fmt::string_view fmt,
                       compat::source_location loc) noexcept;

    class silencer {
    public:
        silencer() noexcept {
            silent = true;
        }

        ~silencer() {
            silent = false;
        }
    };

public:
# 251 "/home/avi/scylla-maint/seastar/include/seastar/util/log.hh"
    class rate_limit {
        friend class logger;

        using clock = lowres_clock;

    private:
        clock::duration _interval;
        clock::time_point _next;
        uint64_t _dropped_messages = 0;

    private:
        bool check();
        bool has_dropped_messages() const { return bool(_dropped_messages); }
        uint64_t get_and_reset_dropped_messages() {
            return std::exchange(_dropped_messages, 0);
        }

    public:
        explicit rate_limit(std::chrono::milliseconds interval);
    };

public:
    explicit logger(sstring name);
    logger(logger&& x);
    ~logger();

    bool is_shard_zero() noexcept;





    bool is_enabled(log_level level) const noexcept {
        return __builtin_expect(level <= _level.load(std::memory_order_relaxed), false) && !silent;
    }







    template <typename... Args>
    void log(log_level level, format_info_t<Args...> fmt, Args&&... args) noexcept {
        if (is_enabled(level)) {
            try {
                lambda_log_writer writer([&] (internal::log_buf::inserter_iterator it) {

                    return fmt::format_to(it, fmt.format, std::forward<Args>(args)...);



                });
                do_log(level, writer);
            } catch (...) {
                failed_to_log(std::current_exception(), fmt::string_view(fmt.format), fmt.loc);
            }
        }
    }
# 325 "/home/avi/scylla-maint/seastar/include/seastar/util/log.hh"
    template <typename... Args>
    void log(log_level level, rate_limit& rl, format_info_t<Args...> fmt, Args&&... args) noexcept {
        if (is_enabled(level) && rl.check()) {
            try {
                lambda_log_writer writer([&] (internal::log_buf::inserter_iterator it) {
                    if (rl.has_dropped_messages()) {
                        it = fmt::format_to(it, "(rate limiting dropped {} similar messages) ", rl.get_and_reset_dropped_messages());
                    }

                    return fmt::format_to(it, fmt::runtime(fmt.format), std::forward<Args>(args)...);



                });
                do_log(level, writer);
            } catch (...) {
                failed_to_log(std::current_exception(), fmt::string_view(fmt.format), fmt.loc);
            }
        }
    }
# 356 "/home/avi/scylla-maint/seastar/include/seastar/util/log.hh"
    void log(log_level level, rate_limit& rl, log_writer& writer, format_info_t<> fmt = {}) noexcept {
        if (is_enabled(level) && rl.check()) {
            try {
                lambda_log_writer writer_wrapper([&] (internal::log_buf::inserter_iterator it) {
                    if (rl.has_dropped_messages()) {
                        it = fmt::format_to(it, "(rate limiting dropped {} similar messages) ", rl.get_and_reset_dropped_messages());
                    }
                    return writer(it);
                });
                do_log(level, writer_wrapper);
            } catch (...) {
                failed_to_log(std::current_exception(), "", fmt.loc);
            }
        }
    }
# 380 "/home/avi/scylla-maint/seastar/include/seastar/util/log.hh"
    template <typename... Args>
    void error(format_info_t<Args...> fmt, Args&&... args) noexcept {
        log(log_level::error, std::move(fmt), std::forward<Args>(args)...);
    }







    template <typename... Args>
    void warn(format_info_t<Args...> fmt, Args&&... args) noexcept {
        log(log_level::warn, std::move(fmt), std::forward<Args>(args)...);
    }







    template <typename... Args>
    void info(format_info_t<Args...> fmt, Args&&... args) noexcept {
        log(log_level::info, std::move(fmt), std::forward<Args>(args)...);
    }







    template <typename... Args>
    void info0(format_info_t<Args...> fmt, Args&&... args) noexcept {
        if (is_shard_zero()) {
            log(log_level::info, std::move(fmt), std::forward<Args>(args)...);
        }
    }







    template <typename... Args>
    void debug(format_info_t<Args...> fmt, Args&&... args) noexcept {
        log(log_level::debug, std::move(fmt), std::forward<Args>(args)...);
    }







    template <typename... Args>
    void trace(format_info_t<Args...> fmt, Args&&... args) noexcept {
        log(log_level::trace, std::move(fmt), std::forward<Args>(args)...);
    }



    const sstring& name() const noexcept {
        return _name;
    }



    log_level level() const noexcept {
        return _level.load(std::memory_order_relaxed);
    }



    void set_level(log_level level) noexcept {
        _level.store(level, std::memory_order_relaxed);
    }


    static void set_ostream(std::ostream& out) noexcept;


    static void set_ostream_enabled(bool enabled) noexcept;


    [[deprecated("Use set_ostream_enabled instead")]]
    static void set_stdout_enabled(bool enabled) noexcept;






    static void set_syslog_enabled(bool enabled) noexcept;
# 484 "/home/avi/scylla-maint/seastar/include/seastar/util/log.hh"
    static void set_shard_field_width(unsigned width) noexcept;




    static void set_with_color(bool enabled) noexcept;
};
# 500 "/home/avi/scylla-maint/seastar/include/seastar/util/log.hh"
class logger_registry {
    mutable std::mutex _mutex;
    std::unordered_map<sstring, logger*> _loggers;
public:




    void set_all_loggers_level(log_level level);





    log_level get_logger_level(sstring name) const;






    void set_logger_level(sstring name, log_level level);





    std::vector<sstring> get_all_logger_names();




    void register_logger(logger* l);



    void unregister_logger(logger* l);



    void moved(logger* from, logger* to);
};

logger_registry& global_logger_registry();


enum class logger_timestamp_style {
    none,
    boot,
    real,
};


enum class logger_ostream_type {
    none,

    stdout __attribute__ ((deprecated ("use cout instead"))) = 1,
    stderr __attribute__ ((deprecated ("use cerr instead"))) = 2,

    cout = 1,
    cerr = 2,
};

struct logging_settings final {
    std::unordered_map<sstring, log_level> logger_levels;
    log_level default_level;
    bool stdout_enabled;
    bool syslog_enabled;
    bool with_color;
    logger_timestamp_style stdout_timestamp_style = logger_timestamp_style::real;
    logger_ostream_type logger_ostream = logger_ostream_type::cerr;
};



void apply_logging_settings(const logging_settings&);





extern thread_local uint64_t logging_failures;

sstring pretty_type_name(const std::type_info&);

sstring level_name(log_level level);

template <typename T>
class logger_for : public logger {
public:
    logger_for() : logger(pretty_type_name(typeid(T))) {}
};


}


namespace std {
std::ostream& operator<<(std::ostream&, const std::exception_ptr&);
std::ostream& operator<<(std::ostream&, const std::exception&);
std::ostream& operator<<(std::ostream&, const std::system_error&);
}


template <> struct fmt::formatter<std::exception_ptr> : fmt::ostream_formatter {};
template <> struct fmt::formatter<std::exception> : fmt::ostream_formatter {};
template <> struct fmt::formatter<std::system_error> : fmt::ostream_formatter {};
# 32 "/home/avi/scylla-maint/seastar/include/seastar/core/sharded.hh" 2



# 1 "/usr/include/boost/iterator/counting_iterator.hpp" 1 3 4
# 21 "/usr/include/boost/iterator/counting_iterator.hpp" 3 4
# 1 "/usr/include/boost/detail/numeric_traits.hpp" 1 3 4
# 64 "/usr/include/boost/detail/numeric_traits.hpp" 3 4
# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 65 "/usr/include/boost/detail/numeric_traits.hpp" 2 3 4







namespace boost { namespace detail {





  template <class T, bool IsSpecialized = std::numeric_limits<T>::is_specialized>
  struct digit_traits
  {
      static const int digits = std::numeric_limits<T>::digits;
  };


  template <class T>
  struct digit_traits<T, false>
  {
      static const int digits = ( sizeof(T) * std::numeric_limits<unsigned char>::digits - (boost::is_signed<T>::value ? 1 : 0));



  };





  template <class Integer>
  struct integer_traits
  {

   private:
      typedef Integer integer_type;
      typedef std::numeric_limits<integer_type> x;
   public:
      typedef typename boost::conditional<
        (int(x::is_signed)
          && (!int(x::is_bounded)

             || (int(x::digits) + 1 >= digit_traits<boost::intmax_t>::digits))),
        Integer,

        typename boost::conditional<
          (int(x::digits) + 1 < digit_traits<signed int>::digits),
          signed int,

          typename boost::conditional<
            (int(x::digits) + 1 < digit_traits<signed long>::digits),
            signed long,
            boost::intmax_t
          >::type
        >::type
      >::type difference_type;
# 143 "/usr/include/boost/detail/numeric_traits.hpp" 3 4
  };


  template <class Number>
  struct numeric_traits
  {
      typedef typename integer_traits<Number>::difference_type difference_type;
  };

  template <class Number>
  inline constexpr typename numeric_traits<Number>::difference_type numeric_distance(Number x, Number y)
  {
      typedef typename numeric_traits<Number>::difference_type difference_type;
      return difference_type(y) - difference_type(x);
  }
}}
# 22 "/usr/include/boost/iterator/counting_iterator.hpp" 2 3 4


namespace boost {
namespace iterators {

template <
    class Incrementable
  , class CategoryOrTraversal
  , class Difference
>
class counting_iterator;

namespace detail
{


  template <class T>
  struct is_numeric_impl
  {

      static_assert(::boost::is_integral<char>::value, "::boost::is_integral<char>::value");



      static const bool value = std::numeric_limits<T>::is_specialized;
# 61 "/usr/include/boost/iterator/counting_iterator.hpp" 3 4
  };

  template <class T>
  struct is_numeric
    : boost::integral_constant<bool, ::boost::iterators::detail::is_numeric_impl<T>::value>
  {};


  template <>
  struct is_numeric<boost::long_long_type>
    : boost::true_type {};

  template <>
  struct is_numeric<boost::ulong_long_type>
    : boost::true_type {};



  template <>
  struct is_numeric<boost::int128_type>
    : boost::true_type {};

  template <>
  struct is_numeric<boost::uint128_type>
    : boost::true_type {};



  template <>
  struct is_numeric<wchar_t>
    : true_type {};

  template <class T>
  struct numeric_difference
  {
      typedef typename boost::detail::numeric_traits<T>::difference_type type;
  };



  template <>
  struct numeric_difference<boost::int128_type>
  {
      typedef boost::int128_type type;
  };

  template <>
  struct numeric_difference<boost::uint128_type>
  {
      typedef boost::int128_type type;
  };


  template <class Incrementable, class CategoryOrTraversal, class Difference>
  struct counting_iterator_base
  {
      typedef typename detail::ia_dflt_help<
          CategoryOrTraversal
        , typename boost::conditional<
              is_numeric<Incrementable>::value
            , boost::type_identity<random_access_traversal_tag>
            , iterator_traversal<Incrementable>
          >::type
      >::type traversal;

      typedef typename detail::ia_dflt_help<
          Difference
        , typename boost::conditional<
              is_numeric<Incrementable>::value
            , numeric_difference<Incrementable>
            , iterator_difference<Incrementable>
          >::type
      >::type difference;

      typedef iterator_adaptor<
          counting_iterator<Incrementable, CategoryOrTraversal, Difference>
        , Incrementable
        , Incrementable




        , traversal
        , Incrementable const&
        , difference
      > type;
  };






  template <bool is_integer> struct distance_policy_select;


  template <class Difference, class Incrementable1, class Incrementable2>
  struct iterator_distance
  {
      static Difference distance(Incrementable1 x, Incrementable2 y)
      {
          return y - x;
      }
  };


  template <class Difference, class Incrementable1, class Incrementable2>
  struct number_distance
  {
      static Difference distance(Incrementable1 x, Incrementable2 y)
      {
          return boost::detail::numeric_distance(x, y);
      }
  };
}

template <
    class Incrementable
  , class CategoryOrTraversal = use_default
  , class Difference = use_default
>
class counting_iterator
  : public detail::counting_iterator_base<
        Incrementable, CategoryOrTraversal, Difference
    >::type
{
    typedef typename detail::counting_iterator_base<
        Incrementable, CategoryOrTraversal, Difference
    >::type super_t;

    friend class iterator_core_access;

 public:
    typedef typename super_t::difference_type difference_type;

    counting_iterator() = default;

    counting_iterator(counting_iterator const& rhs) = default;

    counting_iterator(Incrementable x)
      : super_t(x)
    {
    }
# 215 "/usr/include/boost/iterator/counting_iterator.hpp" 3 4
    counting_iterator& operator=(counting_iterator const& rhs) = default;

 private:

    typename super_t::reference dereference() const
    {
        return this->base_reference();
    }

    template <class OtherIncrementable>
    difference_type
    distance_to(counting_iterator<OtherIncrementable, CategoryOrTraversal, Difference> const& y) const
    {
        typedef typename boost::conditional<
            detail::is_numeric<Incrementable>::value
          , detail::number_distance<difference_type, Incrementable, OtherIncrementable>
          , detail::iterator_distance<difference_type, Incrementable, OtherIncrementable>
        >::type d;

        return d::distance(this->base(), y.base());
    }
};


template <class Incrementable>
inline counting_iterator<Incrementable>
make_counting_iterator(Incrementable x)
{
    typedef counting_iterator<Incrementable> result_t;
    return result_t(x);
}

}

using iterators::counting_iterator;
using iterators::make_counting_iterator;

}
# 36 "/home/avi/scylla-maint/seastar/include/seastar/core/sharded.hh" 2
# 50 "/home/avi/scylla-maint/seastar/include/seastar/core/sharded.hh"
namespace seastar {



template <typename Func, typename... Param>
class sharded_parameter;

template <typename Service>
class sharded;



namespace internal {

template <typename Func, typename... Param>
auto unwrap_sharded_arg(sharded_parameter<Func, Param...> sp);

using on_each_shard_func = std::function<future<> (unsigned shard)>;

future<> sharded_parallel_for_each(unsigned nr_shards, on_each_shard_func on_each_shard) noexcept(std::is_nothrow_move_constructible_v<on_each_shard_func>);

template <typename Service>
class either_sharded_or_local {
    sharded<Service>& _sharded;
public:
    either_sharded_or_local(sharded<Service>& s) : _sharded(s) {}
    operator sharded<Service>& ();
    operator Service& ();
};

template <typename T>
struct sharded_unwrap {
    using evaluated_type = T;
    using type = T;
};

template <typename T>
struct sharded_unwrap<std::reference_wrapper<sharded<T>>> {
    using evaluated_type = T&;
    using type = either_sharded_or_local<T>;
};

template <typename Func, typename... Param>
struct sharded_unwrap<sharded_parameter<Func, Param...>> {
    using type = std::invoke_result_t<Func, Param...>;
};

template <typename T>
using sharded_unwrap_evaluated_t = typename sharded_unwrap<T>::evaluated_type;

template <typename T>
using sharded_unwrap_t = typename sharded_unwrap<T>::type;

}







template <typename T>
class sharded;






template<typename T>
class async_sharded_service : public enable_shared_from_this<T> {
    promise<> _freed;
protected:
    async_sharded_service() noexcept = default;
    virtual ~async_sharded_service() {
        _freed.set_value();
    }
    future<> freed() noexcept {
        return _freed.get_future();
    }
    template <typename Service> friend class sharded;
};







template <typename Service>
class peering_sharded_service {
    sharded<Service>* _container = nullptr;
private:
    template <typename T> friend class sharded;
    void set_container(sharded<Service>* container) noexcept { _container = container; }
public:
    peering_sharded_service() noexcept = default;
    peering_sharded_service(peering_sharded_service<Service>&&) noexcept = default;
    peering_sharded_service(const peering_sharded_service<Service>&) = delete;
    peering_sharded_service& operator=(const peering_sharded_service<Service>&) = delete;
    sharded<Service>& container() noexcept { return *_container; }
    const sharded<Service>& container() const noexcept { return *_container; }
};



class no_sharded_instance_exception : public std::exception {
    sstring _msg;
public:
    no_sharded_instance_exception() : _msg("sharded instance does not exist") {}
    explicit no_sharded_instance_exception(sstring type_info)
        : _msg("sharded instance does not exist: " + type_info) {}
    virtual const char* what() const noexcept override {
        return _msg.c_str();
    }
};
# 176 "/home/avi/scylla-maint/seastar/include/seastar/core/sharded.hh"
template <typename Service>
class sharded {
    struct entry {
        shared_ptr<Service> service;

        future<> track_deletion() noexcept {

            if constexpr (std::is_base_of_v<async_sharded_service<Service>, Service>) {
                if (service) {
                    return service->freed();
                }
            }
            return make_ready_future<>();
        }
    };
    std::vector<entry> _instances;
private:
    using invoke_on_all_func_type = std::function<future<> (Service&)>;
private:
    template <typename U, bool async>
    friend struct shared_ptr_make_helper;

    template <typename T>
    std::enable_if_t<std::is_base_of_v<peering_sharded_service<T>, T>>
    set_container(T& service) noexcept {
        service.set_container(this);
    }

    template <typename T>
    std::enable_if_t<!std::is_base_of_v<peering_sharded_service<T>, T>>
    set_container(T&) noexcept {
    }

    future<>
    sharded_parallel_for_each(internal::on_each_shard_func func) noexcept(std::is_nothrow_move_constructible_v<internal::on_each_shard_func>) {
        return internal::sharded_parallel_for_each(_instances.size(), std::move(func));
    }
public:


    sharded() noexcept {}
    sharded(const sharded& other) = delete;
    sharded& operator=(const sharded& other) = delete;


    sharded(sharded&& other) = delete;
    sharded& operator=(sharded&& other) = delete;

    ~sharded();







    template <typename... Args>
    future<> start(Args&&... args) noexcept;







    template <typename... Args>
    future<> start_single(Args&&... args) noexcept;





    future<> stop() noexcept;
# 258 "/home/avi/scylla-maint/seastar/include/seastar/core/sharded.hh"
    future<> invoke_on_all(smp_submit_to_options options, std::function<future<> (Service&)> func) noexcept;






    future<> invoke_on_all(std::function<future<> (Service&)> func) noexcept {
      try {
        return invoke_on_all(smp_submit_to_options{}, std::move(func));
      } catch (...) {
        return current_exception_as_future();
      }
    }
# 287 "/home/avi/scylla-maint/seastar/include/seastar/core/sharded.hh"
    template <typename Func, typename... Args>
    requires std::invocable<Func, Service&, internal::sharded_unwrap_t<Args>...>
    future<> invoke_on_all(smp_submit_to_options options, Func func, Args... args) noexcept;






    template <typename Func, typename... Args>
    requires std::invocable<Func, Service&, internal::sharded_unwrap_t<Args>...>
    future<> invoke_on_all(Func func, Args... args) noexcept {
      try {
        return invoke_on_all(smp_submit_to_options{}, std::move(func), std::move(args)...);
      } catch (...) {
        return current_exception_as_future();
      }
    }
# 316 "/home/avi/scylla-maint/seastar/include/seastar/core/sharded.hh"
    template <typename Func, typename... Args>
    requires std::invocable<Func, Service&, Args...>
    future<> invoke_on_others(smp_submit_to_options options, Func func, Args... args) noexcept;
# 331 "/home/avi/scylla-maint/seastar/include/seastar/core/sharded.hh"
    template <typename Func, typename... Args>
    requires std::invocable<Func, Service&, Args...>
    future<> invoke_on_others(Func func, Args... args) noexcept {
      try {
        return invoke_on_others(smp_submit_to_options{}, std::move(func), std::move(args)...);
      } catch (...) {
        return current_exception_as_future();
      }
    }





    template <typename Reducer, typename Func, typename... Args>
    inline
    auto map_reduce(Reducer&& r, Func&& func, Args&&... args) -> typename reducer_traits<Reducer>::future_type
    {
        return ::seastar::map_reduce(boost::make_counting_iterator<unsigned>(0),
                            boost::make_counting_iterator<unsigned>(_instances.size()),
            [this, func = std::forward<Func>(func), args = std::make_tuple(std::forward<Args>(args)...)] (unsigned c) mutable {
                return smp::submit_to(c, [this, &func, args] () mutable {
                    return std::apply([this, &func] (Args&&... args) mutable {
                        auto inst = get_local_service();
                        return std::invoke(func, *inst, std::forward<Args>(args)...);
                    }, std::move(args));
                });
            }, std::forward<Reducer>(r));
    }


    template <typename Reducer, typename Func, typename... Args>
    inline
    auto map_reduce(Reducer&& r, Func&& func, Args&&... args) const -> typename reducer_traits<Reducer>::future_type
    {
        return ::seastar::map_reduce(boost::make_counting_iterator<unsigned>(0),
                            boost::make_counting_iterator<unsigned>(_instances.size()),
            [this, func = std::forward<Func>(func), args = std::make_tuple(std::forward<Args>(args)...)] (unsigned c) {
                return smp::submit_to(c, [this, &func, args] () {
                    return std::apply([this, &func] (Args&&... args) {
                        auto inst = get_local_service();
                        return std::invoke(func, *inst, std::forward<Args>(args)...);
                    }, std::move(args));
                });
            }, std::forward<Reducer>(r));
    }
# 394 "/home/avi/scylla-maint/seastar/include/seastar/core/sharded.hh"
    template <typename Mapper, typename Initial, typename Reduce>
    inline
    future<Initial>
    map_reduce0(Mapper map, Initial initial, Reduce reduce) {
        auto wrapped_map = [this, map] (unsigned c) {
            return smp::submit_to(c, [this, map] {
                auto inst = get_local_service();
                return std::invoke(map, *inst);
            });
        };
        return ::seastar::map_reduce(smp::all_cpus().begin(), smp::all_cpus().end(),
                            std::move(wrapped_map),
                            std::move(initial),
                            std::move(reduce));
    }


    template <typename Mapper, typename Initial, typename Reduce>
    inline
    future<Initial>
    map_reduce0(Mapper map, Initial initial, Reduce reduce) const {
        auto wrapped_map = [this, map] (unsigned c) {
            return smp::submit_to(c, [this, map] {
                auto inst = get_local_service();
                return std::invoke(map, *inst);
            });
        };
        return ::seastar::map_reduce(smp::all_cpus().begin(), smp::all_cpus().end(),
                            std::move(wrapped_map),
                            std::move(initial),
                            std::move(reduce));
    }
# 436 "/home/avi/scylla-maint/seastar/include/seastar/core/sharded.hh"
    template <typename Mapper, typename Future = futurize_t<std::invoke_result_t<Mapper,Service&>>, typename return_type = decltype(internal::untuple(std::declval<typename Future::tuple_type>()))>
    inline future<std::vector<return_type>> map(Mapper mapper) {
        return do_with(std::vector<return_type>(), std::move(mapper),
                [this] (std::vector<return_type>& vec, Mapper& mapper) mutable {
            vec.resize(_instances.size());
            return parallel_for_each(boost::irange<unsigned>(0, _instances.size()), [this, &vec, &mapper] (unsigned c) {
                return smp::submit_to(c, [this, &mapper] {
                    auto inst = get_local_service();
                    return mapper(*inst);
                }).then([&vec, c] (auto&& res) {
                    vec[c] = std::move(res);
                });
            }).then([&vec] {
                return make_ready_future<std::vector<return_type>>(std::move(vec));
            });
        });
    }
# 466 "/home/avi/scylla-maint/seastar/include/seastar/core/sharded.hh"
    template <typename Func, typename... Args, typename Ret = futurize_t<std::invoke_result_t<Func, Service&, Args...>>>
    requires std::invocable<Func, Service&, Args&&...>
    Ret
    invoke_on(unsigned id, smp_submit_to_options options, Func&& func, Args&&... args) {
        return smp::submit_to(id, options, [this, func = std::forward<Func>(func), args = std::tuple(std::move(args)...)] () mutable {
            auto inst = get_local_service();
            return std::apply(std::forward<Func>(func), std::tuple_cat(std::forward_as_tuple(*inst), std::move(args)));
        });
    }
# 484 "/home/avi/scylla-maint/seastar/include/seastar/core/sharded.hh"
    template <typename Func, typename... Args, typename Ret = futurize_t<std::invoke_result_t<Func, Service&, Args&&...>>>
    requires std::invocable<Func, Service&, Args&&...>
    Ret
    invoke_on(unsigned id, Func&& func, Args&&... args) {
        return invoke_on(id, smp_submit_to_options(), std::forward<Func>(func), std::forward<Args>(args)...);
    }


    const Service& local() const noexcept;


    Service& local() noexcept;


    shared_ptr<Service> local_shared() noexcept;


    bool local_is_initialized() const noexcept;

private:
    template <typename... Args>
    shared_ptr<Service> create_local_service(Args&&... args) {
        auto s = ::seastar::make_shared<Service>(std::forward<Args>(args)...);
        set_container(*s);
        return s;
    }

    shared_ptr<Service> get_local_service() {
        auto inst = _instances[this_shard_id()].service;
        if (!inst) {
            throw no_sharded_instance_exception(pretty_type_name(typeid(Service)));
        }
        return inst;
    }

    shared_ptr<const Service> get_local_service() const {
        auto inst = _instances[this_shard_id()].service;
        if (!inst) {
            throw no_sharded_instance_exception(pretty_type_name(typeid(Service)));
        }
        return inst;
    }
};






template <typename Func, typename... Params>
class sharded_parameter {
    Func _func;
    std::tuple<Params...> _params;
public:
# 546 "/home/avi/scylla-maint/seastar/include/seastar/core/sharded.hh"
    explicit sharded_parameter(Func func, Params... params)
            requires std::invocable<Func, internal::sharded_unwrap_evaluated_t<Params>...>
            : _func(std::move(func)), _params(std::make_tuple(std::move(params)...)) {
    }
private:
    auto evaluate() const;

    template <typename Func_, typename... Param_>
    friend auto internal::unwrap_sharded_arg(sharded_parameter<Func_, Param_...> sp);
};







template <typename Service>
sharded<Service>::~sharded() {
 (static_cast <bool> (_instances.empty()) ? void (0) : __assert_fail ("_instances.empty()", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
}

namespace internal {

template <typename T>
inline
T&&
unwrap_sharded_arg(T&& arg) {
    return std::forward<T>(arg);
}

template <typename Service>
either_sharded_or_local<Service>
unwrap_sharded_arg(std::reference_wrapper<sharded<Service>> arg) {
    return either_sharded_or_local<Service>(arg);
}

template <typename Func, typename... Param>
auto
unwrap_sharded_arg(sharded_parameter<Func, Param...> sp) {
    return sp.evaluate();
}

template <typename Service>
either_sharded_or_local<Service>::operator sharded<Service>& () { return _sharded; }

template <typename Service>
either_sharded_or_local<Service>::operator Service& () { return _sharded.local(); }

}

template <typename Func, typename... Param>
auto
sharded_parameter<Func, Param...>::evaluate() const {
    auto unwrap_params_and_invoke = [this] (const auto&... params) {
        return std::invoke(_func, internal::unwrap_sharded_arg(params)...);
    };
    return std::apply(unwrap_params_and_invoke, _params);
}

template <typename Service>
template <typename... Args>
future<>
sharded<Service>::start(Args&&... args) noexcept {
  try {
    _instances.resize(smp::count);
    return sharded_parallel_for_each(
        [this, args = std::make_tuple(std::forward<Args>(args)...)] (unsigned c) mutable {
            return smp::submit_to(c, [this, args] () mutable {
                _instances[this_shard_id()].service = std::apply([this] (Args... args) {
                    return create_local_service(internal::unwrap_sharded_arg(std::forward<Args>(args))...);
                }, args);
            });
    }).then_wrapped([this] (future<> f) {
        try {
            f.get();
            return make_ready_future<>();
        } catch (...) {
            return this->stop().then([e = std::current_exception()] () mutable {
                std::rethrow_exception(e);
            });
        }
    });
  } catch (...) {
    return current_exception_as_future();
  }
}

template <typename Service>
template <typename... Args>
future<>
sharded<Service>::start_single(Args&&... args) noexcept {
  try {
    (static_cast <bool> (_instances.empty()) ? void (0) : __assert_fail ("_instances.empty()", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
    _instances.resize(1);
    return smp::submit_to(0, [this, args = std::make_tuple(std::forward<Args>(args)...)] () mutable {
        _instances[0].service = std::apply([this] (Args... args) {
            return create_local_service(internal::unwrap_sharded_arg(std::forward<Args>(args))...);
        }, args);
    }).then_wrapped([this] (future<> f) {
        try {
            f.get();
            return make_ready_future<>();
        } catch (...) {
            return this->stop().then([e = std::current_exception()] () mutable {
                std::rethrow_exception(e);
            });
        }
    });
  } catch (...) {
    return current_exception_as_future();
  }
}

namespace internal {



struct sharded_has_stop {




    template <typename Service>
    constexpr static auto check(int) -> std::enable_if_t<(sizeof(&Service::stop) >= 0), bool> {
        return true;
    }


    template<typename>
    static constexpr auto check(...) -> bool {
        return false;
    }
};

template <bool stop_exists>
struct sharded_call_stop {
    template <typename Service>
    static future<> call(Service& instance);
};

template <>
template <typename Service>
inline
future<> sharded_call_stop<true>::call(Service& instance) {
    return instance.stop();
}

template <>
template <typename Service>
inline
future<> sharded_call_stop<false>::call(Service&) {
    return make_ready_future<>();
}

template <typename Service>
inline
future<>
stop_sharded_instance(Service& instance) {
    constexpr bool has_stop = internal::sharded_has_stop::check<Service>(0);
    return internal::sharded_call_stop<has_stop>::call(instance);
}

}

template <typename Service>
future<>
sharded<Service>::stop() noexcept {
  try {
    return sharded_parallel_for_each([this] (unsigned c) mutable {
        return smp::submit_to(c, [this] () mutable {
            auto inst = _instances[this_shard_id()].service;
            if (!inst) {
                return make_ready_future<>();
            }
            return internal::stop_sharded_instance(*inst);
        });
    }).then_wrapped([this] (future<> fut) {
        return sharded_parallel_for_each([this] (unsigned c) {
            return smp::submit_to(c, [this] {
                auto fut = _instances[this_shard_id()].track_deletion();
                _instances[this_shard_id()].service = nullptr;
                return fut;
            });
        }).finally([this, fut = std::move(fut)] () mutable {
            _instances.clear();
            _instances = std::vector<sharded<Service>::entry>();
            return std::move(fut);
        });
    });
  } catch (...) {
    return current_exception_as_future();
  }
}

template <typename Service>
future<>
sharded<Service>::invoke_on_all(smp_submit_to_options options, std::function<future<> (Service&)> func) noexcept {
  try {
    return sharded_parallel_for_each([this, options, func = std::move(func)] (unsigned c) {
        return smp::submit_to(c, options, [this, func] {
            return func(*get_local_service());
        });
    });
  } catch (...) {
    return current_exception_as_future();
  }
}

template <typename Service>
template <typename Func, typename... Args>
requires std::invocable<Func, Service&, internal::sharded_unwrap_t<Args>...>
inline
future<>
sharded<Service>::invoke_on_all(smp_submit_to_options options, Func func, Args... args) noexcept {
    static_assert(std::is_same_v<futurize_t<std::invoke_result_t<Func, Service&, internal::sharded_unwrap_t<Args>...>>, future<>>,
                  "invoke_on_all()'s func must return void or future<>");
  try {
    return invoke_on_all(options, invoke_on_all_func_type([func = std::move(func), args = std::tuple(std::move(args)...)] (Service& service) mutable {
        return std::apply([&service, &func] (Args&&... args) mutable {
            return futurize_apply(func, std::tuple_cat(std::forward_as_tuple(service), std::tuple(internal::unwrap_sharded_arg(std::forward<Args>(args))...)));
        }, std::move(args));
    }));
  } catch (...) {
    return current_exception_as_future();
  }
}

template <typename Service>
template <typename Func, typename... Args>
requires std::invocable<Func, Service&, Args...>
inline
future<>
sharded<Service>::invoke_on_others(smp_submit_to_options options, Func func, Args... args) noexcept {
    static_assert(std::is_same_v<futurize_t<std::invoke_result_t<Func, Service&, Args...>>, future<>>,
                  "invoke_on_others()'s func must return void or future<>");
  try {
    return invoke_on_all(options, [orig = this_shard_id(), func = std::move(func), args = std::tuple(std::move(args)...)] (Service& s) mutable -> future<> {
        return this_shard_id() == orig ? make_ready_future<>() : futurize_apply(func, std::tuple_cat(std::forward_as_tuple(s), args));;
    });
  } catch (...) {
    return current_exception_as_future();
  }
}

template <typename Service>
const Service& sharded<Service>::local() const noexcept {
    (static_cast <bool> (local_is_initialized()) ? void (0) : __assert_fail ("local_is_initialized()", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
    return *_instances[this_shard_id()].service;
}

template <typename Service>
Service& sharded<Service>::local() noexcept {
    (static_cast <bool> (local_is_initialized()) ? void (0) : __assert_fail ("local_is_initialized()", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
    return *_instances[this_shard_id()].service;
}

template <typename Service>
shared_ptr<Service> sharded<Service>::local_shared() noexcept {
    (static_cast <bool> (local_is_initialized()) ? void (0) : __assert_fail ("local_is_initialized()", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
    return _instances[this_shard_id()].service;
}

template <typename Service>
inline bool sharded<Service>::local_is_initialized() const noexcept {
    return _instances.size() > this_shard_id() &&
           _instances[this_shard_id()].service;
}
# 840 "/home/avi/scylla-maint/seastar/include/seastar/core/sharded.hh"
template <typename PtrType>
requires (!std::is_pointer_v<PtrType>)
class foreign_ptr {
private:
    PtrType _value;
    unsigned _cpu;
private:
    void destroy(PtrType p, unsigned cpu) noexcept {



        auto f = destroy_on(std::move(p), cpu);
        if (!f.available() || f.failed()) {
            internal::run_in_background(std::move(f));
        }
    }

    static future<> destroy_on(PtrType p, unsigned cpu) noexcept {
        if (p) {
            if (cpu != this_shard_id()) {
                return smp::submit_to(cpu, [v = std::move(p)] () mutable {



                    v = {};
                });
            } else {
                p = {};
            }
        }
        return make_ready_future<>();
    }
public:
    using element_type = typename std::pointer_traits<PtrType>::element_type;
    using pointer = element_type*;


    foreign_ptr() noexcept(std::is_nothrow_default_constructible_v<PtrType>)
        : _value(PtrType())
        , _cpu(this_shard_id()) {
    }

    foreign_ptr(std::nullptr_t) noexcept(std::is_nothrow_default_constructible_v<foreign_ptr>) : foreign_ptr() {}

    foreign_ptr(PtrType value) noexcept(std::is_nothrow_move_constructible_v<PtrType>)
        : _value(std::move(value))
        , _cpu(this_shard_id()) {
    }


    foreign_ptr(const foreign_ptr&) = delete;

    foreign_ptr(foreign_ptr&& other) noexcept(std::is_nothrow_move_constructible_v<PtrType>) = default;

    ~foreign_ptr() {
        destroy(std::move(_value), _cpu);
    }

    future<foreign_ptr> copy() const noexcept {
        return smp::submit_to(_cpu, [this] () mutable {
            auto v = _value;
            return make_foreign(std::move(v));
        });
    }

    element_type& operator*() const noexcept(noexcept(*_value)) { return *_value; }

    element_type* operator->() const noexcept(noexcept(&*_value)) { return &*_value; }

    pointer get() const noexcept(noexcept(&*_value)) { return &*_value; }




    unsigned get_owner_shard() const noexcept { return _cpu; }

    operator bool() const noexcept(noexcept(static_cast<bool>(_value))) { return static_cast<bool>(_value); }

    foreign_ptr& operator=(foreign_ptr&& other) noexcept(std::is_nothrow_move_constructible_v<PtrType>) {
         destroy(std::move(_value), _cpu);
        _value = std::move(other._value);
        _cpu = other._cpu;
        return *this;
    }





    PtrType release() noexcept(std::is_nothrow_default_constructible_v<PtrType>) {
        return std::exchange(_value, {});
    }



    void reset(PtrType new_ptr) noexcept(std::is_nothrow_move_constructible_v<PtrType>) {
        auto old_ptr = std::move(_value);
        auto old_cpu = _cpu;

        _value = std::move(new_ptr);
        _cpu = this_shard_id();

        destroy(std::move(old_ptr), old_cpu);
    }



    void reset(std::nullptr_t = nullptr) noexcept(std::is_nothrow_default_constructible_v<PtrType>) {
        reset(PtrType());
    }




    future<> destroy() noexcept {
        return destroy_on(std::move(_value), _cpu);
    }
};




template <typename T>
foreign_ptr<T> make_foreign(T ptr) {
    return foreign_ptr<T>(std::move(ptr));
}



template<typename T>
struct is_smart_ptr<foreign_ptr<T>> : std::true_type {};



}
# 44 "/home/avi/scylla-maint/seastar/include/seastar/rpc/rpc_types.hh" 2

namespace seastar {

namespace rpc {

using rpc_clock_type = lowres_clock;


template<typename T>
using type = boost::type<T>;

struct stats {
    using counter_type = uint64_t;
    counter_type replied = 0;
    counter_type pending = 0;
    counter_type exception_received = 0;
    counter_type sent_messages = 0;
    counter_type wait_reply = 0;
    counter_type timeout = 0;
};

class connection_id {
    uint64_t _id;

public:
    uint64_t id() const {
        return _id;
    }
    bool operator==(const connection_id& o) const {
        return _id == o._id;
    }
    explicit operator bool() const {
        return shard() != 0xffff;
    }
    size_t shard() const {
        return size_t(_id & 0xffff);
    }
    constexpr static connection_id make_invalid_id(uint64_t _id = 0) {
        return make_id(_id, 0xffff);
    }
    constexpr static connection_id make_id(uint64_t _id, uint16_t shard) {
        return {_id << 16 | shard};
    }
    constexpr connection_id(uint64_t id) : _id(id) {}
};

constexpr connection_id invalid_connection_id = connection_id::make_invalid_id();

std::ostream& operator<<(std::ostream&, const connection_id&);

class server;

struct client_info {
    socket_address addr;
    rpc::server& server;
    connection_id conn_id;
    std::unordered_map<sstring, boost::any> user_data;
    template <typename T>
    void attach_auxiliary(const sstring& key, T&& object) {
        user_data.emplace(key, boost::any(std::forward<T>(object)));
    }
    template <typename T>
    T& retrieve_auxiliary(const sstring& key) {
        auto it = user_data.find(key);
        (static_cast <bool> (it != user_data.end()) ? void (0) : __assert_fail ("it != user_data.end()", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        return boost::any_cast<T&>(it->second);
    }
    template <typename T>
    std::add_const_t<T>& retrieve_auxiliary(const sstring& key) const {
        return const_cast<client_info*>(this)->retrieve_auxiliary<std::add_const_t<T>>(key);
    }
    template <typename T>
    T* retrieve_auxiliary_opt(const sstring& key) noexcept {
        auto it = user_data.find(key);
        if (it == user_data.end()) {
            return nullptr;
        }
        return &boost::any_cast<T&>(it->second);
    }
    template <typename T>
    const T* retrieve_auxiliary_opt(const sstring& key) const noexcept {
        auto it = user_data.find(key);
        if (it == user_data.end()) {
            return nullptr;
        }
        return &boost::any_cast<const T&>(it->second);
    }
};

class error : public std::runtime_error {
public:
    error(const std::string& msg) : std::runtime_error(msg) {}
};

class closed_error : public error {
public:
    closed_error() : error("connection is closed") {}
};

class timeout_error : public error {
public:
    timeout_error() : error("rpc call timed out") {}
};

class unknown_verb_error : public error {
public:
    uint64_t type;
    unknown_verb_error(uint64_t type_) : error("unknown verb"), type(type_) {}
};

class unknown_exception_error : public error {
public:
    unknown_exception_error() : error("unknown exception") {}
};

class rpc_protocol_error : public error {
public:
    rpc_protocol_error() : error("rpc protocol exception") {}
};

class canceled_error : public error {
public:
    canceled_error() : error("rpc call was canceled") {}
};

class stream_closed : public error {
public:
    stream_closed() : error("rpc stream was closed by peer") {}
};

class remote_verb_error : public error {
    using error::error;
};

struct no_wait_type {};


extern no_wait_type no_wait;




template <typename T>
class optional : public std::optional<T> {
public:
     using std::optional<T>::optional;
};

class opt_time_point : public std::optional<rpc_clock_type::time_point> {
public:
     using std::optional<rpc_clock_type::time_point>::optional;
     opt_time_point(std::optional<rpc_clock_type::time_point> time_point) {
         static_cast<std::optional<rpc_clock_type::time_point>&>(*this) = time_point;
     }
};



struct cancellable {
    std::function<void()> cancel_send;
    std::function<void()> cancel_wait;
    cancellable** send_back_pointer = nullptr;
    cancellable** wait_back_pointer = nullptr;
    cancellable() = default;
    cancellable(cancellable&& x) : cancel_send(std::move(x.cancel_send)), cancel_wait(std::move(x.cancel_wait)), send_back_pointer(x.send_back_pointer), wait_back_pointer(x.wait_back_pointer) {
        if (send_back_pointer) {
            *send_back_pointer = this;
            x.send_back_pointer = nullptr;
        }
        if (wait_back_pointer) {
            *wait_back_pointer = this;
            x.wait_back_pointer = nullptr;
        }
    }
    cancellable& operator=(cancellable&& x) {
        if (&x != this) {
            this->~cancellable();
            new (this) cancellable(std::move(x));
        }
        return *this;
    }
    void cancel() {
        if (cancel_send) {
            cancel_send();
        }
        if (cancel_wait) {
            cancel_wait();
        }
    }
    ~cancellable() {
        cancel();
    }
};

struct rcv_buf {
    uint32_t size = 0;
    std::optional<semaphore_units<>> su;
    std::variant<std::vector<temporary_buffer<char>>, temporary_buffer<char>> bufs;
    using iterator = std::vector<temporary_buffer<char>>::iterator;
    rcv_buf() {}
    explicit rcv_buf(size_t size_) : size(size_) {}
    explicit rcv_buf(temporary_buffer<char> b) : size(b.size()), bufs(std::move(b)) {};
    explicit rcv_buf(std::vector<temporary_buffer<char>> bufs, size_t size)
        : size(size), bufs(std::move(bufs)) {};
};

struct snd_buf {

    static constexpr size_t chunk_size = 128*1024;
    uint32_t size = 0;
    std::variant<std::vector<temporary_buffer<char>>, temporary_buffer<char>> bufs;
    using iterator = std::vector<temporary_buffer<char>>::iterator;
    snd_buf() {}
    snd_buf(snd_buf&&) noexcept;
    snd_buf& operator=(snd_buf&&) noexcept;
    explicit snd_buf(size_t size_);
    explicit snd_buf(temporary_buffer<char> b) : size(b.size()), bufs(std::move(b)) {};

    explicit snd_buf(std::vector<temporary_buffer<char>> bufs, size_t size)
        : size(size), bufs(std::move(bufs)) {};

    temporary_buffer<char>& front();
};

static inline memory_input_stream<rcv_buf::iterator> make_deserializer_stream(rcv_buf& input) {
    auto* b = std::get_if<temporary_buffer<char>>(&input.bufs);
    if (b) {
        return memory_input_stream<rcv_buf::iterator>(memory_input_stream<rcv_buf::iterator>::simple(b->begin(), b->size()));
    } else {
        auto& ar = std::get<std::vector<temporary_buffer<char>>>(input.bufs);
        return memory_input_stream<rcv_buf::iterator>(memory_input_stream<rcv_buf::iterator>::fragmented(ar.begin(), input.size));
    }
}

class compressor {
public:
    virtual ~compressor() {}

    virtual snd_buf compress(size_t head_space, snd_buf data) = 0;

    virtual rcv_buf decompress(rcv_buf data) = 0;
    virtual sstring name() const = 0;
    virtual future<> close() noexcept { return make_ready_future<>(); };


    class factory {
    public:
        virtual ~factory() {}

        virtual const sstring& supported() const = 0;




        virtual std::unique_ptr<compressor> negotiate(sstring feature, bool is_server, std::function<future<>()> send_empty_frame) const {
            return negotiate(feature, is_server);
        }
        virtual std::unique_ptr<compressor> negotiate(sstring feature, bool is_server) const = 0;
    };
};

class connection;

using xshard_connection_ptr = lw_shared_ptr<foreign_ptr<shared_ptr<connection>>>;
constexpr size_t max_queued_stream_buffers = 50;
constexpr size_t max_stream_buffers_memory = 100 * 1024;





template<typename... Out>
class sink {
public:
    class impl {
    protected:
        xshard_connection_ptr _con;
        semaphore _sem;
        std::exception_ptr _ex;
        impl(xshard_connection_ptr con) : _con(std::move(con)), _sem(max_stream_buffers_memory) {}
    public:
        virtual ~impl() {};
        virtual future<> operator()(const Out&... args) = 0;
        virtual future<> close() = 0;
        virtual future<> flush() = 0;
        friend sink;
    };

private:
    shared_ptr<impl> _impl;

public:
    sink(shared_ptr<impl> impl) : _impl(std::move(impl)) {}
    future<> operator()(const Out&... args) {
        return _impl->operator()(args...);
    }
    future<> close() {
        return _impl->close();
    }




    future<> flush() {
        return _impl->flush();
    }
    connection_id get_id() const;
};


template<typename... In>
class source {
public:
    class impl {
    protected:
        xshard_connection_ptr _con;
        circular_buffer<foreign_ptr<std::unique_ptr<rcv_buf>>> _bufs;
        impl(xshard_connection_ptr con) : _con(std::move(con)) {
            _bufs.reserve(max_queued_stream_buffers);
        }
    public:
        virtual ~impl() {}
        virtual future<std::optional<std::tuple<In...>>> operator()() = 0;
        friend source;
    };
private:
    shared_ptr<impl> _impl;

public:
    source(shared_ptr<impl> impl) : _impl(std::move(impl)) {}
    future<std::optional<std::tuple<In...>>> operator()() {
        return _impl->operator()();
    };
    connection_id get_id() const;
    template<typename Serializer, typename... Out> sink<Out...> make_sink();
};
# 395 "/home/avi/scylla-maint/seastar/include/seastar/rpc/rpc_types.hh"
template <typename... T>
class tuple : public std::tuple<T...> {
public:
    using std::tuple<T...>::tuple;
    tuple(std::tuple<T...>&& x) : std::tuple<T...>(std::move(x)) {}
};



template <typename... T>
tuple(T&&...) -> tuple<T...>;

}

}

namespace std {
template<>
struct hash<seastar::rpc::connection_id> {
    size_t operator()(const seastar::rpc::connection_id& id) const {
        size_t h = 0;
        boost::hash_combine(h, std::hash<uint64_t>{}(id.id()));
        return h;
    }
};

template <typename... T>
struct tuple_size<seastar::rpc::tuple<T...>> : tuple_size<tuple<T...>> {
};

template <size_t I, typename... T>
struct tuple_element<I, seastar::rpc::tuple<T...>> : tuple_element<I, tuple<T...>> {
};

}


template <> struct fmt::formatter<seastar::rpc::connection_id> : fmt::ostream_formatter {};
# 458 "/home/avi/scylla-maint/seastar/include/seastar/rpc/rpc_types.hh"
template <typename T>
struct fmt::formatter<seastar::rpc::optional<T>> : private fmt::formatter<std::optional<T>> {
    using fmt::formatter<std::optional<T>>::parse;
    auto format(const seastar::rpc::optional<T>& opt, fmt::format_context& ctx) const {
        return fmt::formatter<std::optional<T>>::format(opt, ctx);
    }
};
# 37 "/home/avi/scylla-maint/seastar/include/seastar/rpc/rpc.hh" 2
# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/byteorder.hh" 1
# 26 "/home/avi/scylla-maint/seastar/include/seastar/core/byteorder.hh"
# 1 "/usr/include/boost/endian/conversion.hpp" 1 3 4
# 11 "/usr/include/boost/endian/conversion.hpp" 3 4
# 1 "/usr/include/boost/endian/detail/requires_cxx11.hpp" 1 3 4
# 12 "/usr/include/boost/endian/conversion.hpp" 2 3 4
# 1 "/usr/include/boost/endian/detail/endian_reverse.hpp" 1 3 4







# 1 "/usr/include/boost/endian/detail/integral_by_size.hpp" 1 3 4








# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 10 "/usr/include/boost/endian/detail/integral_by_size.hpp" 2 3 4



namespace boost
{
namespace endian
{
namespace detail
{

template<std::size_t N> struct integral_by_size
{
};

template<> struct integral_by_size<1>
{
    typedef uint8_t type;
};

template<> struct integral_by_size<2>
{
    typedef uint16_t type;
};

template<> struct integral_by_size<4>
{
    typedef uint32_t type;
};

template<> struct integral_by_size<8>
{
    typedef uint64_t type;
};



template<> struct integral_by_size<16>
{
    typedef uint128_type type;
};



}
}
}
# 9 "/usr/include/boost/endian/detail/endian_reverse.hpp" 2 3 4
# 1 "/usr/include/boost/endian/detail/intrinsic.hpp" 1 3 4
# 10 "/usr/include/boost/endian/detail/endian_reverse.hpp" 2 3 4
# 1 "/usr/include/boost/endian/detail/is_scoped_enum.hpp" 1 3 4
# 13 "/usr/include/boost/endian/detail/is_scoped_enum.hpp" 3 4
namespace boost
{
namespace endian
{
namespace detail
{

template<class T> struct negation: boost::integral_constant<bool, !T::value> {};

template<class T> struct is_scoped_enum:
    boost::conditional<
        boost::is_enum<T>::value,
        negation< boost::is_convertible<T, int> >,
        boost::false_type
    >::type
{
};

}
}
}
# 11 "/usr/include/boost/endian/detail/endian_reverse.hpp" 2 3 4






# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 18 "/usr/include/boost/endian/detail/endian_reverse.hpp" 2 3 4


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 1 3 4
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 3


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 43 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 2 3
# 21 "/usr/include/boost/endian/detail/endian_reverse.hpp" 2 3 4
# 36 "/usr/include/boost/endian/detail/endian_reverse.hpp" 3 4
namespace boost
{
namespace endian
{

namespace detail
{







inline uint8_t constexpr endian_reverse_impl( uint8_t x ) noexcept
{
    return x;
}

inline uint16_t constexpr endian_reverse_impl( uint16_t x ) noexcept
{






    return __builtin_bswap16(x);


}

inline uint32_t constexpr endian_reverse_impl( uint32_t x ) noexcept
{







    return __builtin_bswap32(x);


}

inline uint64_t constexpr endian_reverse_impl( uint64_t x ) noexcept
{
# 92 "/usr/include/boost/endian/detail/endian_reverse.hpp" 3 4
    return __builtin_bswap64(x);


}



inline uint128_type constexpr endian_reverse_impl( uint128_type x ) noexcept
{
    return endian_reverse_impl( static_cast<uint64_t>( x >> 64 ) ) |
        static_cast<uint128_type>( endian_reverse_impl( static_cast<uint64_t>( x ) ) ) << 64;
}





template<class T> struct is_endian_reversible: boost::integral_constant<bool,
    (boost::is_integral<T>::value && !boost::is_same<T, bool>::value) || is_scoped_enum<T>::value>
{
};



template<class T> struct is_endian_reversible_inplace: boost::integral_constant<bool,
    boost::is_integral<T>::value || boost::is_enum<T>::value || boost::is_same<T, float>::value || boost::is_same<T, double>::value>
{
};

}




template<class T> inline constexpr
    typename enable_if_< !is_class<T>::value, T >::type
    endian_reverse( T x ) noexcept
{
    static_assert(detail::is_endian_reversible<T>::value, "detail::is_endian_reversible<T>::value");

    typedef typename detail::integral_by_size< sizeof(T) >::type uintN_t;

    return static_cast<T>( detail::endian_reverse_impl( static_cast<uintN_t>( x ) ) );
}




template<class T> inline
    typename enable_if_< !is_class<T>::value >::type
    endian_reverse_inplace( T & x ) noexcept
{
    static_assert(detail::is_endian_reversible_inplace<T>::value, "detail::is_endian_reversible_inplace<T>::value");

    typename detail::integral_by_size< sizeof(T) >::type x2;

    std::memcpy( &x2, &x, sizeof(T) );

    x2 = detail::endian_reverse_impl( x2 );

    std::memcpy( &x, &x2, sizeof(T) );
}



template<class T> inline
    typename enable_if_< is_class<T>::value >::type
    endian_reverse_inplace( T & x ) noexcept
{
    x = endian_reverse( x );
}



template<class T, std::size_t N>
inline void endian_reverse_inplace( T (&x)[ N ] ) noexcept
{
    for( std::size_t i = 0; i < N; ++i )
    {
        endian_reverse_inplace( x[i] );
    }
}

}
}
# 13 "/usr/include/boost/endian/conversion.hpp" 2 3 4
# 1 "/usr/include/boost/endian/detail/endian_load.hpp" 1 3 4
# 10 "/usr/include/boost/endian/detail/endian_load.hpp" 3 4
# 1 "/usr/include/boost/endian/detail/order.hpp" 1 3 4
# 41 "/usr/include/boost/endian/detail/order.hpp" 3 4
namespace boost
{
namespace endian
{

enum class order
{
    big,
    little,
    native = little

};

}
}
# 11 "/usr/include/boost/endian/detail/endian_load.hpp" 2 3 4

# 1 "/usr/include/boost/endian/detail/is_trivially_copyable.hpp" 1 3 4
# 10 "/usr/include/boost/endian/detail/is_trivially_copyable.hpp" 3 4
# 1 "/usr/include/boost/type_traits/has_trivial_copy.hpp" 1 3 4
# 18 "/usr/include/boost/type_traits/has_trivial_copy.hpp" 3 4
# 1 "/usr/include/boost/type_traits/is_copy_constructible.hpp" 1 3 4
# 17 "/usr/include/boost/type_traits/is_copy_constructible.hpp" 3 4
# 1 "/usr/include/boost/type_traits/is_constructible.hpp" 1 3 4
# 18 "/usr/include/boost/type_traits/is_constructible.hpp" 3 4
# 1 "/usr/include/boost/type_traits/is_default_constructible.hpp" 1 3 4
# 29 "/usr/include/boost/type_traits/is_default_constructible.hpp" 3 4
namespace boost{

   namespace detail{

      struct is_default_constructible_imp
      {
         template<typename _Tp, typename = decltype(_Tp())>
         static boost::type_traits::yes_type test(int);

         template<typename>
         static boost::type_traits::no_type test(...);
      };
# 53 "/usr/include/boost/type_traits/is_default_constructible.hpp" 3 4
   }







   template <class T> struct is_default_constructible : public integral_constant<bool, sizeof(boost::detail::is_default_constructible_imp::test<T>(0)) == sizeof(boost::type_traits::yes_type)>
   {
      static_assert(boost::is_complete<T>::value, "Arguments to is_default_constructible must be complete types");
   };

   template <class T, std::size_t N> struct is_default_constructible<T[N]> : public is_default_constructible<T>{};
   template <class T> struct is_default_constructible<T[]> : public is_default_constructible<T>{};
   template <class T> struct is_default_constructible<T&> : public integral_constant<bool, false>{};

   template <class T, class U> struct is_default_constructible<std::pair<T,U> > : public integral_constant<bool, is_default_constructible<T>::value && is_default_constructible<U>::value>{};


   template <class T> struct is_default_constructible<T&&> : public integral_constant<bool, false>{};

   template <> struct is_default_constructible<void> : public integral_constant<bool, false>{};
   template <> struct is_default_constructible<void const> : public integral_constant<bool, false>{};
   template <> struct is_default_constructible<void volatile> : public integral_constant<bool, false>{};
   template <> struct is_default_constructible<void const volatile> : public integral_constant<bool, false>{};
# 96 "/usr/include/boost/type_traits/is_default_constructible.hpp" 3 4
}
# 19 "/usr/include/boost/type_traits/is_constructible.hpp" 2 3 4







namespace boost{

   namespace detail{

      struct is_constructible_imp
      {
         template<typename T, typename ...TheArgs, typename = decltype(T(boost::declval<TheArgs>()...))>
         static boost::type_traits::yes_type test(int);
         template<typename, typename...>
         static boost::type_traits::no_type test(...);

         template<typename T, typename Arg, typename = decltype(::new T(boost::declval<Arg>()))>
         static boost::type_traits::yes_type test1(int);
         template<typename, typename>
         static boost::type_traits::no_type test1(...);

         template <typename T>
         static boost::type_traits::yes_type ref_test(T);
         template <typename T>
         static boost::type_traits::no_type ref_test(...);
      };

   }

   template <class T, class ...Args> struct is_constructible : public integral_constant<bool, sizeof(detail::is_constructible_imp::test<T, Args...>(0)) == sizeof(boost::type_traits::yes_type)>
   {
      static_assert(::boost::is_complete<T>::value, "The target type must be complete in order to test for constructibility");
   };
   template <class T, class Arg> struct is_constructible<T, Arg> : public integral_constant<bool, is_destructible<T>::value && sizeof(boost::detail::is_constructible_imp::test1<T, Arg>(0)) == sizeof(boost::type_traits::yes_type)>
   {
      static_assert(::boost::is_complete<T>::value, "The target type must be complete in order to test for constructibility");
   };
   template <class Ref, class Arg> struct is_constructible<Ref&, Arg> : public integral_constant<bool, sizeof(detail::is_constructible_imp::ref_test<Ref&>(boost::declval<Arg>())) == sizeof(boost::type_traits::yes_type)>{};
   template <class Ref, class Arg> struct is_constructible<Ref&&, Arg> : public integral_constant<bool, sizeof(detail::is_constructible_imp::ref_test<Ref&&>(boost::declval<Arg>())) == sizeof(boost::type_traits::yes_type)>{};

   template <> struct is_constructible<void> : public false_type{};
   template <> struct is_constructible<void const> : public false_type{};
   template <> struct is_constructible<void const volatile> : public false_type{};
   template <> struct is_constructible<void volatile> : public false_type{};

   template <class T> struct is_constructible<T> : public is_default_constructible<T>{};
# 88 "/usr/include/boost/type_traits/is_constructible.hpp" 3 4
}
# 18 "/usr/include/boost/type_traits/is_copy_constructible.hpp" 2 3 4



namespace boost {

template <class T> struct is_copy_constructible : public boost::is_constructible<T, const T&>{};

template <> struct is_copy_constructible<void> : public false_type{};
template <> struct is_copy_constructible<void const> : public false_type{};
template <> struct is_copy_constructible<void const volatile> : public false_type{};
template <> struct is_copy_constructible<void volatile> : public false_type{};

}
# 19 "/usr/include/boost/type_traits/has_trivial_copy.hpp" 2 3 4
# 29 "/usr/include/boost/type_traits/has_trivial_copy.hpp" 3 4
namespace boost {

template <typename T> struct has_trivial_copy
: public integral_constant<bool,

   (__is_trivially_copyable(T) && !is_reference<T>::value) && is_copy_constructible<T>::value



>{};

template <typename T, std::size_t N> struct has_trivial_copy<T[N]> : public false_type{};
template <typename T> struct has_trivial_copy<T[]> : public false_type{};

template <typename T> struct has_trivial_copy<T volatile> : public false_type{};

template <> struct has_trivial_copy<void> : public false_type{};

template <> struct has_trivial_copy<void const> : public false_type{};
template <> struct has_trivial_copy<void volatile> : public false_type{};
template <> struct has_trivial_copy<void const volatile> : public false_type{};


template <class T> struct has_trivial_copy<T&> : public false_type{};

template <class T> struct has_trivial_copy<T&&> : public false_type{};


template <class T> struct has_trivial_copy_constructor : public has_trivial_copy<T>{};



}
# 11 "/usr/include/boost/endian/detail/is_trivially_copyable.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/has_trivial_assign.hpp" 1 3 4
# 21 "/usr/include/boost/type_traits/has_trivial_assign.hpp" 3 4
# 1 "/usr/include/boost/type_traits/is_assignable.hpp" 1 3 4
# 18 "/usr/include/boost/type_traits/is_assignable.hpp" 3 4
namespace boost{

   template <class T, class U = T> struct is_assignable;

}






namespace boost{

   namespace detail{

      struct is_assignable_imp
      {
         template<typename T, typename U, typename = decltype(boost::declval<T>() = boost::declval<U>())>
         static boost::type_traits::yes_type test(int);

         template<typename, typename>
         static boost::type_traits::no_type test(...);
      };

   }

   template <class T, class U> struct is_assignable : public integral_constant<bool, sizeof(detail::is_assignable_imp::test<T, U>(0)) == sizeof(boost::type_traits::yes_type)>
   {
      static_assert(boost::is_complete<T>::value, "Arguments to is_assignable must be complete types");
   };
   template <class T, std::size_t N, class U> struct is_assignable<T[N], U> : public is_assignable<T, U>{};
   template <class T, std::size_t N, class U> struct is_assignable<T(&)[N], U> : public is_assignable<T&, U>{};
   template <class T, class U> struct is_assignable<T[], U> : public is_assignable<T, U>{};
   template <class T, class U> struct is_assignable<T(&)[], U> : public is_assignable<T&, U>{};
   template <class U> struct is_assignable<void, U> : public integral_constant<bool, false>{};
   template <class U> struct is_assignable<void const, U> : public integral_constant<bool, false>{};
   template <class U> struct is_assignable<void volatile, U> : public integral_constant<bool, false>{};
   template <class U> struct is_assignable<void const volatile, U> : public integral_constant<bool, false>{};
# 83 "/usr/include/boost/type_traits/is_assignable.hpp" 3 4
}
# 22 "/usr/include/boost/type_traits/has_trivial_assign.hpp" 2 3 4


namespace boost {

   template <typename T>
   struct has_trivial_assign : public integral_constant < bool,

      (__is_trivially_assignable(T&, const T&) && !is_volatile<T>::value && is_assignable<T&, const T&>::value)



   > {};

   template<> struct has_trivial_assign<void> : public false_type{};

   template<> struct has_trivial_assign<void const> : public false_type{};
   template<> struct has_trivial_assign<void const volatile> : public false_type{};
   template<> struct has_trivial_assign<void volatile> : public false_type{};

   template <class T> struct has_trivial_assign<T volatile> : public false_type{};
   template <class T> struct has_trivial_assign<T&> : public false_type{};

   template <class T> struct has_trivial_assign<T&&> : public false_type{};


   template <typename T, std::size_t N> struct has_trivial_assign<T[N]> : public false_type{};
   template <typename T> struct has_trivial_assign<T[]> : public false_type{};

}
# 12 "/usr/include/boost/endian/detail/is_trivially_copyable.hpp" 2 3 4






namespace boost
{
namespace endian
{
namespace detail
{



using std::is_trivially_copyable;
# 36 "/usr/include/boost/endian/detail/is_trivially_copyable.hpp" 3 4
}
}
}
# 13 "/usr/include/boost/endian/detail/endian_load.hpp" 2 3 4





# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 1 3 4
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 3


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 43 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 2 3
# 19 "/usr/include/boost/endian/detail/endian_load.hpp" 2 3 4

namespace boost
{
namespace endian
{

namespace detail
{

template<class T, std::size_t N1, order O1, std::size_t N2, order O2> struct endian_load_impl
{
};

}
# 41 "/usr/include/boost/endian/detail/endian_load.hpp" 3 4
template<class T, std::size_t N, order Order>
inline T endian_load( unsigned char const * p ) noexcept
{
    static_assert(sizeof(T) == 1 || sizeof(T) == 2 || sizeof(T) == 4 || sizeof(T) == 8, "sizeof(T) == 1 || sizeof(T) == 2 || sizeof(T) == 4 || sizeof(T) == 8");
    static_assert(N >= 1 && N <= sizeof(T), "N >= 1 && N <= sizeof(T)");

    return detail::endian_load_impl<T, sizeof(T), order::native, N, Order>()( p );
}

namespace detail
{



template<class T, std::size_t N, order O> struct endian_load_impl<T, N, O, N, O>
{
    inline T operator()( unsigned char const * p ) const noexcept
    {
        static_assert(is_trivially_copyable<T>::value, "is_trivially_copyable<T>::value");

        T t;
        std::memcpy( &t, p, N );
        return t;
    }
};



template<class T, std::size_t N, order O1, order O2> struct endian_load_impl<T, N, O1, N, O2>
{
    inline T operator()( unsigned char const * p ) const noexcept
    {
        static_assert(is_trivially_copyable<T>::value, "is_trivially_copyable<T>::value");

        typename integral_by_size<N>::type tmp;
        std::memcpy( &tmp, p, N );

        endian_reverse_inplace( tmp );

        T t;
        std::memcpy( &t, &tmp, N );
        return t;
    }
};



template<class T, order Order> struct endian_load_impl<T, 2, Order, 1, order::little>
{
    inline T operator()( unsigned char const * p ) const noexcept
    {
        static_assert(is_integral<T>::value || is_enum<T>::value, "is_integral<T>::value || is_enum<T>::value");

        unsigned char tmp[ 2 ];

        tmp[0] = p[0];
        tmp[1] = boost::is_signed<T>::value && ( p[0] & 0x80 )? 0xFF: 0x00;

        return boost::endian::endian_load<T, 2, order::little>( tmp );
    }
};

template<class T, order Order> struct endian_load_impl<T, 2, Order, 1, order::big>
{
    inline T operator()( unsigned char const * p ) const noexcept
    {
        static_assert(is_integral<T>::value || is_enum<T>::value, "is_integral<T>::value || is_enum<T>::value");

        unsigned char tmp[ 2 ];

        tmp[0] = boost::is_signed<T>::value && ( p[0] & 0x80 )? 0xFF: 0x00;
        tmp[1] = p[0];

        return boost::endian::endian_load<T, 2, order::big>( tmp );
    }
};



template<class T, order Order> struct endian_load_impl<T, 4, Order, 1, order::little>
{
    inline T operator()( unsigned char const * p ) const noexcept
    {
        static_assert(is_integral<T>::value || is_enum<T>::value, "is_integral<T>::value || is_enum<T>::value");

        unsigned char tmp[ 4 ];

        unsigned char fill = boost::is_signed<T>::value && ( p[0] & 0x80 )? 0xFF: 0x00;

        tmp[0] = p[0];
        tmp[1] = fill;
        tmp[2] = fill;
        tmp[3] = fill;

        return boost::endian::endian_load<T, 4, order::little>( tmp );
    }
};

template<class T, order Order> struct endian_load_impl<T, 4, Order, 1, order::big>
{
    inline T operator()( unsigned char const * p ) const noexcept
    {
        static_assert(is_integral<T>::value || is_enum<T>::value, "is_integral<T>::value || is_enum<T>::value");

        unsigned char tmp[ 4 ];

        unsigned char fill = boost::is_signed<T>::value && ( p[0] & 0x80 )? 0xFF: 0x00;

        tmp[0] = fill;
        tmp[1] = fill;
        tmp[2] = fill;
        tmp[3] = p[0];

        return boost::endian::endian_load<T, 4, order::big>( tmp );
    }
};



template<class T, order Order> struct endian_load_impl<T, 4, Order, 2, order::little>
{
    inline T operator()( unsigned char const * p ) const noexcept
    {
        static_assert(is_integral<T>::value || is_enum<T>::value, "is_integral<T>::value || is_enum<T>::value");

        unsigned char tmp[ 4 ];

        unsigned char fill = boost::is_signed<T>::value && ( p[1] & 0x80 )? 0xFF: 0x00;

        tmp[0] = p[0];
        tmp[1] = p[1];
        tmp[2] = fill;
        tmp[3] = fill;

        return boost::endian::endian_load<T, 4, order::little>( tmp );
    }
};

template<class T, order Order> struct endian_load_impl<T, 4, Order, 2, order::big>
{
    inline T operator()( unsigned char const * p ) const noexcept
    {
        static_assert(is_integral<T>::value || is_enum<T>::value, "is_integral<T>::value || is_enum<T>::value");

        unsigned char tmp[ 4 ];

        unsigned char fill = boost::is_signed<T>::value && ( p[0] & 0x80 )? 0xFF: 0x00;

        tmp[0] = fill;
        tmp[1] = fill;
        tmp[2] = p[0];
        tmp[3] = p[1];

        return boost::endian::endian_load<T, 4, order::big>( tmp );
    }
};



template<class T, order Order> struct endian_load_impl<T, 4, Order, 3, order::little>
{
    inline T operator()( unsigned char const * p ) const noexcept
    {
        static_assert(is_integral<T>::value || is_enum<T>::value, "is_integral<T>::value || is_enum<T>::value");

        unsigned char tmp[ 4 ];

        tmp[0] = p[0];
        tmp[1] = p[1];
        tmp[2] = p[2];
        tmp[3] = boost::is_signed<T>::value && ( p[2] & 0x80 )? 0xFF: 0x00;

        return boost::endian::endian_load<T, 4, order::little>( tmp );
    }
};

template<class T, order Order> struct endian_load_impl<T, 4, Order, 3, order::big>
{
    inline T operator()( unsigned char const * p ) const noexcept
    {
        static_assert(is_integral<T>::value || is_enum<T>::value, "is_integral<T>::value || is_enum<T>::value");

        unsigned char tmp[ 4 ];

        tmp[0] = boost::is_signed<T>::value && ( p[0] & 0x80 )? 0xFF: 0x00;
        tmp[1] = p[0];
        tmp[2] = p[1];
        tmp[3] = p[2];

        return boost::endian::endian_load<T, 4, order::big>( tmp );
    }
};



template<class T, order Order> struct endian_load_impl<T, 8, Order, 1, order::little>
{
    inline T operator()( unsigned char const * p ) const noexcept
    {
        static_assert(is_integral<T>::value || is_enum<T>::value, "is_integral<T>::value || is_enum<T>::value");

        unsigned char tmp[ 8 ];

        unsigned char fill = boost::is_signed<T>::value && ( p[0] & 0x80 )? 0xFF: 0x00;

        tmp[0] = p[0];

        tmp[1] = fill;
        tmp[2] = fill;
        tmp[3] = fill;
        tmp[4] = fill;
        tmp[5] = fill;
        tmp[6] = fill;
        tmp[7] = fill;

        return boost::endian::endian_load<T, 8, order::little>( tmp );
    }
};

template<class T, order Order> struct endian_load_impl<T, 8, Order, 1, order::big>
{
    inline T operator()( unsigned char const * p ) const noexcept
    {
        static_assert(is_integral<T>::value || is_enum<T>::value, "is_integral<T>::value || is_enum<T>::value");

        unsigned char tmp[ 8 ];

        unsigned char fill = boost::is_signed<T>::value && ( p[0] & 0x80 )? 0xFF: 0x00;

        tmp[0] = fill;
        tmp[1] = fill;
        tmp[2] = fill;
        tmp[3] = fill;
        tmp[4] = fill;
        tmp[5] = fill;
        tmp[6] = fill;

        tmp[7] = p[0];

        return boost::endian::endian_load<T, 8, order::big>( tmp );
    }
};



template<class T, order Order> struct endian_load_impl<T, 8, Order, 2, order::little>
{
    inline T operator()( unsigned char const * p ) const noexcept
    {
        static_assert(is_integral<T>::value || is_enum<T>::value, "is_integral<T>::value || is_enum<T>::value");

        unsigned char tmp[ 8 ];

        unsigned char fill = boost::is_signed<T>::value && ( p[1] & 0x80 )? 0xFF: 0x00;

        tmp[0] = p[0];
        tmp[1] = p[1];

        tmp[2] = fill;
        tmp[3] = fill;
        tmp[4] = fill;
        tmp[5] = fill;
        tmp[6] = fill;
        tmp[7] = fill;

        return boost::endian::endian_load<T, 8, order::little>( tmp );
    }
};

template<class T, order Order> struct endian_load_impl<T, 8, Order, 2, order::big>
{
    inline T operator()( unsigned char const * p ) const noexcept
    {
        static_assert(is_integral<T>::value || is_enum<T>::value, "is_integral<T>::value || is_enum<T>::value");

        unsigned char tmp[ 8 ];

        unsigned char fill = boost::is_signed<T>::value && ( p[0] & 0x80 )? 0xFF: 0x00;

        tmp[0] = fill;
        tmp[1] = fill;
        tmp[2] = fill;
        tmp[3] = fill;
        tmp[4] = fill;
        tmp[5] = fill;

        tmp[6] = p[0];
        tmp[7] = p[1];

        return boost::endian::endian_load<T, 8, order::big>( tmp );
    }
};



template<class T, order Order> struct endian_load_impl<T, 8, Order, 3, order::little>
{
    inline T operator()( unsigned char const * p ) const noexcept
    {
        static_assert(is_integral<T>::value || is_enum<T>::value, "is_integral<T>::value || is_enum<T>::value");

        unsigned char tmp[ 8 ];

        unsigned char fill = boost::is_signed<T>::value && ( p[2] & 0x80 )? 0xFF: 0x00;

        tmp[0] = p[0];
        tmp[1] = p[1];
        tmp[2] = p[2];

        tmp[3] = fill;
        tmp[4] = fill;
        tmp[5] = fill;
        tmp[6] = fill;
        tmp[7] = fill;

        return boost::endian::endian_load<T, 8, order::little>( tmp );
    }
};

template<class T, order Order> struct endian_load_impl<T, 8, Order, 3, order::big>
{
    inline T operator()( unsigned char const * p ) const noexcept
    {
        static_assert(is_integral<T>::value || is_enum<T>::value, "is_integral<T>::value || is_enum<T>::value");

        unsigned char tmp[ 8 ];

        unsigned char fill = boost::is_signed<T>::value && ( p[0] & 0x80 )? 0xFF: 0x00;

        tmp[0] = fill;
        tmp[1] = fill;
        tmp[2] = fill;
        tmp[3] = fill;
        tmp[4] = fill;

        tmp[5] = p[0];
        tmp[6] = p[1];
        tmp[7] = p[2];

        return boost::endian::endian_load<T, 8, order::big>( tmp );
    }
};



template<class T, order Order> struct endian_load_impl<T, 8, Order, 4, order::little>
{
    inline T operator()( unsigned char const * p ) const noexcept
    {
        static_assert(is_integral<T>::value || is_enum<T>::value, "is_integral<T>::value || is_enum<T>::value");

        unsigned char tmp[ 8 ];

        unsigned char fill = boost::is_signed<T>::value && ( p[3] & 0x80 )? 0xFF: 0x00;

        tmp[0] = p[0];
        tmp[1] = p[1];
        tmp[2] = p[2];
        tmp[3] = p[3];

        tmp[4] = fill;
        tmp[5] = fill;
        tmp[6] = fill;
        tmp[7] = fill;

        return boost::endian::endian_load<T, 8, order::little>( tmp );
    }
};

template<class T, order Order> struct endian_load_impl<T, 8, Order, 4, order::big>
{
    inline T operator()( unsigned char const * p ) const noexcept
    {
        static_assert(is_integral<T>::value || is_enum<T>::value, "is_integral<T>::value || is_enum<T>::value");

        unsigned char tmp[ 8 ];

        unsigned char fill = boost::is_signed<T>::value && ( p[0] & 0x80 )? 0xFF: 0x00;

        tmp[0] = fill;
        tmp[1] = fill;
        tmp[2] = fill;
        tmp[3] = fill;

        tmp[4] = p[0];
        tmp[5] = p[1];
        tmp[6] = p[2];
        tmp[7] = p[3];

        return boost::endian::endian_load<T, 8, order::big>( tmp );
    }
};



template<class T, order Order> struct endian_load_impl<T, 8, Order, 5, order::little>
{
    inline T operator()( unsigned char const * p ) const noexcept
    {
        static_assert(is_integral<T>::value || is_enum<T>::value, "is_integral<T>::value || is_enum<T>::value");

        unsigned char tmp[ 8 ];

        unsigned char fill = boost::is_signed<T>::value && ( p[4] & 0x80 )? 0xFF: 0x00;

        tmp[0] = p[0];
        tmp[1] = p[1];
        tmp[2] = p[2];
        tmp[3] = p[3];
        tmp[4] = p[4];

        tmp[5] = fill;
        tmp[6] = fill;
        tmp[7] = fill;

        return boost::endian::endian_load<T, 8, order::little>( tmp );
    }
};

template<class T, order Order> struct endian_load_impl<T, 8, Order, 5, order::big>
{
    inline T operator()( unsigned char const * p ) const noexcept
    {
        static_assert(is_integral<T>::value || is_enum<T>::value, "is_integral<T>::value || is_enum<T>::value");

        unsigned char tmp[ 8 ];

        unsigned char fill = boost::is_signed<T>::value && ( p[0] & 0x80 )? 0xFF: 0x00;

        tmp[0] = fill;
        tmp[1] = fill;
        tmp[2] = fill;

        tmp[3] = p[0];
        tmp[4] = p[1];
        tmp[5] = p[2];
        tmp[6] = p[3];
        tmp[7] = p[4];

        return boost::endian::endian_load<T, 8, order::big>( tmp );
    }
};



template<class T, order Order> struct endian_load_impl<T, 8, Order, 6, order::little>
{
    inline T operator()( unsigned char const * p ) const noexcept
    {
        static_assert(is_integral<T>::value || is_enum<T>::value, "is_integral<T>::value || is_enum<T>::value");

        unsigned char tmp[ 8 ];

        unsigned char fill = boost::is_signed<T>::value && ( p[5] & 0x80 )? 0xFF: 0x00;

        tmp[0] = p[0];
        tmp[1] = p[1];
        tmp[2] = p[2];
        tmp[3] = p[3];
        tmp[4] = p[4];
        tmp[5] = p[5];

        tmp[6] = fill;
        tmp[7] = fill;

        return boost::endian::endian_load<T, 8, order::little>( tmp );
    }
};

template<class T, order Order> struct endian_load_impl<T, 8, Order, 6, order::big>
{
    inline T operator()( unsigned char const * p ) const noexcept
    {
        static_assert(is_integral<T>::value || is_enum<T>::value, "is_integral<T>::value || is_enum<T>::value");

        unsigned char tmp[ 8 ];

        unsigned char fill = boost::is_signed<T>::value && ( p[0] & 0x80 )? 0xFF: 0x00;

        tmp[0] = fill;
        tmp[1] = fill;

        tmp[2] = p[0];
        tmp[3] = p[1];
        tmp[4] = p[2];
        tmp[5] = p[3];
        tmp[6] = p[4];
        tmp[7] = p[5];

        return boost::endian::endian_load<T, 8, order::big>( tmp );
    }
};



template<class T, order Order> struct endian_load_impl<T, 8, Order, 7, order::little>
{
    inline T operator()( unsigned char const * p ) const noexcept
    {
        static_assert(is_integral<T>::value || is_enum<T>::value, "is_integral<T>::value || is_enum<T>::value");

        unsigned char tmp[ 8 ];

        unsigned char fill = boost::is_signed<T>::value && ( p[6] & 0x80 )? 0xFF: 0x00;

        tmp[0] = p[0];
        tmp[1] = p[1];
        tmp[2] = p[2];
        tmp[3] = p[3];
        tmp[4] = p[4];
        tmp[5] = p[5];
        tmp[6] = p[6];

        tmp[7] = fill;

        return boost::endian::endian_load<T, 8, order::little>( tmp );
    }
};

template<class T, order Order> struct endian_load_impl<T, 8, Order, 7, order::big>
{
    inline T operator()( unsigned char const * p ) const noexcept
    {
        static_assert(is_integral<T>::value || is_enum<T>::value, "is_integral<T>::value || is_enum<T>::value");

        unsigned char tmp[ 8 ];

        unsigned char fill = boost::is_signed<T>::value && ( p[0] & 0x80 )? 0xFF: 0x00;

        tmp[0] = fill;

        tmp[1] = p[0];
        tmp[2] = p[1];
        tmp[3] = p[2];
        tmp[4] = p[3];
        tmp[5] = p[4];
        tmp[6] = p[5];
        tmp[7] = p[6];

        return boost::endian::endian_load<T, 8, order::big>( tmp );
    }
};

}

}
}
# 14 "/usr/include/boost/endian/conversion.hpp" 2 3 4
# 1 "/usr/include/boost/endian/detail/endian_store.hpp" 1 3 4
# 17 "/usr/include/boost/endian/detail/endian_store.hpp" 3 4
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 1 3 4
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 3


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 43 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstring" 2 3
# 18 "/usr/include/boost/endian/detail/endian_store.hpp" 2 3 4

namespace boost
{
namespace endian
{

namespace detail
{

template<class T, std::size_t N1, order O1, std::size_t N2, order O2> struct endian_store_impl
{
};

}
# 40 "/usr/include/boost/endian/detail/endian_store.hpp" 3 4
template<class T, std::size_t N, order Order>
inline void endian_store( unsigned char * p, T const & v ) noexcept
{
    static_assert(sizeof(T) == 1 || sizeof(T) == 2 || sizeof(T) == 4 || sizeof(T) == 8, "sizeof(T) == 1 || sizeof(T) == 2 || sizeof(T) == 4 || sizeof(T) == 8");
    static_assert(N >= 1 && N <= sizeof(T), "N >= 1 && N <= sizeof(T)");

    return detail::endian_store_impl<T, sizeof(T), order::native, N, Order>()( p, v );
}

namespace detail
{



template<class T, std::size_t N, order O> struct endian_store_impl<T, N, O, N, O>
{
    inline void operator()( unsigned char * p, T const & v ) const noexcept
    {
        static_assert(is_trivially_copyable<T>::value, "is_trivially_copyable<T>::value");

        std::memcpy( p, &v, N );
    }
};



template<class T, std::size_t N, order O1, order O2> struct endian_store_impl<T, N, O1, N, O2>
{
    inline void operator()( unsigned char * p, T const & v ) const noexcept
    {
        static_assert(is_trivially_copyable<T>::value, "is_trivially_copyable<T>::value");

        typename integral_by_size<N>::type tmp;
        std::memcpy( &tmp, &v, N );

        endian_reverse_inplace( tmp );

        std::memcpy( p, &tmp, N );
    }
};



template<class T, order Order> struct endian_store_impl<T, 2, Order, 1, order::little>
{
    inline void operator()( unsigned char * p, T const & v ) const noexcept
    {
        static_assert(is_integral<T>::value || is_enum<T>::value, "is_integral<T>::value || is_enum<T>::value");

        unsigned char tmp[ 2 ];
        boost::endian::endian_store<T, 2, order::little>( tmp, v );

        p[0] = tmp[0];
    }
};

template<class T, order Order> struct endian_store_impl<T, 2, Order, 1, order::big>
{
    inline void operator()( unsigned char * p, T const & v ) const noexcept
    {
        static_assert(is_integral<T>::value || is_enum<T>::value, "is_integral<T>::value || is_enum<T>::value");

        unsigned char tmp[ 2 ];
        boost::endian::endian_store<T, 2, order::big>( tmp, v );

        p[0] = tmp[1];
    }
};



template<class T, order Order> struct endian_store_impl<T, 4, Order, 1, order::little>
{
    inline void operator()( unsigned char * p, T const & v ) const noexcept
    {
        static_assert(is_integral<T>::value || is_enum<T>::value, "is_integral<T>::value || is_enum<T>::value");

        unsigned char tmp[ 4 ];
        boost::endian::endian_store<T, 4, order::little>( tmp, v );

        p[0] = tmp[0];
    }
};

template<class T, order Order> struct endian_store_impl<T, 4, Order, 1, order::big>
{
    inline void operator()( unsigned char * p, T const & v ) const noexcept
    {
        static_assert(is_integral<T>::value || is_enum<T>::value, "is_integral<T>::value || is_enum<T>::value");

        unsigned char tmp[ 4 ];
        boost::endian::endian_store<T, 4, order::big>( tmp, v );

        p[0] = tmp[3];
    }
};



template<class T, order Order> struct endian_store_impl<T, 4, Order, 2, order::little>
{
    inline void operator()( unsigned char * p, T const & v ) const noexcept
    {
        static_assert(is_integral<T>::value || is_enum<T>::value, "is_integral<T>::value || is_enum<T>::value");

        unsigned char tmp[ 4 ];
        boost::endian::endian_store<T, 4, order::little>( tmp, v );

        p[0] = tmp[0];
        p[1] = tmp[1];
    }
};

template<class T, order Order> struct endian_store_impl<T, 4, Order, 2, order::big>
{
    inline void operator()( unsigned char * p, T const & v ) const noexcept
    {
        static_assert(is_integral<T>::value || is_enum<T>::value, "is_integral<T>::value || is_enum<T>::value");

        unsigned char tmp[ 4 ];
        boost::endian::endian_store<T, 4, order::big>( tmp, v );

        p[0] = tmp[2];
        p[1] = tmp[3];
    }
};



template<class T, order Order> struct endian_store_impl<T, 4, Order, 3, order::little>
{
    inline void operator()( unsigned char * p, T const & v ) const noexcept
    {
        static_assert(is_integral<T>::value || is_enum<T>::value, "is_integral<T>::value || is_enum<T>::value");

        unsigned char tmp[ 4 ];
        boost::endian::endian_store<T, 4, order::little>( tmp, v );

        p[0] = tmp[0];
        p[1] = tmp[1];
        p[2] = tmp[2];
    }
};

template<class T, order Order> struct endian_store_impl<T, 4, Order, 3, order::big>
{
    inline void operator()( unsigned char * p, T const & v ) const noexcept
    {
        static_assert(is_integral<T>::value || is_enum<T>::value, "is_integral<T>::value || is_enum<T>::value");

        unsigned char tmp[ 4 ];
        boost::endian::endian_store<T, 4, order::big>( tmp, v );

        p[0] = tmp[1];
        p[1] = tmp[2];
        p[2] = tmp[3];
    }
};



template<class T, order Order> struct endian_store_impl<T, 8, Order, 1, order::little>
{
    inline void operator()( unsigned char * p, T const & v ) const noexcept
    {
        static_assert(is_integral<T>::value || is_enum<T>::value, "is_integral<T>::value || is_enum<T>::value");

        unsigned char tmp[ 8 ];
        boost::endian::endian_store<T, 8, order::little>( tmp, v );

        p[0] = tmp[0];
    }
};

template<class T, order Order> struct endian_store_impl<T, 8, Order, 1, order::big>
{
    inline void operator()( unsigned char * p, T const & v ) const noexcept
    {
        static_assert(is_integral<T>::value || is_enum<T>::value, "is_integral<T>::value || is_enum<T>::value");

        unsigned char tmp[ 8 ];
        boost::endian::endian_store<T, 8, order::big>( tmp, v );

        p[0] = tmp[7];
    }
};



template<class T, order Order> struct endian_store_impl<T, 8, Order, 2, order::little>
{
    inline void operator()( unsigned char * p, T const & v ) const noexcept
    {
        static_assert(is_integral<T>::value || is_enum<T>::value, "is_integral<T>::value || is_enum<T>::value");

        unsigned char tmp[ 8 ];
        boost::endian::endian_store<T, 8, order::little>( tmp, v );

        p[0] = tmp[0];
        p[1] = tmp[1];
    }
};

template<class T, order Order> struct endian_store_impl<T, 8, Order, 2, order::big>
{
    inline void operator()( unsigned char * p, T const & v ) const noexcept
    {
        static_assert(is_integral<T>::value || is_enum<T>::value, "is_integral<T>::value || is_enum<T>::value");

        unsigned char tmp[ 8 ];
        boost::endian::endian_store<T, 8, order::big>( tmp, v );

        p[0] = tmp[6];
        p[1] = tmp[7];
    }
};



template<class T, order Order> struct endian_store_impl<T, 8, Order, 3, order::little>
{
    inline void operator()( unsigned char * p, T const & v ) const noexcept
    {
        static_assert(is_integral<T>::value || is_enum<T>::value, "is_integral<T>::value || is_enum<T>::value");

        unsigned char tmp[ 8 ];
        boost::endian::endian_store<T, 8, order::little>( tmp, v );

        p[0] = tmp[0];
        p[1] = tmp[1];
        p[2] = tmp[2];
    }
};

template<class T, order Order> struct endian_store_impl<T, 8, Order, 3, order::big>
{
    inline void operator()( unsigned char * p, T const & v ) const noexcept
    {
        static_assert(is_integral<T>::value || is_enum<T>::value, "is_integral<T>::value || is_enum<T>::value");

        unsigned char tmp[ 8 ];
        boost::endian::endian_store<T, 8, order::big>( tmp, v );

        p[0] = tmp[5];
        p[1] = tmp[6];
        p[2] = tmp[7];
    }
};



template<class T, order Order> struct endian_store_impl<T, 8, Order, 4, order::little>
{
    inline void operator()( unsigned char * p, T const & v ) const noexcept
    {
        static_assert(is_integral<T>::value || is_enum<T>::value, "is_integral<T>::value || is_enum<T>::value");

        unsigned char tmp[ 8 ];
        boost::endian::endian_store<T, 8, order::little>( tmp, v );

        p[0] = tmp[0];
        p[1] = tmp[1];
        p[2] = tmp[2];
        p[3] = tmp[3];
    }
};

template<class T, order Order> struct endian_store_impl<T, 8, Order, 4, order::big>
{
    inline void operator()( unsigned char * p, T const & v ) const noexcept
    {
        static_assert(is_integral<T>::value || is_enum<T>::value, "is_integral<T>::value || is_enum<T>::value");

        unsigned char tmp[ 8 ];
        boost::endian::endian_store<T, 8, order::big>( tmp, v );

        p[0] = tmp[4];
        p[1] = tmp[5];
        p[2] = tmp[6];
        p[3] = tmp[7];
    }
};



template<class T, order Order> struct endian_store_impl<T, 8, Order, 5, order::little>
{
    inline void operator()( unsigned char * p, T const & v ) const noexcept
    {
        static_assert(is_integral<T>::value || is_enum<T>::value, "is_integral<T>::value || is_enum<T>::value");

        unsigned char tmp[ 8 ];
        boost::endian::endian_store<T, 8, order::little>( tmp, v );

        p[0] = tmp[0];
        p[1] = tmp[1];
        p[2] = tmp[2];
        p[3] = tmp[3];
        p[4] = tmp[4];
    }
};

template<class T, order Order> struct endian_store_impl<T, 8, Order, 5, order::big>
{
    inline void operator()( unsigned char * p, T const & v ) const noexcept
    {
        static_assert(is_integral<T>::value || is_enum<T>::value, "is_integral<T>::value || is_enum<T>::value");

        unsigned char tmp[ 8 ];
        boost::endian::endian_store<T, 8, order::big>( tmp, v );

        p[0] = tmp[3];
        p[1] = tmp[4];
        p[2] = tmp[5];
        p[3] = tmp[6];
        p[4] = tmp[7];
    }
};



template<class T, order Order> struct endian_store_impl<T, 8, Order, 6, order::little>
{
    inline void operator()( unsigned char * p, T const & v ) const noexcept
    {
        static_assert(is_integral<T>::value || is_enum<T>::value, "is_integral<T>::value || is_enum<T>::value");

        unsigned char tmp[ 8 ];
        boost::endian::endian_store<T, 8, order::little>( tmp, v );

        p[0] = tmp[0];
        p[1] = tmp[1];
        p[2] = tmp[2];
        p[3] = tmp[3];
        p[4] = tmp[4];
        p[5] = tmp[5];
    }
};

template<class T, order Order> struct endian_store_impl<T, 8, Order, 6, order::big>
{
    inline void operator()( unsigned char * p, T const & v ) const noexcept
    {
        static_assert(is_integral<T>::value || is_enum<T>::value, "is_integral<T>::value || is_enum<T>::value");

        unsigned char tmp[ 8 ];
        boost::endian::endian_store<T, 8, order::big>( tmp, v );

        p[0] = tmp[2];
        p[1] = tmp[3];
        p[2] = tmp[4];
        p[3] = tmp[5];
        p[4] = tmp[6];
        p[5] = tmp[7];
    }
};



template<class T, order Order> struct endian_store_impl<T, 8, Order, 7, order::little>
{
    inline void operator()( unsigned char * p, T const & v ) const noexcept
    {
        static_assert(is_integral<T>::value || is_enum<T>::value, "is_integral<T>::value || is_enum<T>::value");

        unsigned char tmp[ 8 ];
        boost::endian::endian_store<T, 8, order::little>( tmp, v );

        p[0] = tmp[0];
        p[1] = tmp[1];
        p[2] = tmp[2];
        p[3] = tmp[3];
        p[4] = tmp[4];
        p[5] = tmp[5];
        p[6] = tmp[6];
    }
};

template<class T, order Order> struct endian_store_impl<T, 8, Order, 7, order::big>
{
    inline void operator()( unsigned char * p, T const & v ) const noexcept
    {
        static_assert(is_integral<T>::value || is_enum<T>::value, "is_integral<T>::value || is_enum<T>::value");

        unsigned char tmp[ 8 ];
        boost::endian::endian_store<T, 8, order::big>( tmp, v );

        p[0] = tmp[1];
        p[1] = tmp[2];
        p[2] = tmp[3];
        p[3] = tmp[4];
        p[4] = tmp[5];
        p[5] = tmp[6];
        p[6] = tmp[7];
    }
};

}

}
}
# 15 "/usr/include/boost/endian/conversion.hpp" 2 3 4





# 1 "/usr/include/boost/cstdint.hpp" 1 3 4
# 21 "/usr/include/boost/endian/conversion.hpp" 2 3 4




namespace boost
{
namespace endian
{
# 53 "/usr/include/boost/endian/conversion.hpp" 3 4
  template <class EndianReversible >
    inline constexpr EndianReversible big_to_native(EndianReversible x) noexcept;

  template <class EndianReversible >
    inline constexpr EndianReversible native_to_big(EndianReversible x) noexcept;



  template <class EndianReversible >
    inline constexpr EndianReversible little_to_native(EndianReversible x) noexcept;

  template <class EndianReversible >
    inline constexpr EndianReversible native_to_little(EndianReversible x) noexcept;



  template <order From, order To,
    class EndianReversible>
      inline constexpr EndianReversible conditional_reverse(EndianReversible from) noexcept;






  template <class EndianReversible >
    inline constexpr EndianReversible conditional_reverse(EndianReversible from,
      order from_order, order to_order)
        noexcept;
# 120 "/usr/include/boost/endian/conversion.hpp" 3 4
  template <class EndianReversibleInplace>
    inline void big_to_native_inplace(EndianReversibleInplace& x) noexcept;

  template <class EndianReversibleInplace>
    inline void native_to_big_inplace(EndianReversibleInplace& x) noexcept;



  template <class EndianReversibleInplace>
    inline void little_to_native_inplace(EndianReversibleInplace& x) noexcept;

  template <class EndianReversibleInplace>
    inline void native_to_little_inplace(EndianReversibleInplace& x) noexcept;



  template <order From, order To,
    class EndianReversibleInplace>
  inline void conditional_reverse_inplace(EndianReversibleInplace& x) noexcept;


  template <class EndianReversibleInplace>
  inline void conditional_reverse_inplace(EndianReversibleInplace& x,
    order from_order, order to_order)
    noexcept;



template <class EndianReversible>
inline constexpr EndianReversible big_to_native( EndianReversible x ) noexcept
{
    return boost::endian::conditional_reverse<order::big, order::native>( x );
}

template <class EndianReversible>
inline constexpr EndianReversible native_to_big( EndianReversible x ) noexcept
{
    return boost::endian::conditional_reverse<order::native, order::big>( x );
}

template <class EndianReversible>
inline constexpr EndianReversible little_to_native( EndianReversible x ) noexcept
{
    return boost::endian::conditional_reverse<order::little, order::native>( x );
}

template <class EndianReversible>
inline constexpr EndianReversible native_to_little( EndianReversible x ) noexcept
{
    return boost::endian::conditional_reverse<order::native, order::little>( x );
}

namespace detail
{

template<class EndianReversible>
inline constexpr EndianReversible conditional_reverse_impl( EndianReversible x, boost::true_type ) noexcept
{
    return x;
}

template<class EndianReversible>
inline constexpr EndianReversible conditional_reverse_impl( EndianReversible x, boost::false_type ) noexcept
{
    return endian_reverse( x );
}

}


template <order From, order To, class EndianReversible>
inline constexpr EndianReversible conditional_reverse( EndianReversible x ) noexcept
{
    static_assert(boost::is_class<EndianReversible>::value || detail::is_endian_reversible<EndianReversible>::value, "boost::is_class<EndianReversible>::value || detail::is_endian_reversible<EndianReversible>::value");
    return detail::conditional_reverse_impl( x, boost::integral_constant<bool, From == To>() );
}


template <class EndianReversible>
inline constexpr EndianReversible conditional_reverse( EndianReversible x,
    order from_order, order to_order ) noexcept
{
    static_assert(boost::is_class<EndianReversible>::value || detail::is_endian_reversible<EndianReversible>::value, "boost::is_class<EndianReversible>::value || detail::is_endian_reversible<EndianReversible>::value");
    return from_order == to_order? x: endian_reverse( x );
}





template <class EndianReversibleInplace>
inline void big_to_native_inplace( EndianReversibleInplace& x ) noexcept
{
    boost::endian::conditional_reverse_inplace<order::big, order::native>( x );
}

template <class EndianReversibleInplace>
inline void native_to_big_inplace( EndianReversibleInplace& x ) noexcept
{
    boost::endian::conditional_reverse_inplace<order::native, order::big>( x );
}

template <class EndianReversibleInplace>
inline void little_to_native_inplace( EndianReversibleInplace& x ) noexcept
{
    boost::endian::conditional_reverse_inplace<order::little, order::native>( x );
}

template <class EndianReversibleInplace>
inline void native_to_little_inplace( EndianReversibleInplace& x ) noexcept
{
    boost::endian::conditional_reverse_inplace<order::native, order::little>( x );
}

namespace detail
{

template<class EndianReversibleInplace>
inline void conditional_reverse_inplace_impl( EndianReversibleInplace&, boost::true_type ) noexcept
{
}

template<class EndianReversibleInplace>
inline void conditional_reverse_inplace_impl( EndianReversibleInplace& x, boost::false_type ) noexcept
{
    endian_reverse_inplace( x );
}

}


template <order From, order To, class EndianReversibleInplace>
inline void conditional_reverse_inplace( EndianReversibleInplace& x ) noexcept
{
    static_assert(boost::is_class<EndianReversibleInplace>::value || boost::is_array<EndianReversibleInplace>::value || detail::is_endian_reversible_inplace<EndianReversibleInplace>::value, "boost::is_class<EndianReversibleInplace>::value || boost::is_array<EndianReversibleInplace>::value || detail::is_endian_reversible_inplace<EndianReversibleInplace>::value");




    detail::conditional_reverse_inplace_impl( x, boost::integral_constant<bool, From == To>() );
}


template <class EndianReversibleInplace>
inline void conditional_reverse_inplace( EndianReversibleInplace& x,
    order from_order, order to_order ) noexcept
{
    static_assert(boost::is_class<EndianReversibleInplace>::value || boost::is_array<EndianReversibleInplace>::value || detail::is_endian_reversible_inplace<EndianReversibleInplace>::value, "boost::is_class<EndianReversibleInplace>::value || boost::is_array<EndianReversibleInplace>::value || detail::is_endian_reversible_inplace<EndianReversibleInplace>::value");




    if( from_order != to_order )
    {
        endian_reverse_inplace( x );
    }
}





inline boost::int16_t load_little_s16( unsigned char const * p ) noexcept
{
    return boost::endian::endian_load<boost::int16_t, 2, order::little>( p );
}

inline boost::uint16_t load_little_u16( unsigned char const * p ) noexcept
{
    return boost::endian::endian_load<boost::uint16_t, 2, order::little>( p );
}

inline boost::int16_t load_big_s16( unsigned char const * p ) noexcept
{
    return boost::endian::endian_load<boost::int16_t, 2, order::big>( p );
}

inline boost::uint16_t load_big_u16( unsigned char const * p ) noexcept
{
    return boost::endian::endian_load<boost::uint16_t, 2, order::big>( p );
}



inline boost::int32_t load_little_s24( unsigned char const * p ) noexcept
{
    return boost::endian::endian_load<boost::int32_t, 3, order::little>( p );
}

inline boost::uint32_t load_little_u24( unsigned char const * p ) noexcept
{
    return boost::endian::endian_load<boost::uint32_t, 3, order::little>( p );
}

inline boost::int32_t load_big_s24( unsigned char const * p ) noexcept
{
    return boost::endian::endian_load<boost::int32_t, 3, order::big>( p );
}

inline boost::uint32_t load_big_u24( unsigned char const * p ) noexcept
{
    return boost::endian::endian_load<boost::uint32_t, 3, order::big>( p );
}



inline boost::int32_t load_little_s32( unsigned char const * p ) noexcept
{
    return boost::endian::endian_load<boost::int32_t, 4, order::little>( p );
}

inline boost::uint32_t load_little_u32( unsigned char const * p ) noexcept
{
    return boost::endian::endian_load<boost::uint32_t, 4, order::little>( p );
}

inline boost::int32_t load_big_s32( unsigned char const * p ) noexcept
{
    return boost::endian::endian_load<boost::int32_t, 4, order::big>( p );
}

inline boost::uint32_t load_big_u32( unsigned char const * p ) noexcept
{
    return boost::endian::endian_load<boost::uint32_t, 4, order::big>( p );
}



inline boost::int64_t load_little_s40( unsigned char const * p ) noexcept
{
    return boost::endian::endian_load<boost::int64_t, 5, order::little>( p );
}

inline boost::uint64_t load_little_u40( unsigned char const * p ) noexcept
{
    return boost::endian::endian_load<boost::uint64_t, 5, order::little>( p );
}

inline boost::int64_t load_big_s40( unsigned char const * p ) noexcept
{
    return boost::endian::endian_load<boost::int64_t, 5, order::big>( p );
}

inline boost::uint64_t load_big_u40( unsigned char const * p ) noexcept
{
    return boost::endian::endian_load<boost::uint64_t, 5, order::big>( p );
}



inline boost::int64_t load_little_s48( unsigned char const * p ) noexcept
{
    return boost::endian::endian_load<boost::int64_t, 6, order::little>( p );
}

inline boost::uint64_t load_little_u48( unsigned char const * p ) noexcept
{
    return boost::endian::endian_load<boost::uint64_t, 6, order::little>( p );
}

inline boost::int64_t load_big_s48( unsigned char const * p ) noexcept
{
    return boost::endian::endian_load<boost::int64_t, 6, order::big>( p );
}

inline boost::uint64_t load_big_u48( unsigned char const * p ) noexcept
{
    return boost::endian::endian_load<boost::uint64_t, 6, order::big>( p );
}



inline boost::int64_t load_little_s56( unsigned char const * p ) noexcept
{
    return boost::endian::endian_load<boost::int64_t, 7, order::little>( p );
}

inline boost::uint64_t load_little_u56( unsigned char const * p ) noexcept
{
    return boost::endian::endian_load<boost::uint64_t, 7, order::little>( p );
}

inline boost::int64_t load_big_s56( unsigned char const * p ) noexcept
{
    return boost::endian::endian_load<boost::int64_t, 7, order::big>( p );
}

inline boost::uint64_t load_big_u56( unsigned char const * p ) noexcept
{
    return boost::endian::endian_load<boost::uint64_t, 7, order::big>( p );
}



inline boost::int64_t load_little_s64( unsigned char const * p ) noexcept
{
    return boost::endian::endian_load<boost::int64_t, 8, order::little>( p );
}

inline boost::uint64_t load_little_u64( unsigned char const * p ) noexcept
{
    return boost::endian::endian_load<boost::uint64_t, 8, order::little>( p );
}

inline boost::int64_t load_big_s64( unsigned char const * p ) noexcept
{
    return boost::endian::endian_load<boost::int64_t, 8, order::big>( p );
}

inline boost::uint64_t load_big_u64( unsigned char const * p ) noexcept
{
    return boost::endian::endian_load<boost::uint64_t, 8, order::big>( p );
}



inline void store_little_s16( unsigned char * p, boost::int16_t v )
{
    boost::endian::endian_store<boost::int16_t, 2, order::little>( p, v );
}

inline void store_little_u16( unsigned char * p, boost::uint16_t v )
{
    boost::endian::endian_store<boost::uint16_t, 2, order::little>( p, v );
}

inline void store_big_s16( unsigned char * p, boost::int16_t v )
{
    boost::endian::endian_store<boost::int16_t, 2, order::big>( p, v );
}

inline void store_big_u16( unsigned char * p, boost::uint16_t v )
{
    boost::endian::endian_store<boost::uint16_t, 2, order::big>( p, v );
}



inline void store_little_s24( unsigned char * p, boost::int32_t v )
{
    boost::endian::endian_store<boost::int32_t, 3, order::little>( p, v );
}

inline void store_little_u24( unsigned char * p, boost::uint32_t v )
{
    boost::endian::endian_store<boost::uint32_t, 3, order::little>( p, v );
}

inline void store_big_s24( unsigned char * p, boost::int32_t v )
{
    boost::endian::endian_store<boost::int32_t, 3, order::big>( p, v );
}

inline void store_big_u24( unsigned char * p, boost::uint32_t v )
{
    boost::endian::endian_store<boost::uint32_t, 3, order::big>( p, v );
}



inline void store_little_s32( unsigned char * p, boost::int32_t v )
{
    boost::endian::endian_store<boost::int32_t, 4, order::little>( p, v );
}

inline void store_little_u32( unsigned char * p, boost::uint32_t v )
{
    boost::endian::endian_store<boost::uint32_t, 4, order::little>( p, v );
}

inline void store_big_s32( unsigned char * p, boost::int32_t v )
{
    boost::endian::endian_store<boost::int32_t, 4, order::big>( p, v );
}

inline void store_big_u32( unsigned char * p, boost::uint32_t v )
{
    boost::endian::endian_store<boost::uint32_t, 4, order::big>( p, v );
}



inline void store_little_s40( unsigned char * p, boost::int64_t v )
{
    boost::endian::endian_store<boost::int64_t, 5, order::little>( p, v );
}

inline void store_little_u40( unsigned char * p, boost::uint64_t v )
{
    boost::endian::endian_store<boost::uint64_t, 5, order::little>( p, v );
}

inline void store_big_s40( unsigned char * p, boost::int64_t v )
{
    boost::endian::endian_store<boost::int64_t, 5, order::big>( p, v );
}

inline void store_big_u40( unsigned char * p, boost::uint64_t v )
{
    boost::endian::endian_store<boost::uint64_t, 5, order::big>( p, v );
}



inline void store_little_s48( unsigned char * p, boost::int64_t v )
{
    boost::endian::endian_store<boost::int64_t, 6, order::little>( p, v );
}

inline void store_little_u48( unsigned char * p, boost::uint64_t v )
{
    boost::endian::endian_store<boost::uint64_t, 6, order::little>( p, v );
}

inline void store_big_s48( unsigned char * p, boost::int64_t v )
{
    boost::endian::endian_store<boost::int64_t, 6, order::big>( p, v );
}

inline void store_big_u48( unsigned char * p, boost::uint64_t v )
{
    boost::endian::endian_store<boost::uint64_t, 6, order::big>( p, v );
}



inline void store_little_s56( unsigned char * p, boost::int64_t v )
{
    boost::endian::endian_store<boost::int64_t, 7, order::little>( p, v );
}

inline void store_little_u56( unsigned char * p, boost::uint64_t v )
{
    boost::endian::endian_store<boost::uint64_t, 7, order::little>( p, v );
}

inline void store_big_s56( unsigned char * p, boost::int64_t v )
{
    boost::endian::endian_store<boost::int64_t, 7, order::big>( p, v );
}

inline void store_big_u56( unsigned char * p, boost::uint64_t v )
{
    boost::endian::endian_store<boost::uint64_t, 7, order::big>( p, v );
}



inline void store_little_s64( unsigned char * p, boost::int64_t v )
{
    boost::endian::endian_store<boost::int64_t, 8, order::little>( p, v );
}

inline void store_little_u64( unsigned char * p, boost::uint64_t v )
{
    boost::endian::endian_store<boost::uint64_t, 8, order::little>( p, v );
}

inline void store_big_s64( unsigned char * p, boost::int64_t v )
{
    boost::endian::endian_store<boost::int64_t, 8, order::big>( p, v );
}

inline void store_big_u64( unsigned char * p, boost::uint64_t v )
{
    boost::endian::endian_store<boost::uint64_t, 8, order::big>( p, v );
}

}
}
# 27 "/home/avi/scylla-maint/seastar/include/seastar/core/byteorder.hh" 2




namespace seastar {



template <typename T>
inline T cpu_to_le(T x) noexcept {
  return boost::endian::native_to_little(x);
}
template <typename T>
inline T le_to_cpu(T x) noexcept {
  return boost::endian::little_to_native(x);
}

template <typename T>
inline T cpu_to_be(T x) noexcept {
  return boost::endian::native_to_big(x);
}
template <typename T>
inline T be_to_cpu(T x) noexcept {
  return boost::endian::big_to_native(x);
}

template <typename T>
inline T cpu_to_le(const unaligned<T>& v) noexcept {
    return cpu_to_le(T(v));
}

template <typename T>
inline T le_to_cpu(const unaligned<T>& v) noexcept {
    return le_to_cpu(T(v));
}

template <typename T>
inline
T
read_le(const char* p) noexcept {
    T datum;
    std::copy_n(p, sizeof(T), reinterpret_cast<char*>(&datum));
    return le_to_cpu(datum);
}

template <typename T>
inline
void
write_le(char* p, T datum) noexcept {
    datum = cpu_to_le(datum);
    std::copy_n(reinterpret_cast<const char*>(&datum), sizeof(T), p);
}

template <typename T>
inline
T
read_be(const char* p) noexcept {
    T datum;
    std::copy_n(p, sizeof(T), reinterpret_cast<char*>(&datum));
    return be_to_cpu(datum);
}

template <typename T>
inline
void
write_be(char* p, T datum) noexcept {
    datum = cpu_to_be(datum);
    std::copy_n(reinterpret_cast<const char*>(&datum), sizeof(T), p);
}

template <typename T>
inline
T
consume_be(const char*& p) noexcept {
    auto ret = read_be<T>(p);
    p += sizeof(T);
    return ret;
}

template <typename T>
inline
void
produce_be(char*& p, T datum) noexcept {
    write_be<T>(p, datum);
    p += sizeof(T);
}



}
# 38 "/home/avi/scylla-maint/seastar/include/seastar/rpc/rpc.hh" 2
# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/shared_future.hh" 1
# 35 "/home/avi/scylla-maint/seastar/include/seastar/core/shared_future.hh"
namespace seastar {





template<typename Clock>
struct with_clock {};



template <typename... T>
struct future_option_traits;

template <typename Clock, typename T>
struct future_option_traits<with_clock<Clock>, T> {
    using clock_type = Clock;

    using future_type = future<T>;
    using promise_type = promise<T>;
};

template <typename Clock>
struct future_option_traits<with_clock<Clock>> {
    using clock_type = Clock;

    using future_type = future<>;
    using promise_type = promise<>;
};

template <typename T>
struct future_option_traits<T> : public future_option_traits<with_clock<lowres_clock>, T> {
};

template <>
struct future_option_traits<> : future_option_traits<void> {
};
# 107 "/home/avi/scylla-maint/seastar/include/seastar/core/shared_future.hh"
template<typename... T>
class shared_future {
    template <typename... U> friend class shared_promise;
    using options = future_option_traits<T...>;
public:
    using clock = typename options::clock_type;
    using time_point = typename clock::time_point;
    using future_type = typename future_option_traits<T...>::future_type;
    using promise_type = typename future_option_traits<T...>::promise_type;
    using value_tuple_type = typename future_type::tuple_type;
private:

    class shared_state final : public enable_lw_shared_from_this<shared_state>, public task {
        future_type _original_future;

        lw_shared_ptr<shared_state> _keepaliver;
        struct entry {
            promise_type pr;
            std::optional<abort_on_expiry<clock>> timer;
        };

        struct entry_expiry {
            void operator()(entry& e) noexcept {
                if (e.timer) {
                    e.pr.set_exception(std::make_exception_ptr(timed_out_error()));
                } else {
                    e.pr.set_exception(std::make_exception_ptr(abort_requested_exception()));
                }
            };
        };

        internal::abortable_fifo<entry, entry_expiry> _peers;

    public:
        ~shared_state() {



            if (_original_future.failed()) {
                _original_future.ignore_ready_future();
            }
        }
        explicit shared_state(future_type f) noexcept
                : task(default_scheduling_group())
                , _original_future(std::move(f)) {
        }
        void run_and_dispose() noexcept override {
            auto& state = _original_future._state;
            if (_original_future.failed()) {
                while (_peers) {
                    _peers.front().pr.set_exception(state.get_exception());
                    _peers.pop_front();
                }
            } else {
                while (_peers) {
                    auto& p = _peers.front().pr;
                    try {
                        p.set_value(state.get_value());
                    } catch (...) {
                        p.set_exception(std::current_exception());
                    }
                    _peers.pop_front();
                }
            }


            _peers = {};
            _keepaliver.release();
        }

        task* waiting_task() noexcept override {
            return nullptr;
        }

        future_type get_future(time_point timeout = time_point::max()) noexcept {






            memory::scoped_critical_alloc_section _;
            if (!_original_future.available()) {
                entry& e = _peers.emplace_back();

                auto f = e.pr.get_future();
                if (timeout != time_point::max()) {
                    e.timer.emplace(timeout);
                    abort_source& as = e.timer->abort_source();
                   _peers.make_back_abortable(as);
                }
                if (!_keepaliver) {
                    this->set_scheduling_group(current_scheduling_group());
                    _original_future.set_task(*this);
                    _keepaliver = this->shared_from_this();
                }
                return f;
            } else if (_original_future.failed()) {
                return future_type(exception_future_marker(), std::exception_ptr(_original_future._state.get_exception()));
            } else {
                return future_type(ready_future_marker(), _original_future._state.get_value());
            }
        }

        future_type get_future(abort_source& as) noexcept {






            memory::scoped_critical_alloc_section _;
            if (!_original_future.available()) {
                entry& e = _peers.emplace_back();

                auto f = e.pr.get_future();
                _peers.make_back_abortable(as);
                if (!_keepaliver) {
                    this->set_scheduling_group(current_scheduling_group());
                    _original_future.set_task(*this);
                    _keepaliver = this->shared_from_this();
                }
                return f;
            } else if (_original_future.failed()) {
                return future_type(exception_future_marker(), std::exception_ptr(_original_future._state.get_exception()));
            } else {
                return future_type(ready_future_marker(), _original_future._state.get_value());
            }
        }

        bool available() const noexcept {
            return _original_future.available();
        }

        bool failed() const noexcept {
            return _original_future.failed();
        }


        bool has_scheduled_task() const noexcept {
            return _keepaliver != nullptr;
        }
    };

    lw_shared_ptr<shared_state> _state;
public:

    shared_future(future_type f)
        : _state(make_lw_shared<shared_state>(std::move(f))) { }

    shared_future() = default;
    shared_future(const shared_future&) = default;
    shared_future& operator=(const shared_future&) = default;
    shared_future(shared_future&&) = default;
    shared_future& operator=(shared_future&&) = default;







    future_type get_future(time_point timeout = time_point::max()) const noexcept {
        return _state->get_future(timeout);
    }







    future_type get_future(abort_source& as) const noexcept {
        return _state->get_future(as);
    }




    bool available() const noexcept {
        return _state->available();
    }




    bool failed() const noexcept {
        return _state->failed();
    }


    operator future_type() const noexcept {
        return get_future();
    }


    bool valid() const noexcept {
        return bool(_state);
    }


    friend class shared_future_tester;

};







template <typename... T>
class shared_promise {
public:
    using shared_future_type = shared_future<T...>;
    using future_type = typename shared_future_type::future_type;
    using promise_type = typename shared_future_type::promise_type;
    using clock = typename shared_future_type::clock;
    using time_point = typename shared_future_type::time_point;
    using value_tuple_type = typename shared_future_type::value_tuple_type;
private:
    promise_type _promise;
    shared_future_type _shared_future;
    static constexpr bool copy_noexcept = future_type::copy_noexcept;
public:
    shared_promise(const shared_promise&) = delete;
    shared_promise(shared_promise&&) = default;
    shared_promise& operator=(shared_promise&&) = default;
    shared_promise() : _promise(), _shared_future(_promise.get_future()) {
    }




    future_type get_shared_future(time_point timeout = time_point::max()) const noexcept {
        return _shared_future.get_future(timeout);
    }





    future_type get_shared_future(abort_source& as) const noexcept {
        return _shared_future.get_future(as);
    }


    void set_value(const value_tuple_type& result) noexcept(copy_noexcept) {
        _promise.set_value(result);
    }


    void set_value(value_tuple_type&& result) noexcept {
        _promise.set_value(std::move(result));
    }


    template <typename... A>
    void set_value(A&&... a) noexcept {
        _promise.set_value(std::forward<A>(a)...);
    }


    void set_exception(std::exception_ptr ex) noexcept {
        _promise.set_exception(std::move(ex));
    }


    template<typename Exception>
    void set_exception(Exception&& e) noexcept {
        set_exception(make_exception_ptr(std::forward<Exception>(e)));
    }


    bool available() const noexcept {
        return _shared_future.available();
    }


    bool failed() const noexcept {
        return _shared_future.failed();
    }
};



}
# 39 "/home/avi/scylla-maint/seastar/include/seastar/rpc/rpc.hh" 2
# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/queue.hh" 1
# 29 "/home/avi/scylla-maint/seastar/include/seastar/core/queue.hh"
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/queue" 1 3
# 59 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/queue" 3







# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_queue.h" 1 3
# 65 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_queue.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 95 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_queue.h" 3
  template<typename _Tp, typename _Sequence = deque<_Tp> >
    class queue
    {
# 109 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_queue.h" 3
      template<typename _Tp1, typename _Seq1>
 friend bool
 operator==(const queue<_Tp1, _Seq1>&, const queue<_Tp1, _Seq1>&);

      template<typename _Tp1, typename _Seq1>
 friend bool
 operator<(const queue<_Tp1, _Seq1>&, const queue<_Tp1, _Seq1>&);


      template<typename _Tp1, three_way_comparable _Seq1>
 friend compare_three_way_result_t<_Seq1>
 operator<=>(const queue<_Tp1, _Seq1>&, const queue<_Tp1, _Seq1>&);



      template<typename _Alloc>
 using _Uses = typename
   enable_if<uses_allocator<_Sequence, _Alloc>::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/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_queue.h" 3
      _Sequence c;

    public:
# 164 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_queue.h" 3
      template<typename _Seq = _Sequence, typename _Requires = typename
        enable_if<is_default_constructible<_Seq>::value>::type>
 queue()
 : c() { }

      explicit
      queue(const _Sequence& __c)
      : c(__c) { }

      explicit
      queue(_Sequence&& __c)
      : c(std::move(__c)) { }

      template<typename _Alloc, typename _Requires = _Uses<_Alloc>>
 explicit
 queue(const _Alloc& __a)
 : c(__a) { }

      template<typename _Alloc, typename _Requires = _Uses<_Alloc>>
 queue(const _Sequence& __c, const _Alloc& __a)
 : c(__c, __a) { }

      template<typename _Alloc, typename _Requires = _Uses<_Alloc>>
 queue(_Sequence&& __c, const _Alloc& __a)
 : c(std::move(__c), __a) { }

      template<typename _Alloc, typename _Requires = _Uses<_Alloc>>
 queue(const queue& __q, const _Alloc& __a)
 : c(__q.c, __a) { }

      template<typename _Alloc, typename _Requires = _Uses<_Alloc>>
 queue(queue&& __q, const _Alloc& __a)
 : c(std::move(__q.c), __a) { }



      template<typename _InputIterator,
        typename = _RequireInputIter<_InputIterator>>
 queue(_InputIterator __first, _InputIterator __last)
 : c(__first, __last) { }

      template<typename _InputIterator, typename _Alloc,
        typename = _RequireInputIter<_InputIterator>,
        typename = _Uses<_Alloc>>
 queue(_InputIterator __first, _InputIterator __last, const _Alloc& __a)
 : c(__first, __last, __a) { }





      [[__nodiscard__]] bool
      empty() const
      { return c.empty(); }


      [[__nodiscard__]]
      size_type
      size() const
      { return c.size(); }





      [[__nodiscard__]]
      reference
      front()
      {
                              ;
 return c.front();
      }





      [[__nodiscard__]]
      const_reference
      front() const
      {
                              ;
 return c.front();
      }





      [[__nodiscard__]]
      reference
      back()
      {
                              ;
 return c.back();
      }





      [[__nodiscard__]]
      const_reference
      back() const
      {
                              ;
 return c.back();
      }
# 282 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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<typename... _Args>
 decltype(auto)
 emplace(_Args&&... __args)
 { return c.emplace_back(std::forward<_Args>(__args)...); }
# 315 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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<typename _Container,
    typename = _RequireNotAllocator<_Container>>
    queue(_Container) -> queue<typename _Container::value_type, _Container>;

  template<typename _Container, typename _Allocator,
    typename = _RequireNotAllocator<_Container>>
    queue(_Container, _Allocator)
    -> queue<typename _Container::value_type, _Container>;


  template<typename _InputIterator,
    typename _ValT
      = typename iterator_traits<_InputIterator>::value_type,
    typename = _RequireInputIter<_InputIterator>>
    queue(_InputIterator, _InputIterator) -> queue<_ValT>;

  template<typename _InputIterator, typename _Allocator,
    typename _ValT
      = typename iterator_traits<_InputIterator>::value_type,
    typename = _RequireInputIter<_InputIterator>,
    typename = _RequireAllocator<_Allocator>>
    queue(_InputIterator, _InputIterator, _Allocator)
    -> queue<_ValT, deque<_ValT, _Allocator>>;
# 375 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_queue.h" 3
  template<typename _Tp, typename _Seq>
    [[__nodiscard__]]
    inline bool
    operator==(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
    { return __x.c == __y.c; }
# 394 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_queue.h" 3
  template<typename _Tp, typename _Seq>
    [[__nodiscard__]]
    inline bool
    operator<(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
    { return __x.c < __y.c; }


  template<typename _Tp, typename _Seq>
    [[__nodiscard__]]
    inline bool
    operator!=(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
    { return !(__x == __y); }


  template<typename _Tp, typename _Seq>
    [[__nodiscard__]]
    inline bool
    operator>(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
    { return __y < __x; }


  template<typename _Tp, typename _Seq>
    [[__nodiscard__]]
    inline bool
    operator<=(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
    { return !(__y < __x); }


  template<typename _Tp, typename _Seq>
    [[__nodiscard__]]
    inline bool
    operator>=(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
    { return !(__x < __y); }


  template<typename _Tp, three_way_comparable _Seq>
    [[nodiscard]]
    inline compare_three_way_result_t<_Seq>
    operator<=>(const queue<_Tp, _Seq>& __x, const queue<_Tp, _Seq>& __y)
    { return __x.c <=> __y.c; }



  template<typename _Tp, typename _Seq>
    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<typename _Tp, typename _Seq, typename _Alloc>
    struct uses_allocator<queue<_Tp, _Seq>, _Alloc>
    : public uses_allocator<_Seq, _Alloc>::type { };
# 494 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_queue.h" 3
  template<typename _Tp, typename _Sequence = vector<_Tp>,
    typename _Compare = less<typename _Sequence::value_type> >
    class priority_queue
    {
# 512 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_queue.h" 3
      template<typename _Alloc>
 using _Uses = typename
   enable_if<uses_allocator<_Sequence, _Alloc>::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:
# 551 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_queue.h" 3
      template<typename _Seq = _Sequence, typename _Requires = typename
        enable_if<__and_<is_default_constructible<_Compare>,
    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<typename _Alloc, typename _Requires = _Uses<_Alloc>>
 explicit
 priority_queue(const _Alloc& __a)
 : c(__a), comp() { }

      template<typename _Alloc, typename _Requires = _Uses<_Alloc>>
 priority_queue(const _Compare& __x, const _Alloc& __a)
 : c(__a), comp(__x) { }



      template<typename _Alloc, typename _Requires = _Uses<_Alloc>>
 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<typename _Alloc, typename _Requires = _Uses<_Alloc>>
 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<typename _Alloc, typename _Requires = _Uses<_Alloc>>
 priority_queue(const priority_queue& __q, const _Alloc& __a)
 : c(__q.c, __a), comp(__q.comp) { }

      template<typename _Alloc, typename _Requires = _Uses<_Alloc>>
 priority_queue(priority_queue&& __q, const _Alloc& __a)
 : c(std::move(__q.c), __a), comp(std::move(__q.comp)) { }
# 627 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_queue.h" 3
      template<typename _InputIterator,
        typename = std::_RequireInputIter<_InputIterator>>
 priority_queue(_InputIterator __first, _InputIterator __last,
         const _Compare& __x = _Compare())
 : c(__first, __last), comp(__x)
 { std::make_heap(c.begin(), c.end(), comp); }



      template<typename _InputIterator,
        typename = std::_RequireInputIter<_InputIterator>>
 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<typename _InputIterator,
        typename = std::_RequireInputIter<_InputIterator>>
 priority_queue(_InputIterator __first, _InputIterator __last,
         const _Compare& __x, _Sequence&& __s)
 : c(std::move(__s)), comp(__x)
 {
                                                  ;
   c.insert(c.end(), __first, __last);
   std::make_heap(c.begin(), c.end(), comp);
 }



      template<typename _InputIterator, typename _Alloc,
        typename = std::_RequireInputIter<_InputIterator>,
        typename _Requires = _Uses<_Alloc>>
 priority_queue(_InputIterator __first, _InputIterator __last,
         const _Alloc& __alloc)
 : c(__first, __last, __alloc), comp()
 { std::make_heap(c.begin(), c.end(), comp); }

      template<typename _InputIterator, typename _Alloc,
        typename = std::_RequireInputIter<_InputIterator>,
        typename _Requires = _Uses<_Alloc>>
 priority_queue(_InputIterator __first, _InputIterator __last,
         const _Compare& __x, const _Alloc& __alloc)
 : c(__first, __last, __alloc), comp(__x)
 { std::make_heap(c.begin(), c.end(), comp); }

      template<typename _InputIterator, typename _Alloc,
        typename = std::_RequireInputIter<_InputIterator>,
        typename _Requires = _Uses<_Alloc>>
 priority_queue(_InputIterator __first, _InputIterator __last,
         const _Compare& __x, const _Sequence& __s,
         const _Alloc& __alloc)
 : c(__s, __alloc), comp(__x)
 {
                                                  ;
   c.insert(c.end(), __first, __last);
   std::make_heap(c.begin(), c.end(), comp);
 }

      template<typename _InputIterator, typename _Alloc,
        typename _Requires = _Uses<_Alloc>>
 priority_queue(_InputIterator __first, _InputIterator __last,
         const _Compare& __x, _Sequence&& __s,
         const _Alloc& __alloc)
 : c(std::move(__s), __alloc), comp(__x)
 {
                                                  ;
   c.insert(c.end(), __first, __last);
   std::make_heap(c.begin(), c.end(), comp);
 }





      [[__nodiscard__]] bool
      empty() const
      { return c.empty(); }


      [[__nodiscard__]]
      size_type
      size() const
      { return c.size(); }





      [[__nodiscard__]]
      const_reference
      top() const
      {
                              ;
 return c.front();
      }
# 735 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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<typename... _Args>
 void
 emplace(_Args&&... __args)
 {
   c.emplace_back(std::forward<_Args>(__args)...);
   std::push_heap(c.begin(), c.end(), comp);
 }
# 770 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/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 _Compare, typename _Container,
    typename = _RequireNotAllocator<_Compare>,
    typename = _RequireNotAllocator<_Container>>
    priority_queue(_Compare, _Container)
    -> priority_queue<typename _Container::value_type, _Container, _Compare>;

  template<typename _InputIterator, typename _ValT
    = typename iterator_traits<_InputIterator>::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 _Compare, typename _Container, typename _Allocator,
    typename = _RequireNotAllocator<_Compare>,
    typename = _RequireNotAllocator<_Container>>
    priority_queue(_Compare, _Container, _Allocator)
    -> priority_queue<typename _Container::value_type, _Container, _Compare>;





  template<typename _Tp, typename _Sequence, typename _Compare>
    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<typename _Tp, typename _Sequence, typename _Compare,
    typename _Alloc>
    struct uses_allocator<priority_queue<_Tp, _Sequence, _Compare>, _Alloc>
    : public uses_allocator<_Sequence, _Alloc>::type { };



}
# 67 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/queue" 2 3


# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 70 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/queue" 2 3
# 30 "/home/avi/scylla-maint/seastar/include/seastar/core/queue.hh" 2


namespace seastar {
# 42 "/home/avi/scylla-maint/seastar/include/seastar/core/queue.hh"
template <typename T>
requires std::is_nothrow_move_constructible_v<T>
class queue {
    std::queue<T, circular_buffer<T>> _q;
    size_t _max;
    std::optional<promise<>> _not_empty;
    std::optional<promise<>> _not_full;
    std::exception_ptr _ex = nullptr;
private:
    void notify_not_empty() noexcept;
    void notify_not_full() noexcept;
public:
    explicit queue(size_t size);




    bool push(T&& a);




    T pop() noexcept;





    T& front() noexcept;





    template <typename Func>
    bool consume(Func&& func);


    bool empty() const noexcept;


    bool full() const noexcept;




    future<> not_empty() noexcept;



    future<> not_full() noexcept;






    future<T> pop_eventually() noexcept;






    future<> push_eventually(T&& data) noexcept;


    size_t size() const noexcept {

        return _q.size();
    }




    size_t max_size() const noexcept { return _max; }




    void set_max_size(size_t max) noexcept {
        _max = max;
        if (!full()) {
            notify_not_full();
        }
    }



    void abort(std::exception_ptr ex) noexcept {



        while (!_q.empty()) {
            _q.pop();
        }
        _ex = ex;
        if (_not_full) {
            _not_full->set_exception(ex);
            _not_full= std::nullopt;
        }
        if (_not_empty) {
            _not_empty->set_exception(std::move(ex));
            _not_empty = std::nullopt;
        }
    }




    bool has_blocked_consumer() const noexcept {
        return bool(_not_empty);
    }
};

template <typename T>
requires std::is_nothrow_move_constructible_v<T>
inline
queue<T>::queue(size_t size)
    : _max(size) {
}

template <typename T>
requires std::is_nothrow_move_constructible_v<T>
inline
void queue<T>::notify_not_empty() noexcept {
    if (_not_empty) {
        _not_empty->set_value();
        _not_empty = std::optional<promise<>>();
    }
}

template <typename T>
requires std::is_nothrow_move_constructible_v<T>
inline
void queue<T>::notify_not_full() noexcept {
    if (_not_full) {
        _not_full->set_value();
        _not_full = std::optional<promise<>>();
    }
}

template <typename T>
requires std::is_nothrow_move_constructible_v<T>
inline
bool queue<T>::push(T&& data) {
    if (_q.size() < _max) {
        _q.push(std::move(data));
        notify_not_empty();
        return true;
    } else {
        return false;
    }
}

template <typename T>
requires std::is_nothrow_move_constructible_v<T>
inline
T& queue<T>::front() noexcept {

    return _q.front();
}

template <typename T>
requires std::is_nothrow_move_constructible_v<T>
inline
T queue<T>::pop() noexcept {
    if (_q.size() == _max) {
        notify_not_full();
    }




    (static_cast <bool> (!_q.empty()) ? void (0) : __assert_fail ("!_q.empty()", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
    T data = std::move(_q.front());
    _q.pop();
    return data;
}

template <typename T>
requires std::is_nothrow_move_constructible_v<T>
inline
future<T> queue<T>::pop_eventually() noexcept {


    static_assert(std::is_nothrow_move_constructible_v<T>,
                  "Queue element type must be no-throw move constructible");

    if (_ex) {
        return make_exception_future<T>(_ex);
    }
    if (empty()) {
        return not_empty().then([this] {
            if (_ex) {
                return make_exception_future<T>(_ex);
            } else {
                return make_ready_future<T>(pop());
            }
        });
    } else {
        return make_ready_future<T>(pop());
    }
}

template <typename T>
requires std::is_nothrow_move_constructible_v<T>
inline
future<> queue<T>::push_eventually(T&& data) noexcept {
    if (_ex) {
        return make_exception_future<>(_ex);
    }
    if (full()) {
        return not_full().then([this, data = std::move(data)] () mutable {
            _q.push(std::move(data));
            notify_not_empty();
        });
    } else {
      try {
        _q.push(std::move(data));
        notify_not_empty();
        return make_ready_future<>();
      } catch (...) {
        return current_exception_as_future();
      }
    }
}

template <typename T>
requires std::is_nothrow_move_constructible_v<T>
template <typename Func>
inline
bool queue<T>::consume(Func&& func) {
    if (_ex) {
        std::rethrow_exception(_ex);
    }
    bool running = true;
    while (!_q.empty() && running) {
        running = func(std::move(_q.front()));
        _q.pop();
    }
    if (!full()) {
        notify_not_full();
    }
    return running;
}

template <typename T>
requires std::is_nothrow_move_constructible_v<T>
inline
bool queue<T>::empty() const noexcept {

    return _q.empty();
}

template <typename T>
requires std::is_nothrow_move_constructible_v<T>
inline
bool queue<T>::full() const noexcept {

    return _q.size() >= _max;
}

template <typename T>
requires std::is_nothrow_move_constructible_v<T>
inline
future<> queue<T>::not_empty() noexcept {
    if (_ex) {
        return make_exception_future<>(_ex);
    }
    if (!empty()) {
        return make_ready_future<>();
    } else {
        _not_empty = promise<>();
        return _not_empty->get_future();
    }
}

template <typename T>
requires std::is_nothrow_move_constructible_v<T>
inline
future<> queue<T>::not_full() noexcept {
    if (_ex) {
        return make_exception_future<>(_ex);
    }
    if (!full()) {
        return make_ready_future<>();
    } else {
        _not_full = promise<>();
        return _not_full->get_future();
    }
}

}
# 40 "/home/avi/scylla-maint/seastar/include/seastar/rpc/rpc.hh" 2
# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/weak_ptr.hh" 1
# 30 "/home/avi/scylla-maint/seastar/include/seastar/core/weak_ptr.hh"
namespace seastar {
# 45 "/home/avi/scylla-maint/seastar/include/seastar/core/weak_ptr.hh"
template<typename T>
class weak_ptr {
    template<typename U>
    friend class weakly_referencable;
    template <typename U>
    friend class weak_ptr;
private:
    using hook_type = boost::intrusive::list_member_hook<boost::intrusive::link_mode<boost::intrusive::auto_unlink>>;
    hook_type _hook;
    T* _ptr = nullptr;
    weak_ptr(T* p) noexcept : _ptr(p) {}
    void clear() noexcept {
        _hook = {};
        _ptr = nullptr;
    }
    void swap(weak_ptr&& o) noexcept {
        _hook.swap_nodes(o._hook);
        std::swap(_ptr, o._ptr);
    }

public:
    template <typename U>
    requires std::convertible_to<U*, T*>
    weak_ptr(weak_ptr<U>&& o)
    {
        if (o._ptr) {
            _ptr = std::exchange(o._ptr, nullptr);
            _hook.swap_nodes(o._hook);
        }
    }





    weak_ptr() noexcept {}
    weak_ptr(std::nullptr_t) noexcept : weak_ptr() {}
    weak_ptr(weak_ptr&& o) noexcept
    {
        swap(std::move(o));
    }
    weak_ptr(const weak_ptr& o) noexcept {
        if (o._ptr) {
            swap(o._ptr->weak_from_this());
        }
    }
    weak_ptr& operator=(weak_ptr&& o) noexcept {
        if (this != &o) {
            clear();
            swap(std::move(o));
        }
        return *this;
    }
    weak_ptr& operator=(const weak_ptr& o) noexcept {
        if (this != &o) {
            clear();
            if (o._ptr) {
                swap(o._ptr->weak_from_this());
            }
        }
        return *this;
    }
    explicit operator bool() const noexcept { return _ptr != nullptr; }
    T* operator->() const noexcept { return _ptr; }
    T& operator*() const noexcept { return *_ptr; }
    T* get() const noexcept { return _ptr; }
    bool operator==(const weak_ptr& o) const noexcept { return _ptr == o._ptr; }
    bool operator!=(const weak_ptr& o) const noexcept { return _ptr != o._ptr; }
};
# 132 "/home/avi/scylla-maint/seastar/include/seastar/core/weak_ptr.hh"
template<typename T>
class weakly_referencable {
    boost::intrusive::list<weak_ptr<T>,
            boost::intrusive::member_hook<weak_ptr<T>, typename weak_ptr<T>::hook_type, &weak_ptr<T>::_hook>,
            boost::intrusive::constant_time_size<false>> _ptr_list;
public:




    weakly_referencable() noexcept {}
    weakly_referencable(weakly_referencable&&) = delete;
    weakly_referencable(const weakly_referencable&) = delete;
    ~weakly_referencable() noexcept {
        _ptr_list.clear_and_dispose([] (weak_ptr<T>* wp) noexcept {
            wp->_ptr = nullptr;
        });
    }
    weak_ptr<T> weak_from_this() noexcept {
        weak_ptr<T> ptr(static_cast<T*>(this));
        _ptr_list.push_back(ptr);
        return ptr;
    }

    weak_ptr<const T> weak_from_this() const noexcept {
        return const_cast<weakly_referencable*>(this)->weak_from_this();
    }
};

}
# 41 "/home/avi/scylla-maint/seastar/include/seastar/rpc/rpc.hh" 2




namespace bi = boost::intrusive;

namespace seastar {

namespace rpc {
# 64 "/home/avi/scylla-maint/seastar/include/seastar/rpc/rpc.hh"
using id_type = int64_t;

using rpc_semaphore = basic_semaphore<semaphore_default_exception_factory, rpc_clock_type>;
using resource_permit = semaphore_units<semaphore_default_exception_factory, rpc_clock_type>;

static constexpr char rpc_magic[] = "SSTARRPC";





struct isolation_config {


    scheduling_group sched_group = current_scheduling_group();
};




isolation_config default_isolate_connection(sstring isolation_cookie);
# 97 "/home/avi/scylla-maint/seastar/include/seastar/rpc/rpc.hh"
struct resource_limits {
    size_t basic_request_size = 0;
    unsigned bloat_factor = 1;
    size_t max_memory = rpc_semaphore::max_counter();


    using syncronous_isolation_function = std::function<isolation_config (sstring isolation_cookie)>;
    using asyncronous_isolation_function = std::function<future<isolation_config> (sstring isolation_cookie)>;
    using isolation_function_alternatives = std::variant<syncronous_isolation_function, asyncronous_isolation_function>;
    isolation_function_alternatives isolate_connection = default_isolate_connection;
};

struct client_options {
    std::optional<net::tcp_keepalive_params> keepalive;
    bool tcp_nodelay = true;
    bool reuseaddr = false;
    compressor::factory* compressor_factory = nullptr;
    bool send_timeout_data = true;
    connection_id stream_parent = invalid_connection_id;



    sstring isolation_cookie;
    sstring metrics_domain = "default";
};
# 135 "/home/avi/scylla-maint/seastar/include/seastar/rpc/rpc.hh"
class streaming_domain_type {
    uint64_t _id;
public:
    explicit streaming_domain_type(uint64_t id) : _id(id) {}
    bool operator==(const streaming_domain_type& o) const {
        return _id == o._id;
    }
    friend struct std::hash<streaming_domain_type>;
    friend std::ostream& operator<<(std::ostream&, const streaming_domain_type&);
};




class server;

struct server_options {
    compressor::factory* compressor_factory = nullptr;
    bool tcp_nodelay = true;
    std::optional<streaming_domain_type> streaming_domain;
    server_socket::load_balancing_algorithm load_balancing_algorithm = server_socket::load_balancing_algorithm::default_;




    std::function<bool(const socket_address&)> filter_connection = {};
};



inline
size_t
estimate_request_size(const resource_limits& lim, size_t serialized_size) {
    return lim.basic_request_size + serialized_size * lim.bloat_factor;
}

struct negotiation_frame {
    char magic[sizeof(rpc_magic) - 1];
    uint32_t len;
};

enum class protocol_features : uint32_t {
    COMPRESS = 0,
    TIMEOUT = 1,
    CONNECTION_ID = 2,
    STREAM_PARENT = 3,
    ISOLATION = 4,
};


using feature_map = std::map<protocol_features, sstring>;


template <typename Function>
struct signature;

class logger {
    std::function<void(const sstring&)> _logger;
    ::seastar::logger* _seastar_logger = nullptr;


    void log(const sstring& str) const {
        if (_seastar_logger) {

            _seastar_logger->info("{}", str);
        } else if (_logger) {
            _logger(str);
        }
    }


    template <typename... Args>

    void log(log_level level, fmt::format_string<Args...> fmt, Args&&... args) const {



        if (_seastar_logger) {
            _seastar_logger->log(level, fmt, std::forward<Args>(args)...);



        } else if (_logger && level <= log_level::info) {
            _logger(format(fmt, std::forward<Args>(args)...));
        }
    }

public:
    void set(std::function<void(const sstring&)> l) {
        _logger = std::move(l);
    }

    void set(::seastar::logger* logger) {
        _seastar_logger = logger;
    }

    void operator()(const client_info& info, id_type msg_id, const sstring& str) const;
    void operator()(const client_info& info, id_type msg_id, log_level level, std::string_view str) const;

    void operator()(const client_info& info, const sstring& str) const;
    void operator()(const client_info& info, log_level level, std::string_view str) const;

    void operator()(const socket_address& addr, const sstring& str) const;
    void operator()(const socket_address& addr, log_level level, std::string_view str) const;
};

class connection {
protected:
    connected_socket _fd;
    input_stream<char> _read_buf;
    output_stream<char> _write_buf;
    bool _error = false;
    bool _connected = false;
    std::optional<shared_promise<>> _negotiated = shared_promise<>();
    promise<> _stopped;
    stats _stats;
    const logger& _logger;


    void* _serializer;
    struct outgoing_entry : public bi::list_base_hook<bi::link_mode<bi::auto_unlink>> {
        timer<rpc_clock_type> t;
        snd_buf buf;
        promise<> done;
        cancellable* pcancel = nullptr;
        outgoing_entry(snd_buf b) : buf(std::move(b)) {}

        outgoing_entry(outgoing_entry&&) = delete;
        outgoing_entry(const outgoing_entry&) = delete;

        void uncancellable() {
            t.cancel();
            if (pcancel) {
                pcancel->cancel_send = std::function<void()>();
            }
        }

        ~outgoing_entry() {
            if (pcancel) {
                pcancel->cancel_send = std::function<void()>();
                pcancel->send_back_pointer = nullptr;
            }
        }

        using container_t = bi::list<outgoing_entry, bi::constant_time_size<false>>;
    };
    void withdraw(outgoing_entry::container_t::iterator it, std::exception_ptr ex = nullptr);
    future<> _outgoing_queue_ready = _negotiated->get_shared_future();
    outgoing_entry::container_t _outgoing_queue;
    size_t _outgoing_queue_size = 0;
    std::unique_ptr<compressor> _compressor;
    bool _propagate_timeout = false;
    bool _timeout_negotiated = false;

    bool _is_stream = false;
    connection_id _id = invalid_connection_id;

    std::unordered_map<connection_id, xshard_connection_ptr> _streams;
    queue<rcv_buf> _stream_queue = queue<rcv_buf>(max_queued_stream_buffers);
    semaphore _stream_sem = semaphore(max_stream_buffers_memory);
    bool _sink_closed = true;
    bool _source_closed = true;


    future<bool> _sink_closed_future = make_ready_future<bool>(false);

    void set_negotiated() noexcept;

    bool is_stream() const noexcept {
        return _is_stream;
    }

    snd_buf compress(snd_buf buf);
    future<> send_buffer(snd_buf buf);
    future<> send(snd_buf buf, std::optional<rpc_clock_type::time_point> timeout = {}, cancellable* cancel = nullptr);
    future<> send_entry(outgoing_entry& d) noexcept;
    future<> stop_send_loop(std::exception_ptr ex);
    future<std::optional<rcv_buf>> read_stream_frame_compressed(input_stream<char>& in);
    bool stream_check_twoway_closed() const noexcept {
        return _sink_closed && _source_closed;
    }
    future<> stream_close();
    future<> stream_process_incoming(rcv_buf&&);
    future<> handle_stream_frame();

public:
    connection(connected_socket&& fd, const logger& l, void* s, connection_id id = invalid_connection_id) : connection(l, s, id) {
        set_socket(std::move(fd));
    }
    connection(const logger& l, void* s, connection_id id = invalid_connection_id) : _logger(l), _serializer(s), _id(id) {}
    virtual ~connection() {}
    size_t outgoing_queue_length() const noexcept {
        return _outgoing_queue_size;
    }

    void set_socket(connected_socket&& fd);
    future<> send_negotiation_frame(feature_map features);
    bool error() const noexcept { return _error; }
    void abort();
    future<> stop() noexcept;
    future<> stream_receive(circular_buffer<foreign_ptr<std::unique_ptr<rcv_buf>>>& bufs);
    future<> close_sink() {
        _sink_closed = true;
        if (stream_check_twoway_closed()) {
            return stream_close();
        }
        return make_ready_future();
    }
    bool sink_closed() const noexcept {
        return _sink_closed;
    }
    future<> close_source() {
        _source_closed = true;
        if (stream_check_twoway_closed()) {
            return stream_close();
        }
        return make_ready_future();
    }
    connection_id get_connection_id() const noexcept {
        return _id;
    }
    stats& get_stats_internal() noexcept {
        return _stats;
    }
    xshard_connection_ptr get_stream(connection_id id) const;
    void register_stream(connection_id id, xshard_connection_ptr c);
    virtual socket_address peer_address() const = 0;

    const logger& get_logger() const noexcept {
        return _logger;
    }

    template<typename Serializer>
    Serializer& serializer() {
        return *static_cast<Serializer*>(_serializer);
    }

    template <typename FrameType>
    future<typename FrameType::return_type> read_frame(socket_address info, input_stream<char>& in);

    template <typename FrameType>
    future<typename FrameType::return_type> read_frame_compressed(socket_address info, std::unique_ptr<compressor>& compressor, input_stream<char>& in);
    friend class client;
    template<typename Serializer, typename... Out>
    friend class sink_impl;
    template<typename Serializer, typename... In>
    friend class source_impl;

    void suspend_for_testing(promise<>& p) {
        _outgoing_queue_ready.get();
        auto dummy = std::make_unique<outgoing_entry>(snd_buf());
        _outgoing_queue.push_back(*dummy);
        _outgoing_queue_ready = dummy->done.get_future();
        (void)p.get_future().then([dummy = std::move(dummy)] { dummy->done.set_value(); });
    }
};

struct deferred_snd_buf {
    promise<> pr;
    snd_buf data;
};


template<typename Serializer, typename... Out>
class sink_impl : public sink<Out...>::impl {

    alignas (cache_line_size) uint64_t _next_seq_num = 1;


    struct alignas (cache_line_size) {
        uint64_t last_seq_num = 0;
        std::map<uint64_t, deferred_snd_buf> out_of_order_bufs;
    } _remote_state;
public:
    sink_impl(xshard_connection_ptr con) : sink<Out...>::impl(std::move(con)) { this->_con->get()->_sink_closed = false; }
    future<> operator()(const Out&... args) override;
    future<> close() override;
    future<> flush() override;
    ~sink_impl() override;
};


template<typename Serializer, typename... In>
class source_impl : public source<In...>::impl {
public:
    source_impl(xshard_connection_ptr con) : source<In...>::impl(std::move(con)) { this->_con->get()->_source_closed = false; }
    future<std::optional<std::tuple<In...>>> operator()() override;
};

class client : public rpc::connection, public weakly_referencable<client> {
    socket _socket;
    id_type _message_id = 1;
    struct reply_handler_base {
        timer<rpc_clock_type> t;
        cancellable* pcancel = nullptr;
        virtual void operator()(client&, id_type, rcv_buf data) = 0;
        virtual void timeout() {}
        virtual void cancel() {}
        virtual ~reply_handler_base() {
            if (pcancel) {
                pcancel->cancel_wait = std::function<void()>();
                pcancel->wait_back_pointer = nullptr;
            }
        };
    };

    class metrics {
        struct domain;

        using domain_member_hook_t = boost::intrusive::list_member_hook<boost::intrusive::link_mode<boost::intrusive::auto_unlink>>;

        const client& _c;
        domain& _domain;
        domain_member_hook_t _link;

        using domain_list_t = boost::intrusive::list<metrics,
              boost::intrusive::member_hook<metrics, metrics::domain_member_hook_t, &metrics::_link>,
              boost::intrusive::constant_time_size<false>>;

    public:
        metrics(const client&);
        ~metrics();
    };

    void enqueue_zero_frame();
public:
    template<typename Reply, typename Func>
    struct reply_handler final : reply_handler_base {
        Func func;
        Reply reply;
        reply_handler(Func&& f) : func(std::move(f)) {}
        virtual void operator()(client& client, id_type msg_id, rcv_buf data) override {
            return func(reply, client, msg_id, std::move(data));
        }
        virtual void timeout() override {
            reply.done = true;
            reply.p.set_exception(timeout_error());
        }
        virtual void cancel() override {
            reply.done = true;
            reply.p.set_exception(canceled_error());
        }
        virtual ~reply_handler() {}
    };
private:
    std::unordered_map<id_type, std::unique_ptr<reply_handler_base>> _outstanding;
    socket_address _server_addr, _local_addr;
    client_options _options;
    weak_ptr<client> _parent;

    metrics _metrics;

private:
    future<> negotiate_protocol(feature_map map);
    void negotiate(feature_map server_features);
    future<std::tuple<int64_t, std::optional<rcv_buf>>>
    read_response_frame_compressed(input_stream<char>& in);
public:
# 501 "/home/avi/scylla-maint/seastar/include/seastar/rpc/rpc.hh"
    client(const logger& l, void* s, const socket_address& addr, const socket_address& local = {});
    client(const logger& l, void* s, client_options options, const socket_address& addr, const socket_address& local = {});
# 514 "/home/avi/scylla-maint/seastar/include/seastar/rpc/rpc.hh"
    client(const logger& l, void* s, socket socket, const socket_address& addr, const socket_address& local = {});
    client(const logger& l, void* s, client_options options, socket socket, const socket_address& addr, const socket_address& local = {});

    stats get_stats() const;
    size_t incoming_queue_length() const noexcept {
        return _outstanding.size();
    }

    auto next_message_id() { return _message_id++; }
    void wait_for_reply(id_type id, std::unique_ptr<reply_handler_base>&& h, std::optional<rpc_clock_type::time_point> timeout, cancellable* cancel);
    void wait_timed_out(id_type id);
    future<> stop() noexcept;
    void abort_all_streams();
    void deregister_this_stream();
    socket_address peer_address() const override {
        return _server_addr;
    }
    future<> await_connection() {
        if (!_negotiated) {
            return make_ready_future<>();
        } else {
            return _negotiated->get_shared_future();
        }
    }
    template<typename Serializer, typename... Out>
    future<sink<Out...>> make_stream_sink(socket socket) {
        return await_connection().then([this, socket = std::move(socket)] () mutable {
            if (!this->get_connection_id()) {
                return make_exception_future<sink<Out...>>(std::runtime_error("Streaming is not supported by the server"));
            }
            client_options o = _options;
            o.stream_parent = this->get_connection_id();
            o.send_timeout_data = false;
            o.metrics_domain += "_stream";
            auto c = make_shared<client>(_logger, _serializer, o, std::move(socket), _server_addr, _local_addr);
            c->_parent = this->weak_from_this();
            c->_is_stream = true;
            return c->await_connection().then([c, this] {
                if (_error) {
                    throw closed_error();
                }
                xshard_connection_ptr s = make_lw_shared(make_foreign(static_pointer_cast<rpc::connection>(c)));
                this->register_stream(c->get_connection_id(), s);
                return sink<Out...>(make_shared<sink_impl<Serializer, Out...>>(std::move(s)));
            }).handle_exception([c] (std::exception_ptr eptr) {


                return c->stop().then([eptr, c] {
                    return make_exception_future<sink<Out...>>(eptr);
                });
            });
        });
    }
    template<typename Serializer, typename... Out>
    future<sink<Out...>> make_stream_sink() {
        return make_stream_sink<Serializer, Out...>(make_socket());
    }

    future<> request(uint64_t type, int64_t id, snd_buf buf, std::optional<rpc_clock_type::time_point> timeout = {}, cancellable* cancel = nullptr);
};

class protocol_base;

class server {
private:
    static thread_local std::unordered_map<streaming_domain_type, server*> _servers;

public:
    class connection : public rpc::connection, public enable_shared_from_this<connection> {
        client_info _info;
        connection_id _parent_id = invalid_connection_id;
        std::optional<isolation_config> _isolation_config;
    private:
        future<> negotiate_protocol();
        future<std::tuple<std::optional<uint64_t>, uint64_t, int64_t, std::optional<rcv_buf>>>
        read_request_frame_compressed(input_stream<char>& in);
        future<feature_map> negotiate(feature_map requested);
        future<> send_unknown_verb_reply(std::optional<rpc_clock_type::time_point> timeout, int64_t msg_id, uint64_t type);
    public:
        connection(server& s, connected_socket&& fd, socket_address&& addr, const logger& l, void* seralizer, connection_id id);
        future<> process();
        future<> respond(int64_t msg_id, snd_buf&& data, std::optional<rpc_clock_type::time_point> timeout);
        client_info& info() { return _info; }
        const client_info& info() const { return _info; }
        stats get_stats() const {
            stats res = _stats;
            res.pending = outgoing_queue_length();
            return res;
        }
        socket_address peer_address() const override {
            return _info.addr;
        }

        future<resource_permit> wait_for_resources(size_t memory_consumed, std::optional<rpc_clock_type::time_point> timeout) {
            if (timeout) {
                return get_units(get_server()._resources_available, memory_consumed, *timeout);
            } else {
                return get_units(get_server()._resources_available, memory_consumed);
            }
        }
        size_t estimate_request_size(size_t serialized_size) {
            return rpc::estimate_request_size(get_server()._limits, serialized_size);
        }
        size_t max_request_size() const {
            return get_server()._limits.max_memory;
        }
        server& get_server() {
            return _info.server;
        }
        const server& get_server() const {
            return _info.server;
        }
        future<> deregister_this_stream();
        future<> abort_all_streams();
    };
private:
    protocol_base& _proto;
    server_socket _ss;
    resource_limits _limits;
    rpc_semaphore _resources_available;
    std::unordered_map<connection_id, shared_ptr<connection>> _conns;
    promise<> _ss_stopped;
    gate _reply_gate;
    server_options _options;
    bool _shutdown = false;
    uint64_t _next_client_id = 1;

public:
    server(protocol_base* proto, const socket_address& addr, resource_limits memory_limit = resource_limits());
    server(protocol_base* proto, server_options opts, const socket_address& addr, resource_limits memory_limit = resource_limits());
    server(protocol_base* proto, server_socket, resource_limits memory_limit = resource_limits(), server_options opts = server_options{});
    server(protocol_base* proto, server_options opts, server_socket, resource_limits memory_limit = resource_limits());
    void accept();







    future<> stop();
# 665 "/home/avi/scylla-maint/seastar/include/seastar/rpc/rpc.hh"
    future<> shutdown();
    template<typename Func>
    void foreach_connection(Func&& f) {
        for (auto c : _conns) {
            f(*c.second);
        }
    }







    void abort_connection(connection_id id);
    gate& reply_gate() {
        return _reply_gate;
    }
    friend connection;
    friend client;
};

using rpc_handler_func = std::function<future<> (shared_ptr<server::connection>, std::optional<rpc_clock_type::time_point> timeout, int64_t msgid,
                                                 rcv_buf data, gate::holder guard)>;

struct rpc_handler {
    scheduling_group sg;
    rpc_handler_func func;
    gate use_gate;
};

class protocol_base {
public:
    virtual ~protocol_base() {};
    virtual shared_ptr<server::connection> make_server_connection(rpc::server& server, connected_socket fd, socket_address addr, connection_id id) = 0;
protected:
    friend class server;

    struct handler_with_holder {
        rpc_handler& handler;
        gate::holder holder;
    };
    virtual std::optional<handler_with_holder> get_handler(uint64_t msg_id) = 0;
};
# 802 "/home/avi/scylla-maint/seastar/include/seastar/rpc/rpc.hh"
template<typename Serializer, typename MsgType = uint32_t>
class protocol final : public protocol_base {
public:

    class server : public rpc::server {
    public:
        server(protocol& proto, const socket_address& addr, resource_limits memory_limit = resource_limits()) :
            rpc::server(&proto, addr, memory_limit) {}
        server(protocol& proto, server_options opts, const socket_address& addr, resource_limits memory_limit = resource_limits()) :
            rpc::server(&proto, opts, addr, memory_limit) {}
        server(protocol& proto, server_socket socket, resource_limits memory_limit = resource_limits(), server_options = server_options{}) :
            rpc::server(&proto, std::move(socket), memory_limit) {}
        server(protocol& proto, server_options opts, server_socket socket, resource_limits memory_limit = resource_limits()) :
            rpc::server(&proto, opts, std::move(socket), memory_limit) {}
    };

    class client : public rpc::client {
    public:






        client(protocol& p, const socket_address& addr, const socket_address& local = {}) :
            rpc::client(p.get_logger(), &p._serializer, addr, local) {}
        client(protocol& p, client_options options, const socket_address& addr, const socket_address& local = {}) :
            rpc::client(p.get_logger(), &p._serializer, options, addr, local) {}
# 839 "/home/avi/scylla-maint/seastar/include/seastar/rpc/rpc.hh"
        client(protocol& p, socket socket, const socket_address& addr, const socket_address& local = {}) :
            rpc::client(p.get_logger(), &p._serializer, std::move(socket), addr, local) {}
        client(protocol& p, client_options options, socket socket, const socket_address& addr, const socket_address& local = {}) :
            rpc::client(p.get_logger(), &p._serializer, options, std::move(socket), addr, local) {}
    };

    friend server;
private:
    std::unordered_map<MsgType, rpc_handler> _handlers;
    Serializer _serializer;
    logger _logger;

public:
    protocol(Serializer&& serializer) : _serializer(std::forward<Serializer>(serializer)) {}
# 863 "/home/avi/scylla-maint/seastar/include/seastar/rpc/rpc.hh"
    template<typename Func>
    auto make_client(MsgType t);
# 878 "/home/avi/scylla-maint/seastar/include/seastar/rpc/rpc.hh"
    template<typename Func>
    auto register_handler(MsgType t, Func&& func);
# 898 "/home/avi/scylla-maint/seastar/include/seastar/rpc/rpc.hh"
    template <typename Func>
    auto register_handler(MsgType t, scheduling_group sg, Func&& func);
# 911 "/home/avi/scylla-maint/seastar/include/seastar/rpc/rpc.hh"
    future<> unregister_handler(MsgType t);





    [[deprecated("Use set_logger(::seastar::logger*) instead")]]
    void set_logger(std::function<void(const sstring&)> logger) {
        _logger.set(std::move(logger));
    }


    void set_logger(::seastar::logger* logger) {
        _logger.set(logger);
    }

    const logger& get_logger() const {
        return _logger;
    }

    shared_ptr<rpc::server::connection> make_server_connection(rpc::server& server, connected_socket fd, socket_address addr, connection_id id) override {
        return make_shared<rpc::server::connection>(server, std::move(fd), std::move(addr), _logger, &_serializer, id);
    }

    bool has_handler(MsgType msg_id);





    bool has_handlers() const noexcept {
        return !_handlers.empty();
    }

private:
    std::optional<handler_with_holder> get_handler(uint64_t msg_id) override;

    template<typename Ret, typename... In>
    auto make_client(signature<Ret(In...)> sig, MsgType t);

    void register_receiver(MsgType t, rpc_handler&& handler) {
        auto r = _handlers.emplace(t, std::move(handler));
        if (!r.second) {
            throw_with_backtrace<std::runtime_error>("registered handler already exists");
        }
    }
};



}

}

# 1 "/home/avi/scylla-maint/seastar/include/seastar/rpc/rpc_impl.hh" 1
# 26 "/home/avi/scylla-maint/seastar/include/seastar/rpc/rpc_impl.hh"
# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/when_all.hh" 1
# 39 "/home/avi/scylla-maint/seastar/include/seastar/core/when_all.hh"
namespace seastar {




namespace internal {

template<typename... Futures>
struct identity_futures_tuple {
    using future_type = future<std::tuple<Futures...>>;
    using promise_type = typename future_type::promise_type;

    static void set_promise(promise_type& p, std::tuple<Futures...> futures) {
        p.set_value(std::move(futures));
    }

    static future_type make_ready_future(std::tuple<Futures...> futures) noexcept {
        return seastar::make_ready_future<std::tuple<Futures...>>(std::move(futures));
    }

    static future_type current_exception_as_future() noexcept {
        return seastar::current_exception_as_future<std::tuple<Futures...>>();
    }
};

class when_all_state_base;



using when_all_process_element_func = bool (*)(void* future, void* continuation, when_all_state_base* wasb) noexcept;

struct when_all_process_element {
    when_all_process_element_func func;
    void* future;
};

class when_all_state_base {
    size_t _nr_remain;
    const when_all_process_element* _processors;
    void* _continuation;
public:
    virtual ~when_all_state_base() {}
    when_all_state_base(size_t nr_remain, const when_all_process_element* processors, void* continuation)
            : _nr_remain(nr_remain), _processors(processors), _continuation(continuation) {
    }
    virtual task* waiting_task() = 0;
    void complete_one() noexcept {


        --_nr_remain;
        while (_nr_remain) {
            bool ready = process_one(_nr_remain - 1);
            if (!ready) {
                return;
            }
            --_nr_remain;
        }
        if (!_nr_remain) {
            delete this;
        }
    }
    void do_wait_all() noexcept {
        ++_nr_remain;
        complete_one();
    }
    bool process_one(size_t idx) noexcept {
        auto p = _processors[idx];
        return p.func(p.future, _continuation, this);
    }
};

template <typename Future>
class when_all_state_component final : public continuation_base_from_future_t<Future> {
    when_all_state_base* _base;
    Future* _final_resting_place;
public:
    static bool process_element_func(void* future, void* continuation, when_all_state_base* wasb) noexcept {
        auto f = reinterpret_cast<Future*>(future);
        if (f->available()) {
            return true;
        } else {
            auto c = new (continuation) when_all_state_component(wasb, f);
            set_callback(std::move(*f), c);
            return false;
        }
    }
    when_all_state_component(when_all_state_base *base, Future* future) noexcept : _base(base), _final_resting_place(future) {}
    task* waiting_task() noexcept override { return _base->waiting_task(); }
    virtual void run_and_dispose() noexcept override {
        using futurator = futurize<Future>;
        if (__builtin_expect(this->_state.failed(), false)) {
            *_final_resting_place = futurator::make_exception_future(std::move(this->_state).get_exception());
        } else {
            *_final_resting_place = futurator::from_tuple(std::move(this->_state).get_value());
        }
        auto base = _base;
        this->~when_all_state_component();
        base->complete_one();
    }
};

template<typename ResolvedTupleTransform, typename... Futures>
class when_all_state : public when_all_state_base {
    static constexpr size_t nr = sizeof...(Futures);
    using type = std::tuple<Futures...>;
    type tuple;



    std::aligned_union_t<1, when_all_state_component<Futures>...> _cont;
    when_all_process_element _processors[nr];
public:
    typename ResolvedTupleTransform::promise_type p;
    when_all_state(Futures&&... t) : when_all_state_base(nr, _processors, &_cont), tuple(std::make_tuple(std::move(t)...)) {
        init_element_processors(std::make_index_sequence<nr>());
    }
    virtual ~when_all_state() {
        ResolvedTupleTransform::set_promise(p, std::move(tuple));
    }
    task* waiting_task() noexcept override {
        return p.waiting_task();
    }
private:
    template <size_t... Idx>
    void init_element_processors(std::index_sequence<Idx...>) {
        auto ignore = {
        0,
            (_processors[Idx] = when_all_process_element{
                when_all_state_component<std::tuple_element_t<Idx, type>>::process_element_func,
                &std::get<Idx>(tuple)
         }, 0)...
        };
        (void)ignore;
    }
public:
    static typename ResolvedTupleTransform::future_type wait_all(Futures&&... futures) noexcept {
        if ((futures.available() && ...)) {
            return ResolvedTupleTransform::make_ready_future(std::make_tuple(std::move(futures)...));
        }
        auto state = [&] () noexcept {
            memory::scoped_critical_alloc_section _;
            return new when_all_state(std::move(futures)...);
        }();
        auto ret = state->p.get_future();
        state->do_wait_all();
        return ret;
    }
};

}



namespace impl {



template <typename T>
struct is_tuple_of_futures : std::false_type {
};

template <>
struct is_tuple_of_futures<std::tuple<>> : std::true_type {
};

template <typename... T, typename... Rest>
struct is_tuple_of_futures<std::tuple<future<T...>, Rest...>> : is_tuple_of_futures<std::tuple<Rest...>> {
};

}

template <typename... Futs>
concept AllAreFutures = impl::is_tuple_of_futures<std::tuple<Futs...>>::value;

template<typename Fut, std::enable_if_t<is_future<Fut>::value, int> = 0>
auto futurize_invoke_if_func(Fut&& fut) noexcept {
    return std::forward<Fut>(fut);
}

template<typename Func, std::enable_if_t<!is_future<Func>::value, int> = 0>
auto futurize_invoke_if_func(Func&& func) noexcept {
    return futurize_invoke(std::forward<Func>(func));
}


namespace internal {

template <typename... Futs>
requires seastar::AllAreFutures<Futs...>
inline
future<std::tuple<Futs...>>
when_all_impl(Futs&&... futs) noexcept {
    using state = when_all_state<identity_futures_tuple<Futs...>, Futs...>;
    return state::wait_all(std::forward<Futs>(futs)...);
}

}
# 251 "/home/avi/scylla-maint/seastar/include/seastar/core/when_all.hh"
template <typename... FutOrFuncs>
inline auto when_all(FutOrFuncs&&... fut_or_funcs) noexcept {
    return internal::when_all_impl(futurize_invoke_if_func(std::forward<FutOrFuncs>(fut_or_funcs))...);
}

namespace internal {

template<typename Future>
struct identity_futures_vector {
    using future_type = future<std::vector<Future>>;
    static future_type run(std::vector<Future> futures) noexcept {
        return make_ready_future<std::vector<Future>>(std::move(futures));
    }
    static future_type current_exception_as_future() noexcept {
        return seastar::current_exception_as_future<std::vector<Future>>();
    }
};


template <typename ResolvedVectorTransform, typename Future>
inline
typename ResolvedVectorTransform::future_type
complete_when_all(std::vector<Future>&& futures, typename std::vector<Future>::iterator pos) noexcept {

    while (pos != futures.end() && pos->available()) {
        ++pos;
    }

    if (pos == futures.end()) {
        return ResolvedVectorTransform::run(std::move(futures));
    }

    return pos->then_wrapped([futures = std::move(futures), pos] (auto fut) mutable {
        *pos++ = std::move(fut);
        return complete_when_all<ResolvedVectorTransform>(std::move(futures), pos);
    });
}

template<typename ResolvedVectorTransform, typename FutureIterator>
inline auto
do_when_all(FutureIterator begin, FutureIterator end) noexcept {
    using itraits = std::iterator_traits<FutureIterator>;
    auto make_values_vector = [] (size_t size) noexcept {
        memory::scoped_critical_alloc_section _;
        std::vector<typename itraits::value_type> ret;
        ret.reserve(size);
        return ret;
    };
    std::vector<typename itraits::value_type> ret =
            make_values_vector(iterator_range_estimate_vector_capacity(begin, end, typename itraits::iterator_category()));


    std::move(begin, end, std::back_inserter(ret));
    return complete_when_all<ResolvedVectorTransform>(std::move(ret), ret.begin());
}

}
# 320 "/home/avi/scylla-maint/seastar/include/seastar/core/when_all.hh"
template <typename FutureIterator>
requires requires (FutureIterator i) { { *i++ }; requires is_future<std::remove_reference_t<decltype(*i)>>::value; }
inline
future<std::vector<typename std::iterator_traits<FutureIterator>::value_type>>
when_all(FutureIterator begin, FutureIterator end) noexcept {
    namespace si = internal;
    using itraits = std::iterator_traits<FutureIterator>;
    using result_transform = si::identity_futures_vector<typename itraits::value_type>;
    try {
        return si::do_when_all<result_transform>(std::move(begin), std::move(end));
    } catch (...) {
        return result_transform::current_exception_as_future();
    }
}

namespace internal {

template<typename Future>
struct future_has_value {
    enum {
        value = !std::is_same_v<std::decay_t<Future>, future<>>
    };
};

template<typename Tuple>
struct tuple_to_future;

template<typename... Elements>
struct tuple_to_future<std::tuple<Elements...>> {
    using value_type = std::tuple<Elements...>;
    using type = future<value_type>;
    using promise_type = promise<value_type>;




    static auto make_ready(std::tuple<Elements...> t) noexcept {
        return make_ready_future<value_type>(value_type(std::move(t)));
    }

    static auto make_failed(std::exception_ptr excp) noexcept {
        return seastar::make_exception_future<value_type>(std::move(excp));
    }
};

template<typename... Futures>
class extract_values_from_futures_tuple {
    static auto transform(std::tuple<Futures...> futures) noexcept {
        auto prepare_result = [] (auto futures) noexcept {
            auto fs = tuple_filter_by_type<internal::future_has_value>(std::move(futures));
            return tuple_map(std::move(fs), [] (auto&& e) {
                return e.get();
            });
        };

        using tuple_futurizer = internal::tuple_to_future<decltype(prepare_result(std::move(futures)))>;

        std::exception_ptr excp;
        tuple_for_each(futures, [&excp] (auto& f) {
            if (!excp) {
                if (f.failed()) {
                    excp = f.get_exception();
                }
            } else {
                f.ignore_ready_future();
            }
        });
        if (excp) {
            return tuple_futurizer::make_failed(std::move(excp));
        }

        return tuple_futurizer::make_ready(prepare_result(std::move(futures)));
    }
public:
    using future_type = decltype(transform(std::declval<std::tuple<Futures...>>()));
    using promise_type = typename future_type::promise_type;

    static void set_promise(promise_type& p, std::tuple<Futures...> tuple) {
        transform(std::move(tuple)).forward_to(std::move(p));
    }

    static future_type make_ready_future(std::tuple<Futures...> tuple) noexcept {
        return transform(std::move(tuple));
    }

    static future_type current_exception_as_future() noexcept {
        future_type (*type_deduct)() = current_exception_as_future;
        return type_deduct();
    }
};

template<typename Future>
struct extract_values_from_futures_vector {
    using value_type = decltype(untuple(std::declval<typename Future::tuple_type>()));

    using future_type = future<std::vector<value_type>>;

    static future_type run(std::vector<Future> futures) noexcept {
        auto make_values_vector = [] (size_t size) noexcept {
            memory::scoped_critical_alloc_section _;
            std::vector<value_type> values;
            values.reserve(size);
            return values;
        };
        std::vector<value_type> values = make_values_vector(futures.size());

        std::exception_ptr excp;
        for (auto&& f : futures) {
            if (!excp) {
                if (f.failed()) {
                    excp = f.get_exception();
                } else {
                    values.emplace_back(f.get());
                }
            } else {
                f.ignore_ready_future();
            }
        }
        if (excp) {
            return seastar::make_exception_future<std::vector<value_type>>(std::move(excp));
        }
        return make_ready_future<std::vector<value_type>>(std::move(values));
    }

    static future_type current_exception_as_future() noexcept {
        return seastar::current_exception_as_future<std::vector<value_type>>();
    }
};

template<>
struct extract_values_from_futures_vector<future<>> {
    using future_type = future<>;

    static future_type run(std::vector<future<>> futures) noexcept {
        std::exception_ptr excp;
        for (auto&& f : futures) {
            if (!excp) {
                if (f.failed()) {
                    excp = f.get_exception();
                }
            } else {
                f.ignore_ready_future();
            }
        }
        if (excp) {
            return seastar::make_exception_future<>(std::move(excp));
        }
        return make_ready_future<>();
    }

    static future_type current_exception_as_future() noexcept {
        return seastar::current_exception_as_future<>();
    }
};

template<typename... Futures>
requires seastar::AllAreFutures<Futures...>
inline auto when_all_succeed_impl(Futures&&... futures) noexcept {
    using state = when_all_state<extract_values_from_futures_tuple<Futures...>, Futures...>;
    return state::wait_all(std::forward<Futures>(futures)...);
}

}
# 495 "/home/avi/scylla-maint/seastar/include/seastar/core/when_all.hh"
template <typename... FutOrFuncs>
inline auto when_all_succeed(FutOrFuncs&&... fut_or_funcs) noexcept {
    return internal::when_all_succeed_impl(futurize_invoke_if_func(std::forward<FutOrFuncs>(fut_or_funcs))...);
}
# 511 "/home/avi/scylla-maint/seastar/include/seastar/core/when_all.hh"
template <typename FutureIterator, typename = typename std::iterator_traits<FutureIterator>::value_type>
requires requires (FutureIterator i) {
     *i++;
     { i != i } -> std::convertible_to<bool>;
     requires is_future<std::remove_reference_t<decltype(*i)>>::value;
}
inline auto
when_all_succeed(FutureIterator begin, FutureIterator end) noexcept {
    using itraits = std::iterator_traits<FutureIterator>;
    using result_transform = internal::extract_values_from_futures_vector<typename itraits::value_type>;
    try {
        return internal::do_when_all<result_transform>(std::move(begin), std::move(end));
    } catch (...) {
        return result_transform::current_exception_as_future();
    }
}
# 541 "/home/avi/scylla-maint/seastar/include/seastar/core/when_all.hh"
template <typename T>
inline auto
when_all_succeed(std::vector<future<T>>&& futures) noexcept {
    using result_transform = internal::extract_values_from_futures_vector<future<T>>;
    try {
        return internal::complete_when_all<result_transform>(std::move(futures), futures.begin());
    } catch (...) {
        return result_transform::current_exception_as_future();
    }
}



}
# 27 "/home/avi/scylla-maint/seastar/include/seastar/rpc/rpc_impl.hh" 2


# 1 "/usr/include/boost/range/numeric.hpp" 1 3 4
# 26 "/usr/include/boost/range/numeric.hpp" 3 4
# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 58 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 59 "/usr/include/boost/assert.hpp" 2 3 4
# 27 "/usr/include/boost/range/numeric.hpp" 2 3 4


# 1 "/usr/include/boost/range/category.hpp" 1 3 4
# 22 "/usr/include/boost/range/category.hpp" 3 4
namespace boost
{
    template< class T >
    struct range_category : iterator_category< typename range_iterator<T>::type >
    { };
}
# 30 "/usr/include/boost/range/numeric.hpp" 2 3 4



# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/numeric" 1 3 4
# 59 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/numeric" 3



# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_numeric.h" 1 3
# 64 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_numeric.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 85 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_numeric.h" 3
  template<typename _ForwardIterator, typename _Tp>
    constexpr
    void
    iota(_ForwardIterator __first, _ForwardIterator __last, _Tp __value)
    {





                                                     ;

      for (; __first != __last; ++__first)
 {
   *__first = __value;
   ++__value;
 }
    }
# 131 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_numeric.h" 3
  template<typename _InputIterator, typename _Tp>
    constexpr
    inline _Tp
    accumulate(_InputIterator __first, _InputIterator __last, _Tp __init)
    {


                                                     ;

      for (; __first != __last; ++__first)
 __init = std::move(__init) + *__first;
      return __init;
    }
# 158 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_numeric.h" 3
  template<typename _InputIterator, typename _Tp, typename _BinaryOperation>
    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/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_numeric.h" 3
  template<typename _InputIterator1, typename _InputIterator2, typename _Tp>
    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/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_numeric.h" 3
  template<typename _InputIterator1, typename _InputIterator2, typename _Tp,
    typename _BinaryOperation1, typename _BinaryOperation2>
    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/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_numeric.h" 3
  template<typename _InputIterator, typename _OutputIterator>
    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/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_numeric.h" 3
  template<typename _InputIterator, typename _OutputIterator,
    typename _BinaryOperation>
    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;
    }
# 334 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_numeric.h" 3
  template<typename _InputIterator, typename _OutputIterator>
    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;
    }
# 376 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/stl_numeric.h" 3
  template<typename _InputIterator, typename _OutputIterator,
    typename _BinaryOperation>
    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/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/numeric" 2 3
# 90 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/numeric" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 1 3
# 48 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/bits/version.h" 3
# 91 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/numeric" 2 3
# 104 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/numeric" 3
namespace std __attribute__ ((__visibility__ ("default")))
{



namespace __detail
{


  template<typename _Res, typename _Tp>
    constexpr _Res
    __abs_r(_Tp __val)
    {
      static_assert(sizeof(_Res) >= sizeof(_Tp),
   "result type must be at least as wide as the input type");

      if (__val >= 0)
 return __val;




      return -static_cast<_Res>(__val);
    }

  template<typename> void __abs_r(bool) = delete;


  template<typename _Tp>
    constexpr _Tp
    __gcd(_Tp __m, _Tp __n)
    {
      static_assert(is_unsigned<_Tp>::value, "type must be unsigned");

      if (__m == 0)
 return __n;
      if (__n == 0)
 return __m;

      const int __i = std::__countr_zero(__m);
      __m >>= __i;
      const int __j = std::__countr_zero(__n);
      __n >>= __j;
      const int __k = __i < __j ? __i : __j;

      while (true)
 {
   if (__m > __n)
     {
       _Tp __tmp = __m;
       __m = __n;
       __n = __tmp;
     }

   __n -= __m;

   if (__n == 0)
     return __m << __k;

   __n >>= std::__countr_zero(__n);
 }
    }
}




  template<typename _Mn, typename _Nn>
    constexpr common_type_t<_Mn, _Nn>
    gcd(_Mn __m, _Nn __n) noexcept
    {
      static_assert(is_integral_v<_Mn> && is_integral_v<_Nn>,
      "std::gcd arguments must be integers");
      static_assert(_Mn(2) == 2 && _Nn(2) == 2,
      "std::gcd arguments must not be bool");
      using _Ct = common_type_t<_Mn, _Nn>;
      const _Ct __m2 = __detail::__abs_r<_Ct>(__m);
      const _Ct __n2 = __detail::__abs_r<_Ct>(__n);
      return __detail::__gcd<make_unsigned_t<_Ct>>(__m2, __n2);
    }


  template<typename _Mn, typename _Nn>
    constexpr common_type_t<_Mn, _Nn>
    lcm(_Mn __m, _Nn __n) noexcept
    {
      static_assert(is_integral_v<_Mn> && is_integral_v<_Nn>,
      "std::lcm arguments must be integers");
      static_assert(_Mn(2) == 2 && _Nn(2) == 2,
      "std::lcm arguments must not be bool");
      using _Ct = common_type_t<_Mn, _Nn>;
      const _Ct __m2 = __detail::__abs_r<_Ct>(__m);
      const _Ct __n2 = __detail::__abs_r<_Ct>(__n);
      if (__m2 == 0 || __n2 == 0)
 return 0;
      _Ct __r = __m2 / __detail::__gcd<make_unsigned_t<_Ct>>(__m2, __n2);

      if constexpr (is_signed_v<_Ct>)
 if (__is_constant_evaluated())
   return __r * __n2;

      bool __overflow = __builtin_mul_overflow(__r, __n2, &__r);
      do { if (std::__is_constant_evaluated()) if (__builtin_expect(!bool(!__overflow), false)) std::__glibcxx_assert_fail(); } while (false);
      return __r;
    }





  template<typename _Tp>
    constexpr
    enable_if_t<__and_v<is_arithmetic<_Tp>, is_same<remove_cv_t<_Tp>, _Tp>,
   __not_<is_same<_Tp, bool>>>,
  _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<typename _Tp>
    constexpr enable_if_t<is_object_v<_Tp>, _Tp*>
    midpoint(_Tp* __a, _Tp* __b) noexcept
    {
      static_assert( sizeof(_Tp) != 0, "type must be complete" );
      return __a + (__b - __a) / 2;
    }
# 284 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/numeric" 3
  template<typename _InputIterator, typename _Tp, typename _BinaryOperation>
    constexpr
    _Tp
    reduce(_InputIterator __first, _InputIterator __last, _Tp __init,
    _BinaryOperation __binary_op)
    {
      using __ref = typename iterator_traits<_InputIterator>::reference;
      static_assert(is_invocable_r_v<_Tp, _BinaryOperation&, _Tp&, __ref>);
      static_assert(is_invocable_r_v<_Tp, _BinaryOperation&, __ref, _Tp&>);
      static_assert(is_invocable_r_v<_Tp, _BinaryOperation&, _Tp&, _Tp&>);
      static_assert(is_invocable_r_v<_Tp, _BinaryOperation&, __ref, __ref>);
      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;
    }
# 322 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/numeric" 3
  template<typename _InputIterator, typename _Tp>
    constexpr
    inline _Tp
    reduce(_InputIterator __first, _InputIterator __last, _Tp __init)
    { return std::reduce(__first, __last, std::move(__init), plus<>()); }
# 339 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/numeric" 3
  template<typename _InputIterator>
    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<>());
    }
# 366 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/numeric" 3
  template<typename _InputIterator1, typename _InputIterator2, typename _Tp,
    typename _BinaryOperation1, typename _BinaryOperation2>
    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;
    }
# 410 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/numeric" 3
  template<typename _InputIterator1, typename _InputIterator2, typename _Tp>
    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<>());
    }
# 435 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/numeric" 3
  template<typename _InputIterator, typename _Tp,
    typename _BinaryOperation, typename _UnaryOperation>
    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;
    }
# 478 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/numeric" 3
  template<typename _InputIterator, typename _OutputIterator, typename _Tp,
    typename _BinaryOperation>
    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;
    }
# 513 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/numeric" 3
  template<typename _InputIterator, typename _OutputIterator, typename _Tp>
    constexpr
    inline _OutputIterator
    exclusive_scan(_InputIterator __first, _InputIterator __last,
     _OutputIterator __result, _Tp __init)
    {
      return std::exclusive_scan(__first, __last, __result, std::move(__init),
     plus<>());
    }
# 541 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/numeric" 3
  template<typename _InputIterator, typename _OutputIterator,
    typename _BinaryOperation, typename _Tp>
    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;
    }
# 570 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/numeric" 3
  template<typename _InputIterator, typename _OutputIterator,
    typename _BinaryOperation>
    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;
    }
# 604 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/numeric" 3
  template<typename _InputIterator, typename _OutputIterator>
    constexpr
    inline _OutputIterator
    inclusive_scan(_InputIterator __first, _InputIterator __last,
     _OutputIterator __result)
    { return std::inclusive_scan(__first, __last, __result, plus<>()); }
# 631 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/numeric" 3
  template<typename _InputIterator, typename _OutputIterator, typename _Tp,
    typename _BinaryOperation, typename _UnaryOperation>
    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;
    }
# 670 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/numeric" 3
  template<typename _InputIterator, typename _OutputIterator,
    typename _BinaryOperation, typename _UnaryOperation, typename _Tp>
    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;
    }
# 704 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/numeric" 3
  template<typename _InputIterator, typename _OutputIterator,
   typename _BinaryOperation, typename _UnaryOperation>
    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;
    }





}
# 739 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/numeric" 3
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/pstl/glue_numeric_defs.h" 1 3
# 15 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/pstl/glue_numeric_defs.h" 3
namespace std
{


template <class _ExecutionPolicy, class _ForwardIterator, class _Tp, class _BinaryOperation>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Tp>
reduce(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Tp __init,
       _BinaryOperation __binary_op);

template <class _ExecutionPolicy, class _ForwardIterator, class _Tp>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Tp>
reduce(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Tp __init);

template <class _ExecutionPolicy, class _ForwardIterator>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy,
                                                 typename iterator_traits<_ForwardIterator>::value_type>
reduce(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Tp>
transform_reduce(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
                 _ForwardIterator2 __first2, _Tp __init);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp, class _BinaryOperation1,
          class _BinaryOperation2>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Tp>
transform_reduce(_ExecutionPolicy&& __exec, _ForwardIterator1 __first1, _ForwardIterator1 __last1,
                 _ForwardIterator2 __first2, _Tp __init, _BinaryOperation1 __binary_op1,
                 _BinaryOperation2 __binary_op2);

template <class _ExecutionPolicy, class _ForwardIterator, class _Tp, class _BinaryOperation, class _UnaryOperation>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _Tp>
transform_reduce(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, _Tp __init,
                 _BinaryOperation __binary_op, _UnaryOperation __unary_op);



template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
exclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
               _ForwardIterator2 __result, _Tp __init);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp, class _BinaryOperation>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
exclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
               _ForwardIterator2 __result, _Tp __init, _BinaryOperation __binary_op);



template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
inclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
               _ForwardIterator2 __result);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryOperation>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
inclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
               _ForwardIterator2 __result, _BinaryOperation __binary_op);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp, class _BinaryOperation>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
inclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
               _ForwardIterator2 __result, _BinaryOperation __binary_op, _Tp __init);



template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _Tp, class _BinaryOperation,
          class _UnaryOperation>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
transform_exclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
                         _ForwardIterator2 __result, _Tp __init, _BinaryOperation __binary_op,
                         _UnaryOperation __unary_op);



template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryOperation,
          class _UnaryOperation, class _Tp>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
transform_inclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
                         _ForwardIterator2 __result, _BinaryOperation __binary_op, _UnaryOperation __unary_op,
                         _Tp __init);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _UnaryOperation,
          class _BinaryOperation>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
transform_inclusive_scan(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
                         _ForwardIterator2 __result, _BinaryOperation __binary_op, _UnaryOperation __unary_op);



template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2, class _BinaryOperation>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
adjacent_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
                    _ForwardIterator2 __d_first, _BinaryOperation __op);

template <class _ExecutionPolicy, class _ForwardIterator1, class _ForwardIterator2>
__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator2>
adjacent_difference(_ExecutionPolicy&& __exec, _ForwardIterator1 __first, _ForwardIterator1 __last,
                    _ForwardIterator2 __d_first);

}
# 740 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/numeric" 2 3
# 34 "/usr/include/boost/range/numeric.hpp" 2 3 4


namespace boost
{
    template<class SinglePassRange, class Value>
    inline Value accumulate(const SinglePassRange& rng, Value init)
    {
        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( SinglePassRangeConcept<const SinglePassRange>)>::failed> boost_concept_check42 __attribute__((__unused__));


        return std::accumulate(boost::begin(rng), boost::end(rng), init);
    }

    template<class SinglePassRange, class Value, class BinaryOperation>
    inline Value accumulate(const SinglePassRange& rng, Value init,
                            BinaryOperation op)
    {
        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( SinglePassRangeConcept<const SinglePassRange> )>::failed> boost_concept_check52 __attribute__((__unused__));


        return std::accumulate(boost::begin(rng), boost::end(rng), init, op);
    }

    namespace range_detail
    {
        template<class SinglePassRange1, class SinglePassRange2>
        inline bool inner_product_precondition(
            const SinglePassRange1&,
            const SinglePassRange2&,
            std::input_iterator_tag,
            std::input_iterator_tag)
        {
            return true;
        }

        template<class SinglePassRange1, class SinglePassRange2>
        inline bool inner_product_precondition(
            const SinglePassRange1& rng1,
            const SinglePassRange2& rng2,
            std::forward_iterator_tag,
            std::forward_iterator_tag)
        {
            return boost::size(rng2) >= boost::size(rng1);
        }

    }

    template<
        class SinglePassRange1,
        class SinglePassRange2,
        class Value
    >
    inline Value inner_product(
        const SinglePassRange1& rng1,
        const SinglePassRange2& rng2,
        Value init)
    {
        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( SinglePassRangeConcept<const SinglePassRange1>)>::failed> boost_concept_check92 __attribute__((__unused__));


        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( SinglePassRangeConcept<const SinglePassRange2>)>::failed> boost_concept_check95 __attribute__((__unused__));


        (static_cast <bool> (range_detail::inner_product_precondition( rng1, rng2, typename range_category<const SinglePassRange1>::type(), typename range_category<const SinglePassRange2>::type())) ? void (0) : __assert_fail ("range_detail::inner_product_precondition( rng1, rng2, typename range_category<const SinglePassRange1>::type(), typename range_category<const SinglePassRange2>::type())", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));





        return std::inner_product(
            boost::begin(rng1), boost::end(rng1),
            boost::begin(rng2), init);
    }

    template<
        class SinglePassRange1,
        class SinglePassRange2,
        class Value,
        class BinaryOperation1,
        class BinaryOperation2
    >
    inline Value inner_product(
        const SinglePassRange1& rng1,
        const SinglePassRange2& rng2,
        Value init,
        BinaryOperation1 op1,
        BinaryOperation2 op2)
    {
        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( SinglePassRangeConcept<const SinglePassRange1>)>::failed> boost_concept_check123 __attribute__((__unused__));


        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( SinglePassRangeConcept<const SinglePassRange2>)>::failed> boost_concept_check126 __attribute__((__unused__));


        (static_cast <bool> (range_detail::inner_product_precondition( rng1, rng2, typename range_category<const SinglePassRange1>::type(), typename range_category<const SinglePassRange2>::type())) ? void (0) : __assert_fail ("range_detail::inner_product_precondition( rng1, rng2, typename range_category<const SinglePassRange1>::type(), typename range_category<const SinglePassRange2>::type())", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));





        return std::inner_product(
            boost::begin(rng1), boost::end(rng1),
            boost::begin(rng2), init, op1, op2);
    }

    template<class SinglePassRange, class OutputIterator>
    inline OutputIterator partial_sum(const SinglePassRange& rng,
                                      OutputIterator result)
    {
        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( SinglePassRangeConcept<const SinglePassRange>)>::failed> boost_concept_check144 __attribute__((__unused__));


        return std::partial_sum(boost::begin(rng), boost::end(rng), result);
    }

    template<class SinglePassRange, class OutputIterator, class BinaryOperation>
    inline OutputIterator partial_sum(
        const SinglePassRange& rng,
        OutputIterator result,
        BinaryOperation op)
    {
        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( SinglePassRangeConcept<const SinglePassRange>)>::failed> boost_concept_check156 __attribute__((__unused__));


        return std::partial_sum(boost::begin(rng), boost::end(rng), result, op);
    }

    template<class SinglePassRange, class OutputIterator>
    inline OutputIterator adjacent_difference(
        const SinglePassRange& rng,
        OutputIterator result)
    {
        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( SinglePassRangeConcept<const SinglePassRange>)>::failed> boost_concept_check167 __attribute__((__unused__));


        return std::adjacent_difference(boost::begin(rng), boost::end(rng),
                                        result);
    }

    template<class SinglePassRange, class OutputIterator, class BinaryOperation>
    inline OutputIterator adjacent_difference(
        const SinglePassRange& rng,
        OutputIterator result,
        BinaryOperation op)
    {
        typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( SinglePassRangeConcept<const SinglePassRange>)>::failed> boost_concept_check180 __attribute__((__unused__));


        return std::adjacent_difference(boost::begin(rng), boost::end(rng),
                                        result, op);
    }

}
# 30 "/home/avi/scylla-maint/seastar/include/seastar/rpc/rpc_impl.hh" 2
# 1 "/usr/include/boost/range/adaptor/transformed.hpp" 1 3 4
# 14 "/usr/include/boost/range/adaptor/transformed.hpp" 3 4
# 1 "/usr/include/boost/range/adaptor/argument_fwd.hpp" 1 3 4
# 21 "/usr/include/boost/range/adaptor/argument_fwd.hpp" 3 4
namespace boost
{
    namespace range_detail
    {
        template< class T >
        struct holder
        {
            T val;
            holder( T t ) : val(t)
            { }
        };

        template< class T >
        struct holder2
        {
            T val1, val2;
            holder2( T t, T u ) : val1(t), val2(u)
            { }
        };

        template< template<class> class Holder >
        struct forwarder
        {
            template< class T >
            Holder<T> operator()( T t ) const
            {
                return Holder<T>(t);
            }
        };

        template< template<class> class Holder >
        struct forwarder2
        {
            template< class T >
            Holder<T> operator()( T t, T u ) const
            {
                return Holder<T>(t,u);
            }
        };

        template< template<class,class> class Holder >
        struct forwarder2TU
        {
            template< class T, class U >
            Holder<T, U> operator()( T t, U u ) const
            {
                return Holder<T, U>(t, u);
            }
        };


    }

}
# 15 "/usr/include/boost/range/adaptor/transformed.hpp" 2 3 4
# 1 "/usr/include/boost/range/detail/default_constructible_unary_fn.hpp" 1 3 4
# 13 "/usr/include/boost/range/detail/default_constructible_unary_fn.hpp" 3 4
# 1 "/usr/include/boost/optional/optional.hpp" 1 3 4
# 29 "/usr/include/boost/optional/optional.hpp" 3 4
# 1 "/usr/include/boost/assert.hpp" 1 3 4
# 58 "/usr/include/boost/assert.hpp" 3 4
# 1 "/usr/include/assert.h" 1 3 4
# 64 "/usr/include/assert.h" 3 4
extern "C" {


extern void __assert_fail (const char *__assertion, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));


extern void __assert_perror_fail (int __errnum, const char *__file,
      unsigned int __line, const char *__function)
     noexcept (true) __attribute__ ((__noreturn__));




extern void __assert (const char *__assertion, const char *__file, int __line)
     noexcept (true) __attribute__ ((__noreturn__));


}
# 59 "/usr/include/boost/assert.hpp" 2 3 4
# 30 "/usr/include/boost/optional/optional.hpp" 2 3 4


# 1 "/usr/include/boost/core/explicit_operator_bool.hpp" 1 3 4
# 33 "/usr/include/boost/optional/optional.hpp" 2 3 4

# 1 "/usr/include/boost/optional/bad_optional_access.hpp" 1 3 4
# 20 "/usr/include/boost/optional/bad_optional_access.hpp" 3 4
namespace boost {


#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wweak-vtables"


class bad_optional_access : public std::logic_error
{
public:
  bad_optional_access()
    : std::logic_error("Attempted to access the value of an uninitialized optional object.")
    {}
};


#pragma clang diagnostic pop


}
# 35 "/usr/include/boost/optional/optional.hpp" 2 3 4






# 1 "/usr/include/boost/type_traits/disjunction.hpp" 1 3 4
# 18 "/usr/include/boost/type_traits/disjunction.hpp" 3 4
namespace boost {


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

template<class T>
struct disjunction<T>
    : T { };

template<class T, class... U>
struct disjunction<T, U...>
    : conditional<bool(T::value), T, disjunction<U...> >::type { };






}
# 42 "/usr/include/boost/optional/optional.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/has_nothrow_constructor.hpp" 1 3 4
# 25 "/usr/include/boost/type_traits/has_nothrow_constructor.hpp" 3 4
namespace boost {

template <class T> struct has_nothrow_constructor : public integral_constant<bool, (__is_nothrow_constructible(T) && is_default_constructible<T>::value)>{};
# 62 "/usr/include/boost/type_traits/has_nothrow_constructor.hpp" 3 4
template<> struct has_nothrow_constructor<void> : public false_type {};

template<> struct has_nothrow_constructor<void const> : public false_type{};
template<> struct has_nothrow_constructor<void const volatile> : public false_type{};
template<> struct has_nothrow_constructor<void volatile> : public false_type{};


template <class T> struct has_nothrow_default_constructor : public has_nothrow_constructor<T>{};

}
# 43 "/usr/include/boost/optional/optional.hpp" 2 3 4
# 53 "/usr/include/boost/optional/optional.hpp" 3 4
# 1 "/usr/include/boost/type_traits/is_nothrow_move_assignable.hpp" 1 3 4
# 15 "/usr/include/boost/type_traits/is_nothrow_move_assignable.hpp" 3 4
# 1 "/usr/include/boost/type_traits/has_trivial_move_assign.hpp" 1 3 4
# 44 "/usr/include/boost/type_traits/has_trivial_move_assign.hpp" 3 4
namespace boost{

template <typename T>
struct has_trivial_move_assign : public integral_constant<bool,

   (__is_trivially_assignable(T&, T&&) && is_assignable<T&, T&&>::value && !::boost::is_volatile<T>::value)



   > {};

template <> struct has_trivial_move_assign<void> : public false_type{};

template <> struct has_trivial_move_assign<void const> : public false_type{};
template <> struct has_trivial_move_assign<void const volatile> : public false_type{};
template <> struct has_trivial_move_assign<void volatile> : public false_type{};

template <class T> struct has_trivial_move_assign<T&> : public false_type{};

template <class T> struct has_trivial_move_assign<T&&> : public false_type{};


template <class T, std::size_t N> struct has_trivial_move_assign<T[N]> : public false_type{};
template <class T> struct has_trivial_move_assign<T[]> : public false_type{};

}
# 16 "/usr/include/boost/type_traits/is_nothrow_move_assignable.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/has_nothrow_assign.hpp" 1 3 4
# 38 "/usr/include/boost/type_traits/has_nothrow_assign.hpp" 3 4
namespace boost {
# 52 "/usr/include/boost/type_traits/has_nothrow_assign.hpp" 3 4
   template <class T>
   struct has_nothrow_assign : public integral_constant < bool,
# 65 "/usr/include/boost/type_traits/has_nothrow_assign.hpp" 3 4
      (__is_nothrow_assignable(T&, const T&) && !is_volatile<T>::value && is_assignable<T&, const T&>::value)

   > {};

template <class T, std::size_t N> struct has_nothrow_assign <T[N]> : public has_nothrow_assign<T> {};
template <> struct has_nothrow_assign<void> : public false_type{};
template <class T> struct has_nothrow_assign<T volatile> : public false_type{};
template <class T> struct has_nothrow_assign<T&> : public false_type{};

template <class T> struct has_nothrow_assign<T&&> : public false_type{};


template <> struct has_nothrow_assign<void const> : public false_type{};
template <> struct has_nothrow_assign<void const volatile> : public false_type{};
template <> struct has_nothrow_assign<void volatile> : public false_type{};


}
# 17 "/usr/include/boost/type_traits/is_nothrow_move_assignable.hpp" 2 3 4







namespace boost {
# 43 "/usr/include/boost/type_traits/is_nothrow_move_assignable.hpp" 3 4
namespace detail{

template <class T, class Enable = void>
struct false_or_cpp11_noexcept_move_assignable: public ::boost::false_type {};

template <class T>
struct false_or_cpp11_noexcept_move_assignable <
        T,
        typename ::boost::enable_if_<sizeof(T) && noexcept((::boost::declval<T&>() = ::boost::declval<T>()))>::type
    > : public ::boost::integral_constant<bool, noexcept((::boost::declval<T&>() = ::boost::declval<T>()))>
{};

}

template <class T>
struct is_nothrow_move_assignable : public integral_constant<bool, ::boost::detail::false_or_cpp11_noexcept_move_assignable<T>::value>
{
   static_assert(boost::is_complete<T>::value, "Arguments to is_nothrow_move_assignable must be complete types");
};

template <class T> struct is_nothrow_move_assignable<T const> : public ::boost::false_type {};
template <class T> struct is_nothrow_move_assignable<T const volatile> : public ::boost::false_type{};
template <class T> struct is_nothrow_move_assignable<T volatile> : public ::boost::false_type{};
template <class T> struct is_nothrow_move_assignable<T&> : public ::boost::false_type{};

template <class T> struct is_nothrow_move_assignable<T&&> : public ::boost::false_type{};
# 83 "/usr/include/boost/type_traits/is_nothrow_move_assignable.hpp" 3 4
template <> struct is_nothrow_move_assignable<void> : public false_type{};

template <> struct is_nothrow_move_assignable<void const> : public false_type{};
template <> struct is_nothrow_move_assignable<void const volatile> : public false_type{};
template <> struct is_nothrow_move_assignable<void volatile> : public false_type{};


}
# 54 "/usr/include/boost/optional/optional.hpp" 2 3 4
# 1 "/usr/include/boost/type_traits/is_nothrow_move_constructible.hpp" 1 3 4
# 40 "/usr/include/boost/type_traits/is_nothrow_move_constructible.hpp" 3 4
namespace boost{ namespace detail{

template <class T, class Enable = void>
struct false_or_cpp11_noexcept_move_constructible: public ::boost::false_type {};

template <class T>
struct false_or_cpp11_noexcept_move_constructible <
        T,
        typename ::boost::enable_if_<sizeof(T) && noexcept((T(::boost::declval<T>())))>::type
    > : public ::boost::integral_constant<bool, noexcept((T(::boost::declval<T>())))>
{};

}

template <class T> struct is_nothrow_move_constructible
   : public integral_constant<bool, ::boost::detail::false_or_cpp11_noexcept_move_constructible<T>::value>
{
   static_assert(boost::is_complete<T>::value, "Arguments to is_nothrow_move_constructible must be complete types");
};

template <class T> struct is_nothrow_move_constructible<volatile T> : public ::boost::false_type {};
template <class T> struct is_nothrow_move_constructible<const volatile T> : public ::boost::false_type{};
template <class T, std::size_t N> struct is_nothrow_move_constructible<T[N]> : public ::boost::false_type{};
template <class T> struct is_nothrow_move_constructible<T[]> : public ::boost::false_type{};
# 83 "/usr/include/boost/type_traits/is_nothrow_move_constructible.hpp" 3 4
template <> struct is_nothrow_move_constructible<void> : false_type{};

template <> struct is_nothrow_move_constructible<void const> : false_type{};
template <> struct is_nothrow_move_constructible<void volatile> : false_type{};
template <> struct is_nothrow_move_constructible<void const volatile> : false_type{};


template <class T> struct is_nothrow_move_constructible<T&> : public ::boost::true_type{};

template <class T> struct is_nothrow_move_constructible<T&&> : public ::boost::true_type{};


}
# 55 "/usr/include/boost/optional/optional.hpp" 2 3 4





# 1 "/usr/include/boost/none.hpp" 1 3 4
# 17 "/usr/include/boost/none.hpp" 3 4
# 1 "/usr/include/boost/none_t.hpp" 1 3 4
# 18 "/usr/include/boost/none_t.hpp" 3 4
namespace boost {
# 31 "/usr/include/boost/none_t.hpp" 3 4
struct none_t
{
  struct init_tag{};
  explicit constexpr none_t(init_tag){}
};



}
# 18 "/usr/include/boost/none.hpp" 2 3 4





namespace boost {
# 53 "/usr/include/boost/none.hpp" 3 4
inline constexpr none_t none ((none_t::init_tag()));



}
# 61 "/usr/include/boost/optional/optional.hpp" 2 3 4
# 1 "/usr/include/boost/utility/compare_pointees.hpp" 1 3 4
# 17 "/usr/include/boost/utility/compare_pointees.hpp" 3 4
namespace boost {
# 28 "/usr/include/boost/utility/compare_pointees.hpp" 3 4
template<class OptionalPointee>
inline
bool equal_pointees ( OptionalPointee const& x, OptionalPointee const& y )
{
  return (!x) != (!y) ? false : ( !x ? true : (*x) == (*y) ) ;
}

template<class OptionalPointee>
struct equal_pointees_t
{
  typedef bool result_type;
  typedef OptionalPointee first_argument_type;
  typedef OptionalPointee second_argument_type;

  bool operator() ( OptionalPointee const& x, OptionalPointee const& y ) const
    { return equal_pointees(x,y) ; }
} ;
# 55 "/usr/include/boost/utility/compare_pointees.hpp" 3 4
template<class OptionalPointee>
inline
bool less_pointees ( OptionalPointee const& x, OptionalPointee const& y )
{
  return !y ? false : ( !x ? true : (*x) < (*y) ) ;
}

template<class OptionalPointee>
struct less_pointees_t
{
  typedef bool result_type;
  typedef OptionalPointee first_argument_type;
  typedef OptionalPointee second_argument_type;

  bool operator() ( OptionalPointee const& x, OptionalPointee const& y ) const
    { return less_pointees(x,y) ; }
} ;

}
# 62 "/usr/include/boost/optional/optional.hpp" 2 3 4


# 1 "/usr/include/boost/optional/optional_fwd.hpp" 1 3 4
# 21 "/usr/include/boost/optional/optional_fwd.hpp" 3 4
namespace boost {

template<class T> class optional ;


template<class T> void swap ( optional<T>& , optional<T>& ) ;

template<class T> struct optional_swap_should_use_default_constructor ;



template<class T> class optional<T&> ;

template<class T> void swap ( optional<T&>& , optional<T&>& ) noexcept;



}
# 65 "/usr/include/boost/optional/optional.hpp" 2 3 4
# 1 "/usr/include/boost/optional/detail/optional_config.hpp" 1 3 4
# 66 "/usr/include/boost/optional/optional.hpp" 2 3 4
# 1 "/usr/include/boost/optional/detail/optional_factory_support.hpp" 1 3 4
# 21 "/usr/include/boost/optional/detail/optional_factory_support.hpp" 3 4
namespace boost_optional_detail
{
  template <class T, class Factory>
  inline void construct(Factory const& factory, void* address)
  {
    factory.template apply<T>(address);
  }
}

namespace boost
{
  class in_place_factory_base ;
  class typed_in_place_factory_base ;
}
# 67 "/usr/include/boost/optional/optional.hpp" 2 3 4
# 1 "/usr/include/boost/optional/detail/optional_aligned_storage.hpp" 1 3 4
# 17 "/usr/include/boost/optional/detail/optional_aligned_storage.hpp" 3 4
namespace boost {

namespace optional_detail {




template <class T>
class aligned_storage
{


    union __attribute__((__may_alias__)) dummy_u
    {
        unsigned char data[ sizeof(T) ];
        typename type_with_alignment<
          ::boost::alignment_of<T>::value >::type aligner_;
    } dummy_ ;

  public:


    void const* address() const { return &dummy_; }
    void * address() { return &dummy_; }







    T const* ptr_ref() const
    {
        union { void const* ap_pvoid; T const* as_ptype; } caster = { address() };
        return caster.as_ptype;
    }
    T * ptr_ref()
    {
        union { void* ap_pvoid; T* as_ptype; } caster = { address() };
        return caster.as_ptype;
    }





    T const& ref() const { return *ptr_ref(); }
    T & ref() { return *ptr_ref(); }

} ;

}
}
# 68 "/usr/include/boost/optional/optional.hpp" 2 3 4
# 1 "/usr/include/boost/optional/detail/optional_hash.hpp" 1 3 4
# 22 "/usr/include/boost/optional/detail/optional_hash.hpp" 3 4
namespace std
{
  template <typename T>
  struct hash<boost::optional<T> >
  {
    typedef std::size_t result_type;
    typedef boost::optional<T> argument_type;

    constexpr result_type operator()(const argument_type& arg) const {
      return arg ? std::hash<T>()(*arg) : result_type();
    }
  };

  template <typename T>
  struct hash<boost::optional<T&> >
  {
    typedef std::size_t result_type;
    typedef boost::optional<T&> argument_type;

    constexpr result_type operator()(const argument_type& arg) const {
      return arg ? std::hash<T>()(*arg) : result_type();
    }
  };
}
# 69 "/usr/include/boost/optional/optional.hpp" 2 3 4

namespace boost { namespace optional_detail {

template <typename T>
struct optional_value_type
{
};

template <typename T>
struct optional_value_type< ::boost::optional<T> >
{
  typedef T type;
};

}}




namespace boost {

namespace optional_ns {


struct in_place_init_t
{
  struct init_tag{};
  explicit in_place_init_t(init_tag){}
};
const in_place_init_t in_place_init ((in_place_init_t::init_tag()));


struct in_place_init_if_t
{
  struct init_tag{};
  explicit in_place_init_if_t(init_tag){}
};
const in_place_init_if_t in_place_init_if ((in_place_init_if_t::init_tag()));

}

using optional_ns::in_place_init_t;
using optional_ns::in_place_init;
using optional_ns::in_place_init_if_t;
using optional_ns::in_place_init_if;

namespace optional_detail {

struct init_value_tag {};

struct optional_tag {};


template<class T>
class optional_base : public optional_tag
{
  private :

    typedef aligned_storage<T> storage_type ;
    typedef optional_base<T> this_type ;

  protected :

    typedef T value_type ;
    typedef typename boost::remove_const<T>::type unqualified_value_type;

  protected:
    typedef T & reference_type ;
    typedef T const& reference_const_type ;

    typedef T && rval_reference_type ;
    typedef T && reference_type_of_temporary_wrapper ;

    typedef T * pointer_type ;
    typedef T const* pointer_const_type ;
    typedef T const& argument_type ;



    optional_base()
      :
      m_initialized(false) {}



    optional_base ( none_t )
      :
      m_initialized(false) {}



    optional_base ( init_value_tag, argument_type val )
      :
      m_initialized(false)
    {
        construct(val);
    }




    optional_base ( init_value_tag, rval_reference_type val )
      :
      m_initialized(false)
    {
      construct( boost::move(val) );
    }




    optional_base ( bool cond, argument_type val )
      :
      m_initialized(false)
    {
      if ( cond )
        construct(val);
    }




    optional_base ( bool cond, rval_reference_type val )
      :
      m_initialized(false)
    {
      if ( cond )
        construct(boost::move(val));
    }




    optional_base ( optional_base const& rhs )
      :
      m_initialized(false)
    {
      if ( rhs.is_initialized() )
        construct(rhs.get_impl());
    }




    optional_base ( optional_base&& rhs )
    noexcept((::boost::is_nothrow_move_constructible<T>::value))
      :
      m_initialized(false)
    {
      if ( rhs.is_initialized() )
        construct( boost::move(rhs.get_impl()) );
    }




    template<class Expr, class PtrExpr>
    explicit optional_base ( Expr&& expr, PtrExpr const* tag )
      :
      m_initialized(false)
    {
      construct(boost::forward<Expr>(expr),tag);
    }
# 247 "/usr/include/boost/optional/optional.hpp" 3 4
    optional_base& operator= ( optional_base const& rhs )
    {
      this->assign(rhs);
      return *this;
    }


    optional_base& operator= ( optional_base && rhs )
    noexcept((::boost::is_nothrow_move_constructible<T>::value && ::boost::is_nothrow_move_assignable<T>::value))
    {
      this->assign(static_cast<optional_base&&>(rhs));
      return *this;
    }



    ~optional_base() { destroy() ; }


    void assign ( optional_base const& rhs )
    {
      if (is_initialized())
      {
        if ( rhs.is_initialized() )
             assign_value(rhs.get_impl());
        else destroy();
      }
      else
      {
        if ( rhs.is_initialized() )
          construct(rhs.get_impl());
      }
    }



    void assign ( optional_base&& rhs )
    {
      if (is_initialized())
      {
        if ( rhs.is_initialized() )
             assign_value( boost::move(rhs.get_impl()) );
        else destroy();
      }
      else
      {
        if ( rhs.is_initialized() )
          construct(boost::move(rhs.get_impl()));
      }
    }



    template<class U>
    void assign ( optional<U> const& rhs )
    {
      if (is_initialized())
      {
        if ( rhs.is_initialized() )

          assign_value( rhs.get() );




        else destroy();
      }
      else
      {
        if ( rhs.is_initialized() )

          construct(rhs.get());



      }
    }



    template<class U>
    void assign ( optional<U>&& rhs )
    {
      typedef typename optional<U>::rval_reference_type ref_type;
      if (is_initialized())
      {
        if ( rhs.is_initialized() )
             assign_value( static_cast<ref_type>(rhs.get()) );
        else destroy();
      }
      else
      {
        if ( rhs.is_initialized() )
          construct(static_cast<ref_type>(rhs.get()));
      }
    }



    void assign ( argument_type val )
    {
      if (is_initialized())
           assign_value(val);
      else construct(val);
    }



    void assign ( rval_reference_type val )
    {
      if (is_initialized())
           assign_value( boost::move(val) );
      else construct( boost::move(val) );
    }




    void assign ( none_t ) noexcept { destroy(); }




    template<class Expr, class ExprPtr>
    void assign_expr ( Expr&& expr, ExprPtr const* tag )
    {
      if (is_initialized())
        assign_expr_to_initialized(boost::forward<Expr>(expr),tag);
      else construct(boost::forward<Expr>(expr),tag);
    }
# 389 "/usr/include/boost/optional/optional.hpp" 3 4
  public :



    void reset() noexcept { destroy(); }


    void reset ( argument_type val ) { assign(val); }




    pointer_const_type get_ptr() const { return m_initialized ? get_ptr_impl() : 0 ; }
    pointer_type get_ptr() { return m_initialized ? get_ptr_impl() : 0 ; }

    bool is_initialized() const noexcept { return m_initialized ; }

  protected :

    void construct ( argument_type val )
     {
       ::new (m_storage.address()) unqualified_value_type(val) ;
       m_initialized = true ;
     }


    void construct ( rval_reference_type val )
     {
       ::new (m_storage.address()) unqualified_value_type( boost::move(val) ) ;
       m_initialized = true ;
     }






    template<class... Args>
    void construct ( in_place_init_t, Args&&... args )
    {
      ::new (m_storage.address()) unqualified_value_type( boost::forward<Args>(args)... ) ;
      m_initialized = true ;
    }

    template<class... Args>
    void emplace_assign ( Args&&... args )
    {
      destroy();
      construct(in_place_init, boost::forward<Args>(args)...);
    }

    template<class... Args>
    explicit optional_base ( in_place_init_t, Args&&... args )
      :
      m_initialized(false)
    {
      construct(in_place_init, boost::forward<Args>(args)...);
    }

    template<class... Args>
    explicit optional_base ( in_place_init_if_t, bool cond, Args&&... args )
      :
      m_initialized(false)
    {
      if ( cond )
        construct(in_place_init, boost::forward<Args>(args)...);
    }
# 605 "/usr/include/boost/optional/optional.hpp" 3 4
    template<class Expr>
    void construct ( Expr&& factory, in_place_factory_base const* )
     {
       boost_optional_detail::construct<value_type>(factory, m_storage.address());
       m_initialized = true ;
     }


    template<class Expr>
    void construct ( Expr&& factory, typed_in_place_factory_base const* )
     {
       factory.apply(m_storage.address()) ;
       m_initialized = true ;
     }

    template<class Expr>
    void assign_expr_to_initialized ( Expr&& factory, in_place_factory_base const* tag )
     {
       destroy();
       construct(factory,tag);
     }


    template<class Expr>
    void assign_expr_to_initialized ( Expr&& factory, typed_in_place_factory_base const* tag )
     {
       destroy();
       construct(factory,tag);
     }
# 675 "/usr/include/boost/optional/optional.hpp" 3 4
    template<class Expr>
    void construct ( Expr&& expr, void const* )
    {
      new (m_storage.address()) unqualified_value_type(boost::forward<Expr>(expr)) ;
      m_initialized = true ;
    }





    template<class Expr>
    void assign_expr_to_initialized ( Expr&& expr, void const* )
    {
      assign_value( boost::forward<Expr>(expr) );
    }
# 757 "/usr/include/boost/optional/optional.hpp" 3 4
    void assign_value ( argument_type val ) { get_impl() = val; }

    void assign_value ( rval_reference_type val ) { get_impl() = static_cast<rval_reference_type>(val); }


    void destroy()
    {
      if ( m_initialized )
        destroy_impl() ;
    }

    reference_const_type get_impl() const { return m_storage.ref() ; }
    reference_type get_impl() { return m_storage.ref() ; }

    pointer_const_type get_ptr_impl() const { return m_storage.ptr_ref(); }
    pointer_type get_ptr_impl() { return m_storage.ptr_ref(); }

  private :




    void destroy_impl ( ) { m_storage.ref().T::~T() ; m_initialized = false ; }


    bool m_initialized ;
    storage_type m_storage ;
} ;

# 1 "/usr/include/boost/optional/detail/optional_trivially_copyable_base.hpp" 1 3 4
# 14 "/usr/include/boost/optional/detail/optional_trivially_copyable_base.hpp" 3 4
template<class T>
class tc_optional_base : public optional_tag
{
  private :

    typedef tc_optional_base<T> this_type ;

  protected :

    typedef T value_type ;

  protected:
    typedef T & reference_type ;
    typedef T const& reference_const_type ;

    typedef T && rval_reference_type ;
    typedef T && reference_type_of_temporary_wrapper ;

    typedef T * pointer_type ;
    typedef T const* pointer_const_type ;
    typedef T const& argument_type ;

    tc_optional_base()
      :
      m_initialized(false) {}

    tc_optional_base ( none_t )
      :
      m_initialized(false) {}

    tc_optional_base ( init_value_tag, argument_type val )
      :
      m_initialized(true), m_storage(val) {}

    tc_optional_base ( bool cond, argument_type val )
      :
      m_initialized(cond), m_storage(val) {}






    template<class Expr, class PtrExpr>
    explicit tc_optional_base ( Expr&& expr, PtrExpr const* tag )
      :
      m_initialized(false)
    {
      construct(boost::forward<Expr>(expr),tag);
    }
# 83 "/usr/include/boost/optional/detail/optional_trivially_copyable_base.hpp" 3 4
    void assign ( tc_optional_base const& rhs )
    {
      *this = rhs;
    }


    template<class U>
    void assign ( optional<U> const& rhs )
    {
      if ( rhs.is_initialized() )

        m_storage = rhs.get();




      m_initialized = rhs.is_initialized();
    }



    template<class U>
    void assign ( optional<U>&& rhs )
    {
      typedef typename optional<U>::rval_reference_type ref_type;
      if ( rhs.is_initialized() )
        m_storage = static_cast<ref_type>(rhs.get());
      m_initialized = rhs.is_initialized();
    }


    void assign ( argument_type val )
    {
      construct(val);
    }

    void assign ( none_t ) { destroy(); }




    template<class Expr, class ExprPtr>
    void assign_expr ( Expr&& expr, ExprPtr const* tag )
    {
       construct(boost::forward<Expr>(expr),tag);
    }
# 139 "/usr/include/boost/optional/detail/optional_trivially_copyable_base.hpp" 3 4
  public :



    void reset() noexcept { destroy(); }


    void reset ( argument_type val ) noexcept { assign(val); }




    pointer_const_type get_ptr() const { return m_initialized ? get_ptr_impl() : 0 ; }
    pointer_type get_ptr() { return m_initialized ? get_ptr_impl() : 0 ; }

    bool is_initialized() const { return m_initialized ; }

  protected :

    void construct ( argument_type val )
     {
       m_storage = val ;
       m_initialized = true ;
     }





    template<class... Args>
    void construct ( in_place_init_t, Args&&... args )
    {
      m_storage = value_type( boost::forward<Args>(args)... ) ;
      m_initialized = true ;
    }

    template<class... Args>
    void emplace_assign ( Args&&... args )
    {
      construct(in_place_init, boost::forward<Args>(args)...);
    }

    template<class... Args>
    explicit tc_optional_base ( in_place_init_t, Args&&... args )
      :
      m_initialized(false)
    {
      construct(in_place_init, boost::forward<Args>(args)...);
    }

    template<class... Args>
    explicit tc_optional_base ( in_place_init_if_t, bool cond, Args&&... args )
      :
      m_initialized(false)
    {
      if ( cond )
        construct(in_place_init, boost::forward<Args>(args)...);
    }
# 338 "/usr/include/boost/optional/detail/optional_trivially_copyable_base.hpp" 3 4
    template<class Expr>
    void construct ( Expr&& factory, in_place_factory_base const* )
     {
       boost_optional_detail::construct<value_type>(factory, boost::addressof(m_storage));
       m_initialized = true ;
     }


    template<class Expr>
    void construct ( Expr&& factory, typed_in_place_factory_base const* )
     {
       factory.apply(boost::addressof(m_storage)) ;
       m_initialized = true ;
     }

    template<class Expr>
    void assign_expr_to_initialized ( Expr&& factory, in_place_factory_base const* tag )
     {
       destroy();
       construct(factory,tag);
     }


    template<class Expr>
    void assign_expr_to_initialized ( Expr&& factory, typed_in_place_factory_base const* tag )
     {
       destroy();
       construct(factory,tag);
     }
# 408 "/usr/include/boost/optional/detail/optional_trivially_copyable_base.hpp" 3 4
    template<class Expr>
    void construct ( Expr&& expr, void const* )
    {
      m_storage = value_type(boost::forward<Expr>(expr)) ;
      m_initialized = true ;
    }





    template<class Expr>
    void assign_expr_to_initialized ( Expr&& expr, void const* )
    {
      assign_value( boost::forward<Expr>(expr) );
    }
# 490 "/usr/include/boost/optional/detail/optional_trivially_copyable_base.hpp" 3 4
    void assign_value ( argument_type val ) { m_storage = val; }

    void assign_value ( rval_reference_type val ) { m_storage = static_cast<rval_reference_type>(val); }


    void destroy()
    {
      m_initialized = false;
    }

    reference_const_type get_impl() const { return m_storage ; }
    reference_type get_impl() { return m_storage ; }

    pointer_const_type get_ptr_impl() const { return boost::addressof(m_storage); }
    pointer_type get_ptr_impl() { return boost::addressof(m_storage); }

  private :

    bool m_initialized ;
    T m_storage ;
} ;
# 787 "/usr/include/boost/optional/optional.hpp" 2 3 4


template <typename U>
struct is_optional_or_tag
  : boost::conditional< boost::is_base_of<optional_detail::optional_tag, typename boost::decay<U>::type>::value
                     || boost::is_same<typename boost::decay<U>::type, none_t>::value
                     || boost::is_same<typename boost::decay<U>::type, in_place_init_t>::value
                     || boost::is_same<typename boost::decay<U>::type, in_place_init_if_t>::value,
    boost::true_type, boost::false_type>::type
{};

template <typename T, typename U>
struct has_dedicated_constructor
  : boost::disjunction<is_optional_or_tag<U>, boost::is_same<T, typename boost::decay<U>::type> >
{};

template <typename U>
struct is_in_place_factory
  : boost::disjunction< boost::is_base_of<boost::in_place_factory_base, typename boost::decay<U>::type>,
                        boost::is_base_of<boost::typed_in_place_factory_base, typename boost::decay<U>::type> >
{};



template <typename T, typename U>
struct is_factory_or_constructible_to_T
  : boost::disjunction< is_in_place_factory<U>, boost::is_constructible<T, U&&> >
{};

template <typename T, typename U>
struct is_optional_constructible : boost::is_constructible<T, U>
{};
# 839 "/usr/include/boost/optional/optional.hpp" 3 4
template <typename T, typename U>
struct is_opt_assignable
  : boost::conjunction<boost::is_convertible<U&&, T>, boost::is_assignable<T&, U&&> >
{};
# 861 "/usr/include/boost/optional/optional.hpp" 3 4
template <typename T, typename U>
struct is_factory_or_opt_assignable_to_T
  : boost::disjunction< is_in_place_factory<U>, is_opt_assignable<T, U> >
{};

template <typename T, typename U, bool = has_dedicated_constructor<T, U>::value>
struct is_optional_val_init_candidate
  : boost::false_type
{};

template <typename T, typename U>
struct is_optional_val_init_candidate<T, U, false>
  : is_factory_or_constructible_to_T<T, U>
{};

template <typename T, typename U, bool = has_dedicated_constructor<T, U>::value>
struct is_optional_val_assign_candidate
  : boost::false_type
{};

template <typename T, typename U>
struct is_optional_val_assign_candidate<T, U, false>
  : is_factory_or_opt_assignable_to_T<T, U>
{};

}

namespace optional_config {

template <typename T>
struct optional_uses_direct_storage_for
  : boost::conditional<(boost::is_scalar<T>::value && !boost::is_const<T>::value && !boost::is_volatile<T>::value)
                      , boost::true_type, boost::false_type>::type
{};

}
# 908 "/usr/include/boost/optional/optional.hpp" 3 4
template<class T>
class optional
  : public boost::conditional< optional_config::optional_uses_direct_storage_for<T>::value, optional_detail::tc_optional_base<T>, optional_detail::optional_base<T> >::type
{
    typedef typename boost::conditional< optional_config::optional_uses_direct_storage_for<T>::value, optional_detail::tc_optional_base<T>, optional_detail::optional_base<T> >::type base ;

  public :

    typedef optional<T> this_type ;

    typedef typename base::value_type value_type ;
    typedef typename base::reference_type reference_type ;
    typedef typename base::reference_const_type reference_const_type ;

    typedef typename base::rval_reference_type rval_reference_type ;
    typedef typename base::reference_type_of_temporary_wrapper reference_type_of_temporary_wrapper ;

    typedef typename base::pointer_type pointer_type ;
    typedef typename base::pointer_const_type pointer_const_type ;
    typedef typename base::argument_type argument_type ;



    optional() noexcept : base() {}



    optional( none_t none_ ) noexcept : base(none_) {}



    optional ( argument_type val ) : base(optional_detail::init_value_tag(), val) {}




    optional ( rval_reference_type val ) : base(optional_detail::init_value_tag(), boost::forward<T>(val))
      {}




    optional ( bool cond, argument_type val ) : base(cond,val) {}




    optional ( bool cond, rval_reference_type val ) : base( cond, boost::forward<T>(val) )
      {}







    template<class U>
    explicit optional ( optional<U> const& rhs

                        ,typename boost::enable_if< optional_detail::is_optional_constructible<T, U const&>, bool>::type = true

                      )
      :
      base()
    {
      if ( rhs.is_initialized() )
        this->construct(rhs.get());
    }





    template<class U>
    explicit optional ( optional<U> && rhs

                        ,typename boost::enable_if< optional_detail::is_optional_constructible<T, U>, bool>::type = true

                      )
      :
      base()
    {
      if ( rhs.is_initialized() )
        this->construct( boost::move(rhs.get()) );
    }
# 1008 "/usr/include/boost/optional/optional.hpp" 3 4
  template<class Expr>
  explicit optional ( Expr&& expr,
                      typename boost::enable_if< optional_detail::is_optional_val_init_candidate<T, Expr>, bool>::type = true
  )
    : base(boost::forward<Expr>(expr),boost::addressof(expr))
    {}
# 1024 "/usr/include/boost/optional/optional.hpp" 3 4
    optional ( optional const& ) = default;
# 1034 "/usr/include/boost/optional/optional.hpp" 3 4
    optional ( optional && ) = default;
# 1055 "/usr/include/boost/optional/optional.hpp" 3 4
    template<class Expr>
    typename boost::enable_if<optional_detail::is_optional_val_assign_candidate<T, Expr>, optional&>::type
    operator= ( Expr&& expr )
      {
        this->assign_expr(boost::forward<Expr>(expr),boost::addressof(expr));
        return *this ;
      }
# 1076 "/usr/include/boost/optional/optional.hpp" 3 4
    template<class U>
    optional& operator= ( optional<U> const& rhs )
      {
        this->assign(rhs);
        return *this ;
      }





    template<class U>
    optional& operator= ( optional<U> && rhs )
      {
        this->assign(boost::move(rhs));
        return *this ;
      }






    optional& operator= ( optional const& rhs ) = default;
# 1111 "/usr/include/boost/optional/optional.hpp" 3 4
    optional& operator= ( optional && ) = default;
# 1126 "/usr/include/boost/optional/optional.hpp" 3 4
    template <typename T_>
    typename boost::enable_if<boost::is_same<T, typename boost::decay<T_>::type>, optional&>::type
    operator= ( T_&& val )
      {
        this->assign( boost::forward<T_>(val) ) ;
        return *this ;
      }
# 1158 "/usr/include/boost/optional/optional.hpp" 3 4
    optional& operator= ( none_t none_ ) noexcept
      {
        this->assign( none_ ) ;
        return *this ;
      }




    template<class... Args>
    void emplace ( Args&&... args )
    {
      this->emplace_assign( boost::forward<Args>(args)... );
    }

    template<class... Args>
    explicit optional ( in_place_init_t, Args&&... args )
    : base( in_place_init, boost::forward<Args>(args)... )
    {}

    template<class... Args>
    explicit optional ( in_place_init_if_t, bool cond, Args&&... args )
    : base( in_place_init_if, cond, boost::forward<Args>(args)... )
    {}
# 1259 "/usr/include/boost/optional/optional.hpp" 3 4
    void swap( optional & arg )
      noexcept((::boost::is_nothrow_move_constructible<T>::value && ::boost::is_nothrow_move_assignable<T>::value))
      {

        boost::swap(*this, arg);
      }





    reference_const_type get() const { (static_cast <bool> (this->is_initialized()) ? void (0) : __assert_fail ("this->is_initialized()", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) ; return this->get_impl(); }
    reference_type get() { (static_cast <bool> (this->is_initialized()) ? void (0) : __assert_fail ("this->is_initialized()", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) ; return this->get_impl(); }


    reference_const_type get_value_or ( reference_const_type v ) const { return this->is_initialized() ? get() : v ; }
    reference_type get_value_or ( reference_type v ) { return this->is_initialized() ? get() : v ; }




    pointer_const_type operator->() const { (static_cast <bool> (this->is_initialized()) ? void (0) : __assert_fail ("this->is_initialized()", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) ; return this->get_ptr_impl() ; }
    pointer_type operator->() { (static_cast <bool> (this->is_initialized()) ? void (0) : __assert_fail ("this->is_initialized()", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)) ; return this->get_ptr_impl() ; }





    reference_const_type operator *() const& { return this->get() ; }
    reference_type operator *() & { return this->get() ; }
    reference_type_of_temporary_wrapper operator *() && { return boost::move(this->get()) ; }






    reference_const_type value() const&
      {
        if (this->is_initialized())
          return this->get() ;
        else
          throw_exception(bad_optional_access());
      }

    reference_type value() &
      {
        if (this->is_initialized())
          return this->get() ;
        else
          throw_exception(bad_optional_access());
      }

    reference_type_of_temporary_wrapper value() &&
      {
        if (this->is_initialized())
          return boost::move(this->get()) ;
        else
          throw_exception(bad_optional_access());
      }
# 1340 "/usr/include/boost/optional/optional.hpp" 3 4
    template <class U>
    value_type value_or ( U&& v ) const&
      {
        if (this->is_initialized())
          return get();
        else
          return boost::forward<U>(v);
      }

    template <class U>
    value_type value_or ( U&& v ) &&
      {
        if (this->is_initialized())
          return boost::move(get());
        else
          return boost::forward<U>(v);
      }
# 1388 "/usr/include/boost/optional/optional.hpp" 3 4
    template <typename F>
    value_type value_or_eval ( F f ) const&
      {
        if (this->is_initialized())
          return get();
        else
          return f();
      }

    template <typename F>
    value_type value_or_eval ( F f ) &&
      {
        if (this->is_initialized())
          return boost::move(get());
        else
          return f();
      }

    template <typename F>
    optional<typename boost::result_of<F(reference_type)>::type> map(F f) &
      {
        if (this->has_value())
          return f(get());
        else
          return none;
      }

    template <typename F>
    optional<typename boost::result_of<F(reference_const_type)>::type> map(F f) const&
      {
        if (this->has_value())
          return f(get());
        else
          return none;
      }

    template <typename F>
    optional<typename boost::result_of<F(reference_type_of_temporary_wrapper)>::type> map(F f) &&
      {
        if (this->has_value())
          return f(boost::move(this->get()));
        else
          return none;
      }

    template <typename F>
    optional<typename optional_detail::optional_value_type<typename boost::result_of<F(reference_type)>::type>::type> flat_map(F f) &
      {
        if (this->has_value())
          return f(get());
        else
          return none;
      }

    template <typename F>
    optional<typename optional_detail::optional_value_type<typename boost::result_of<F(reference_const_type)>::type>::type> flat_map(F f) const&
      {
        if (this->has_value())
          return f(get());
        else
          return none;
      }

    template <typename F>
    optional<typename optional_detail::optional_value_type<typename boost::result_of<F(reference_type_of_temporary_wrapper)>::type>::type> flat_map(F f) &&
      {
        if (this->has_value())
          return f(boost::move(get()));
        else
          return none;
      }
# 1508 "/usr/include/boost/optional/optional.hpp" 3 4
    bool has_value() const noexcept { return this->is_initialized() ; }

    bool operator!() const noexcept { return !this->is_initialized() ; }

    inline __attribute__ ((__always_inline__)) explicit operator bool () const noexcept { return !this->operator! (); }
} ;

}



namespace boost {


template<class T>
class optional<T&&>
{
  static_assert(sizeof(T) == 0, "Optional rvalue references are illegal.");
} ;


}


# 1 "/usr/include/boost/optional/detail/optional_reference_spec.hpp" 1 3 4
# 22 "/usr/include/boost/optional/detail/optional_reference_spec.hpp" 3 4
namespace boost {

namespace detail {



template <class From>
void prevent_binding_rvalue()
{

    static_assert(boost::is_lvalue_reference<From>::value, "binding rvalue references to optional lvalue references is disallowed");


}

template <class T>
typename boost::remove_reference<T>::type& forward_reference(T&& r)
{
    static_assert(boost::is_lvalue_reference<T>::value, "binding rvalue references to optional lvalue references is disallowed");

    return boost::forward<T>(r);
}




template <class T>
struct is_const_integral
{
  static const bool value = boost::is_const<T>::value && boost::is_integral<T>::value;
};

template <class T>
struct is_const_integral_bad_for_conversion
{



  static const bool value = false;

};

template <class From>
void prevent_assignment_from_false_const_integral()
{
# 75 "/usr/include/boost/optional/detail/optional_reference_spec.hpp" 3 4
}


template <class T>
struct is_optional_
{
  static const bool value = false;
};

template <class U>
struct is_optional_< ::boost::optional<U> >
{
  static const bool value = true;
};

template <class T>
struct is_no_optional
{
  static const bool value = !is_optional_<typename boost::decay<T>::type>::value;
};


template <class T, class U>
  struct is_same_decayed
  {
    static const bool value = ::boost::is_same<T, typename ::boost::remove_reference<U>::type>::value
                           || ::boost::is_same<T, const typename ::boost::remove_reference<U>::type>::value;
  };

template <class T, class U>
struct no_unboxing_cond
{
  static const bool value = is_no_optional<U>::value && !is_same_decayed<T, U>::value;
};


}

template <class T>
class optional<T&> : public optional_detail::optional_tag
{
    T* ptr_;

public:
    typedef T& value_type;
    typedef T& reference_type;
    typedef T& reference_const_type;
    typedef T& rval_reference_type;
    typedef T* pointer_type;
    typedef T* pointer_const_type;

    optional() noexcept : ptr_() {}
    optional(none_t) noexcept : ptr_() {}

    template <class U>
        explicit optional(const optional<U&>& rhs) noexcept : ptr_(rhs.get_ptr()) {}
    optional(const optional& rhs) noexcept : ptr_(rhs.get_ptr()) {}


    template <class U>
      explicit optional(U& rhs, typename boost::enable_if_c<detail::is_same_decayed<T, U>::value && detail::is_const_integral_bad_for_conversion<U>::value, bool>::type = true) noexcept
      : ptr_(boost::addressof(rhs)) {}

    template <class U>
      optional(U& rhs, typename boost::enable_if_c<detail::is_same_decayed<T, U>::value && !detail::is_const_integral_bad_for_conversion<U>::value, bool>::type = true) noexcept
      : ptr_(boost::addressof(rhs)) {}

    optional& operator=(const optional& rhs) noexcept { ptr_ = rhs.get_ptr(); return *this; }
    template <class U>
        optional& operator=(const optional<U&>& rhs) noexcept { ptr_ = rhs.get_ptr(); return *this; }
    optional& operator=(none_t) noexcept { ptr_ = 0; return *this; }


    void swap(optional& rhs) noexcept { std::swap(ptr_, rhs.ptr_); }
    T& get() const { (static_cast <bool> (ptr_) ? void (0) : __assert_fail ("ptr_", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); return *ptr_; }

    T* get_ptr() const noexcept { return ptr_; }
    T* operator->() const { (static_cast <bool> (ptr_) ? void (0) : __assert_fail ("ptr_", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); return ptr_; }
    T& operator*() const { (static_cast <bool> (ptr_) ? void (0) : __assert_fail ("ptr_", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); return *ptr_; }

    T& value() const
    {
      if (this->is_initialized())
        return this->get();
      else
        throw_exception(bad_optional_access());
    }

    bool operator!() const noexcept { return ptr_ == 0; }
    inline __attribute__ ((__always_inline__)) explicit operator bool () const noexcept { return !this->operator! (); }

    void reset() noexcept { ptr_ = 0; }

    bool is_initialized() const noexcept { return ptr_ != 0; }
    bool has_value() const noexcept { return ptr_ != 0; }

    template <typename F>
    optional<typename boost::result_of<F(T&)>::type> map(F f) const
    {
      if (this->has_value())
        return f(this->get());
      else
        return none;
    }

    template <typename F>
    optional<typename optional_detail::optional_value_type<typename boost::result_of<F(T&)>::type>::type> flat_map(F f) const
      {
        if (this->has_value())
          return f(get());
        else
          return none;
      }



    optional(T&& ) noexcept { detail::prevent_binding_rvalue<T&&>(); }

    template <class R>
        optional(R&& r, typename boost::enable_if<detail::no_unboxing_cond<T, R>, bool>::type = true) noexcept
        : ptr_(boost::addressof(r)) { detail::prevent_binding_rvalue<R>(); }

    template <class R>
        optional(bool cond, R&& r, typename boost::enable_if<detail::is_no_optional<R>, bool>::type = true) noexcept
        : ptr_(cond ? boost::addressof(r) : 0) { detail::prevent_binding_rvalue<R>(); }

    template <class R>
        typename boost::enable_if<detail::is_no_optional<R>, optional<T&>&>::type
        operator=(R&& r) noexcept { detail::prevent_binding_rvalue<R>(); ptr_ = boost::addressof(r); return *this; }

    template <class R>
        void emplace(R&& r, typename boost::enable_if<detail::is_no_optional<R>, bool>::type = true) noexcept
        { detail::prevent_binding_rvalue<R>(); ptr_ = boost::addressof(r); }

    template <class R>
      T& get_value_or(R&& r, typename boost::enable_if<detail::is_no_optional<R>, bool>::type = true) const noexcept
      { detail::prevent_binding_rvalue<R>(); return ptr_ ? *ptr_ : r; }

    template <class R>
        T& value_or(R&& r, typename boost::enable_if<detail::is_no_optional<R>, bool>::type = true) const noexcept
        { detail::prevent_binding_rvalue<R>(); return ptr_ ? *ptr_ : r; }

    template <class R>
      void reset(R&& r, typename boost::enable_if<detail::is_no_optional<R>, bool>::type = true) noexcept
      { detail::prevent_binding_rvalue<R>(); ptr_ = boost::addressof(r); }

    template <class F>
        T& value_or_eval(F f) const { return ptr_ ? *ptr_ : detail::forward_reference(f()); }
# 267 "/usr/include/boost/optional/detail/optional_reference_spec.hpp" 3 4
};

template <class T>
  void swap ( optional<T&>& x, optional<T&>& y) noexcept
{
  x.swap(y);
}

}
# 1533 "/usr/include/boost/optional/optional.hpp" 2 3 4


namespace boost {



template<class T>
inline
optional<typename boost::decay<T>::type> make_optional ( T && v )
{
  return optional<typename boost::decay<T>::type>(boost::forward<T>(v));
}


template<class T>
inline
optional<typename boost::decay<T>::type> make_optional ( bool cond, T && v )
{
  return optional<typename boost::decay<T>::type>(cond,boost::forward<T>(v));
}
# 1576 "/usr/include/boost/optional/optional.hpp" 3 4
template<class T>
inline
typename optional<T>::reference_const_type
get ( optional<T> const& opt )
{
  return opt.get() ;
}

template<class T>
inline
typename optional<T>::reference_type
get ( optional<T>& opt )
{
  return opt.get() ;
}



template<class T>
inline
typename optional<T>::pointer_const_type
get ( optional<T> const* opt )
{
  return opt->get_ptr() ;
}

template<class T>
inline
typename optional<T>::pointer_type
get ( optional<T>* opt )
{
  return opt->get_ptr() ;
}



template<class T>
inline
typename optional<T>::reference_const_type
get_optional_value_or ( optional<T> const& opt, typename optional<T>::reference_const_type v )
{
  return opt.get_value_or(v) ;
}

template<class T>
inline
typename optional<T>::reference_type
get_optional_value_or ( optional<T>& opt, typename optional<T>::reference_type v )
{
  return opt.get_value_or(v) ;
}



template<class T>
inline
typename optional<T>::pointer_const_type
get_pointer ( optional<T> const& opt )
{
  return opt.get_ptr() ;
}

template<class T>
inline
typename optional<T>::pointer_type
get_pointer ( optional<T>& opt )
{
  return opt.get_ptr() ;
}

}


namespace boost {


template<class CharType, class CharTrait>
std::basic_ostream<CharType, CharTrait>&
operator<<(std::basic_ostream<CharType, CharTrait>& os, optional_detail::optional_tag const&)
{
  static_assert(sizeof(CharType) == 0, "If you want to output boost::optional, include header <boost/optional/optional_io.hpp>");
  return os;
}

}


# 1 "/usr/include/boost/optional/detail/optional_relops.hpp" 1 3 4
# 16 "/usr/include/boost/optional/detail/optional_relops.hpp" 3 4
namespace boost {
# 26 "/usr/include/boost/optional/detail/optional_relops.hpp" 3 4
template<class T>
inline
bool operator == ( optional<T> const& x, optional<T> const& y )
{ return bool(x) && bool(y) ? *x == *y : bool(x) == bool(y); }

template<class T>
inline
bool operator < ( optional<T> const& x, optional<T> const& y )
{ return less_pointees(x,y); }

template<class T>
inline
bool operator != ( optional<T> const& x, optional<T> const& y )
{ return !( x == y ) ; }

template<class T>
inline
bool operator > ( optional<T> const& x, optional<T> const& y )
{ return y < x ; }

template<class T>
inline
bool operator <= ( optional<T> const& x, optional<T> const& y )
{ return !( y < x ) ; }

template<class T>
inline
bool operator >= ( optional<T> const& x, optional<T> const& y )
{ return !( x < y ) ; }





template<class T>
inline
bool operator == ( optional<T> const& x, T const& y )
{ return equal_pointees(x, optional<T>(y)); }

template<class T>
inline
bool operator < ( optional<T> const& x, T const& y )
{ return less_pointees(x, optional<T>(y)); }

template<class T>
inline
bool operator != ( optional<T> const& x, T const& y )
{ return !( x == y ) ; }

template<class T>
inline
bool operator > ( optional<T> const& x, T const& y )
{ return y < x ; }

template<class T>
inline
bool operator <= ( optional<T> const& x, T const& y )
{ return !( y < x ) ; }

template<class T>
inline
bool operator >= ( optional<T> const& x, T const& y )
{ return !( x < y ) ; }





template<class T>
inline
bool operator == ( T const& x, optional<T> const& y )
{ return equal_pointees( optional<T>(x), y ); }

template<class T>
inline
bool operator < ( T const& x, optional<T> const& y )
{ return less_pointees( optional<T>(x), y ); }

template<class T>
inline
bool operator != ( T const& x, optional<T> const& y )
{ return !( x == y ) ; }

template<class T>
inline
bool operator > ( T const& x, optional<T> const& y )
{ return y < x ; }

template<class T>
inline
bool operator <= ( T const& x, optional<T> const& y )
{ return !( y < x ) ; }

template<class T>
inline
bool operator >= ( T const& x, optional<T> const& y )
{ return !( x < y ) ; }






template<class T>
inline
bool operator == ( optional<T> const& x, none_t ) noexcept
{ return !x; }

template<class T>
inline
bool operator < ( optional<T> const& x, none_t )
{ return less_pointees(x,optional<T>() ); }

template<class T>
inline
bool operator != ( optional<T> const& x, none_t ) noexcept
{ return bool(x); }

template<class T>
inline
bool operator > ( optional<T> const& x, none_t y )
{ return y < x ; }

template<class T>
inline
bool operator <= ( optional<T> const& x, none_t y )
{ return !( y < x ) ; }

template<class T>
inline
bool operator >= ( optional<T> const& x, none_t y )
{ return !( x < y ) ; }





template<class T>
inline
bool operator == ( none_t , optional<T> const& y ) noexcept
{ return !y; }

template<class T>
inline
bool operator < ( none_t , optional<T> const& y )
{ return less_pointees(optional<T>() ,y); }

template<class T>
inline
bool operator != ( none_t, optional<T> const& y ) noexcept
{ return bool(y); }

template<class T>
inline
bool operator > ( none_t x, optional<T> const& y )
{ return y < x ; }

template<class T>
inline
bool operator <= ( none_t x, optional<T> const& y )
{ return !( y < x ) ; }

template<class T>
inline
bool operator >= ( none_t x, optional<T> const& y )
{ return !( x < y ) ; }

}
# 1664 "/usr/include/boost/optional/optional.hpp" 2 3 4
# 1 "/usr/include/boost/optional/detail/optional_swap.hpp" 1 3 4
# 19 "/usr/include/boost/optional/detail/optional_swap.hpp" 3 4
namespace boost {

namespace optional_detail {

template <bool use_default_constructor> struct swap_selector;

template <>
struct swap_selector<true>
{
    template <class T>
    static void optional_swap ( optional<T>& x, optional<T>& y )
    {
        const bool hasX = !!x;
        const bool hasY = !!y;

        if ( !hasX && !hasY )
            return;

        if( !hasX )
            x.emplace();
        else if ( !hasY )
            y.emplace();


        boost::swap(x.get(), y.get());

        if( !hasX )
            y = boost::none ;
        else if( !hasY )
            x = boost::none ;
    }
};
# 62 "/usr/include/boost/optional/detail/optional_swap.hpp" 3 4
template <>
struct swap_selector<false>
{
    template <class T>
    static void optional_swap ( optional<T>& x, optional<T>& y )

    {
        if (x)
        {
            if (y)
            {
                boost::swap(*x, *y);
            }
            else
            {
                y = boost::move(*x);
                x = boost::none;
            }
        }
        else
        {
            if (y)
            {
                x = boost::move(*y);
                y = boost::none;
            }
        }
    }
};

}



template<class T>
struct optional_swap_should_use_default_constructor : boost::false_type {} ;
# 106 "/usr/include/boost/optional/detail/optional_swap.hpp" 3 4
template <class T>
inline void swap ( optional<T>& x, optional<T>& y )

{
    optional_detail::swap_selector<optional_swap_should_use_default_constructor<T>::value>::optional_swap(x, y);
}

}
# 1665 "/usr/include/boost/optional/optional.hpp" 2 3 4
# 14 "/usr/include/boost/range/detail/default_constructible_unary_fn.hpp" 2 3 4

# 1 "/usr/include/boost/type_traits/has_trivial_constructor.hpp" 1 3 4
# 37 "/usr/include/boost/type_traits/has_trivial_constructor.hpp" 3 4
namespace boost {

template <typename T> struct has_trivial_constructor

   : public integral_constant <bool, ((::boost::is_pod<T>::value || __is_trivially_constructible(T)) && is_default_constructible<T>::value)>{};




template <> struct has_trivial_constructor<void> : public boost::false_type{};
template <> struct has_trivial_constructor<void const> : public boost::false_type{};
template <> struct has_trivial_constructor<void const volatile> : public boost::false_type{};
template <> struct has_trivial_constructor<void volatile> : public boost::false_type{};

template <class T> struct has_trivial_default_constructor : public has_trivial_constructor<T> {};



}
# 16 "/usr/include/boost/range/detail/default_constructible_unary_fn.hpp" 2 3 4

namespace boost
{
    namespace range_detail
    {

template<typename F, typename R>
class default_constructible_unary_fn_wrapper
{
public:
    typedef R result_type;

    default_constructible_unary_fn_wrapper()
    {
    }
    default_constructible_unary_fn_wrapper(const F& source)
        : m_impl(source)
    {
    }
    default_constructible_unary_fn_wrapper(const default_constructible_unary_fn_wrapper& source)
        : m_impl(source.m_impl)
    {
    }
    default_constructible_unary_fn_wrapper& operator=(const default_constructible_unary_fn_wrapper& source)
    {
        if (source.m_impl)
        {

            m_impl.emplace(*source.m_impl);
        }
        else
        {
            m_impl.reset();
        }
        return *this;
    }
    template<typename Arg>
    R operator()(const Arg& arg) const
    {
        (static_cast <bool> (m_impl) ? void (0) : __assert_fail ("m_impl", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        return (*m_impl)(arg);
    }
    template<typename Arg>
    R operator()(Arg& arg) const
    {
        (static_cast <bool> (m_impl) ? void (0) : __assert_fail ("m_impl", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
        return (*m_impl)(arg);
    }
private:
    boost::optional<F> m_impl;
};

template<typename F, typename R>
struct default_constructible_unary_fn_gen
{
    typedef typename boost::mpl::if_<
        boost::has_trivial_default_constructor<F>,
        F,
        default_constructible_unary_fn_wrapper<F,R>
    >::type type;
};

    }
}
# 16 "/usr/include/boost/range/adaptor/transformed.hpp" 2 3 4


# 1 "/usr/include/boost/iterator/transform_iterator.hpp" 1 3 4
# 34 "/usr/include/boost/iterator/transform_iterator.hpp" 3 4
# 1 "/usr/include/boost/iterator/detail/config_def.hpp" 1 3 4
# 35 "/usr/include/boost/iterator/transform_iterator.hpp" 2 3 4


namespace boost {
namespace iterators {

  template <class UnaryFunction, class Iterator, class Reference = use_default, class Value = use_default>
  class transform_iterator;

  namespace detail
  {

    template <class UnaryFunc, class Iterator, class Reference, class Value>
    struct transform_iterator_base
    {
     private:


        typedef typename ia_dflt_help<
            Reference



          , result_of<const UnaryFunc&(typename std::iterator_traits<Iterator>::reference)>

        >::type reference;






        typedef typename ia_dflt_help<
            Value
          , remove_reference<reference>
        >::type cv_value_type;

     public:
        typedef iterator_adaptor<
            transform_iterator<UnaryFunc, Iterator, Reference, Value>
          , Iterator
          , cv_value_type
          , use_default
          , reference
        > type;
    };
  }

  template <class UnaryFunc, class Iterator, class Reference, class Value>
  class transform_iterator
    : public boost::iterators::detail::transform_iterator_base<UnaryFunc, Iterator, Reference, Value>::type
  {
    typedef typename
    boost::iterators::detail::transform_iterator_base<UnaryFunc, Iterator, Reference, Value>::type
    super_t;

    friend class iterator_core_access;

  public:
    transform_iterator() { }

    transform_iterator(Iterator const& x, UnaryFunc f)
      : super_t(x), m_f(f) { }

    explicit transform_iterator(Iterator const& x)
      : super_t(x)
    {





        static_assert(is_class<UnaryFunc>::value, "is_class<UnaryFunc>::value");

    }

    template <
        class OtherUnaryFunction
      , class OtherIterator
      , class OtherReference
      , class OtherValue>
    transform_iterator(
         transform_iterator<OtherUnaryFunction, OtherIterator, OtherReference, OtherValue> const& t
       , typename enable_if_convertible<OtherIterator, Iterator>::type* = 0

       , typename enable_if_convertible<OtherUnaryFunction, UnaryFunc>::type* = 0

    )
      : super_t(t.base()), m_f(t.functor())
   {}

    UnaryFunc functor() const
      { return m_f; }

  private:
    typename super_t::reference dereference() const
    { return m_f(*this->base()); }



    UnaryFunc m_f;
  };

  template <class UnaryFunc, class Iterator>
  inline transform_iterator<UnaryFunc, Iterator>
  make_transform_iterator(Iterator it, UnaryFunc fun)
  {
      return transform_iterator<UnaryFunc, Iterator>(it, fun);
  }
# 151 "/usr/include/boost/iterator/transform_iterator.hpp" 3 4
  template <class UnaryFunc, class Iterator>
  inline typename iterators::enable_if<
      is_class<UnaryFunc>
    , transform_iterator<UnaryFunc, Iterator>
  >::type
  make_transform_iterator(Iterator it)
  {
      return transform_iterator<UnaryFunc, Iterator>(it, UnaryFunc());
  }
# 170 "/usr/include/boost/iterator/transform_iterator.hpp" 3 4
}

using iterators::transform_iterator;
using iterators::make_transform_iterator;

}

# 1 "/usr/include/boost/iterator/detail/config_undef.hpp" 1 3 4
# 178 "/usr/include/boost/iterator/transform_iterator.hpp" 2 3 4
# 19 "/usr/include/boost/range/adaptor/transformed.hpp" 2 3 4


namespace boost
{
    namespace range_detail
    {


        template<typename P, typename It>
        struct transform_iterator_gen
        {
            typedef transform_iterator<
                typename default_constructible_unary_fn_gen<
                    P,
                    typename transform_iterator<P, It>::reference
                >::type,
                It
            > type;
        };

        template< class F, class R >
        struct transformed_range :
            public boost::iterator_range<
                typename transform_iterator_gen<
                    F, typename range_iterator<R>::type>::type>
        {
        private:
            typedef typename transform_iterator_gen<
                F, typename range_iterator<R>::type>::type transform_iter_t;

            typedef boost::iterator_range<transform_iter_t> base;

        public:
            typedef typename default_constructible_unary_fn_gen<
                F,
                typename transform_iterator<
                    F,
                    typename range_iterator<R>::type
                >::reference
            >::type transform_fn_type;

            typedef R source_range_type;

            transformed_range(transform_fn_type f, R& r)
                : base(transform_iter_t(boost::begin(r), f),
                       transform_iter_t(boost::end(r), f))
            {
            }
        };

        template< class T >
        struct transform_holder : holder<T>
        {
            transform_holder( T r ) : holder<T>(r)
            {
            }
        };

        template< class SinglePassRange, class UnaryFunction >
        inline transformed_range<UnaryFunction,SinglePassRange>
        operator|( SinglePassRange& r,
                   const transform_holder<UnaryFunction>& f )
        {
            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( SinglePassRangeConcept<SinglePassRange>)>::failed> boost_concept_check83 __attribute__((__unused__));


            return transformed_range<UnaryFunction,SinglePassRange>( f.val, r );
        }

        template< class SinglePassRange, class UnaryFunction >
        inline transformed_range<UnaryFunction, const SinglePassRange>
        operator|( const SinglePassRange& r,
                   const transform_holder<UnaryFunction>& f )
        {
            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( SinglePassRangeConcept<const SinglePassRange>)>::failed> boost_concept_check94 __attribute__((__unused__));


           return transformed_range<UnaryFunction, const SinglePassRange>(
               f.val, r);
        }

    }

    using range_detail::transformed_range;

    namespace adaptors
    {
        namespace
        {
            const range_detail::forwarder<range_detail::transform_holder>
                    transformed =
                      range_detail::forwarder<range_detail::transform_holder>();
        }

        template<class UnaryFunction, class SinglePassRange>
        inline transformed_range<UnaryFunction, SinglePassRange>
        transform(SinglePassRange& rng, UnaryFunction fn)
        {
            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( SinglePassRangeConcept<SinglePassRange>)>::failed> boost_concept_check118 __attribute__((__unused__));


            return transformed_range<UnaryFunction, SinglePassRange>(fn, rng);
        }

        template<class UnaryFunction, class SinglePassRange>
        inline transformed_range<UnaryFunction, const SinglePassRange>
        transform(const SinglePassRange& rng, UnaryFunction fn)
        {
            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( SinglePassRangeConcept<const SinglePassRange>)>::failed> boost_concept_check128 __attribute__((__unused__));


            return transformed_range<UnaryFunction, const SinglePassRange>(
                fn, rng);
        }
    }

}
# 31 "/home/avi/scylla-maint/seastar/include/seastar/rpc/rpc_impl.hh" 2
# 1 "/home/avi/scylla-maint/seastar/include/seastar/net/packet-data-source.hh" 1
# 23 "/home/avi/scylla-maint/seastar/include/seastar/net/packet-data-source.hh"
namespace seastar {

namespace net {

class packet_data_source final : public data_source_impl {
    size_t _cur_frag = 0;
    packet _p;
public:
    explicit packet_data_source(net::packet&& p)
        : _p(std::move(p))
    {}

    virtual future<temporary_buffer<char>> get() override {
        if (_cur_frag != _p.nr_frags()) {
            auto& f = _p.fragments()[_cur_frag++];
            return make_ready_future<temporary_buffer<char>>(
                    temporary_buffer<char>(f.base, f.size,
                            make_deleter(deleter(), [p = _p.share()] () mutable {})));
        }
        return make_ready_future<temporary_buffer<char>>(temporary_buffer<char>());
    }
};

static inline
input_stream<char> as_input_stream(packet&& p) {
    return input_stream<char>(data_source(std::make_unique<packet_data_source>(std::move(p))));
}

}

}
# 32 "/home/avi/scylla-maint/seastar/include/seastar/rpc/rpc_impl.hh" 2


namespace seastar {

namespace rpc {

enum class exception_type : uint32_t {
    USER = 0,
    UNKNOWN_VERB = 1,
};

template<typename T>
struct remove_optional {
    using type = T;
};

template<typename T>
struct remove_optional<optional<T>> {
    using type = T;
};

struct wait_type {};


struct do_want_client_info {};
struct dont_want_client_info {};


struct do_want_time_point {};
struct dont_want_time_point {};


template <typename Ret, typename... In>
struct signature<Ret (In...)> {
    using ret_type = Ret;
    using arg_types = std::tuple<In...>;
    using clean = signature;
    using want_client_info = dont_want_client_info;
    using want_time_point = dont_want_time_point;
};


template <typename Ret, typename... In>
struct signature<Ret (const client_info&, In...)> {
    using ret_type = Ret;
    using arg_types = std::tuple<In...>;
    using clean = signature<Ret (In...)>;
    using want_client_info = do_want_client_info;
    using want_time_point = dont_want_time_point;
};

template <typename Ret, typename... In>
struct signature<Ret (client_info&, In...)> {
    using ret_type = Ret;
    using arg_types = std::tuple<In...>;
    using clean = signature<Ret (In...)>;
    using want_client_info = do_want_client_info;
    using want_time_point = dont_want_time_point;
};


template <typename Ret, typename... In>
struct signature<Ret (const client_info&, opt_time_point, In...)> {
    using ret_type = Ret;
    using arg_types = std::tuple<In...>;
    using clean = signature<Ret (In...)>;
    using want_client_info = do_want_client_info;
    using want_time_point = do_want_time_point;
};

template <typename Ret, typename... In>
struct signature<Ret (client_info&, opt_time_point, In...)> {
    using ret_type = Ret;
    using arg_types = std::tuple<In...>;
    using clean = signature<Ret (In...)>;
    using want_client_info = do_want_client_info;
    using want_time_point = do_want_time_point;
};


template <typename Ret, typename... In>
struct signature<Ret (opt_time_point, In...)> {
    using ret_type = Ret;
    using arg_types = std::tuple<In...>;
    using clean = signature<Ret (In...)>;
    using want_client_info = dont_want_client_info;
    using want_time_point = do_want_time_point;
};

template <typename T>
struct wait_signature {
    using type = wait_type;
    using cleaned_type = T;
};

template <typename... T>
struct wait_signature<future<T...>> {
    using type = wait_type;
    using cleaned_type = future<T...>;
};

template <>
struct wait_signature<no_wait_type> {
    using type = no_wait_type;
    using cleaned_type = void;
};

template <>
struct wait_signature<future<no_wait_type>> {
    using type = no_wait_type;
    using cleaned_type = future<>;
};

template <typename T>
using wait_signature_t = typename wait_signature<T>::type;

template <typename... In>
inline
std::tuple<In...>
maybe_add_client_info(dont_want_client_info, client_info&, std::tuple<In...>&& args) {
    return std::move(args);
}

template <typename... In>
inline
std::tuple<std::reference_wrapper<client_info>, In...>
maybe_add_client_info(do_want_client_info, client_info& ci, std::tuple<In...>&& args) {
    return std::tuple_cat(std::make_tuple(std::ref(ci)), std::move(args));
}

template <typename... In>
inline
std::tuple<In...>
maybe_add_time_point(dont_want_time_point, opt_time_point&, std::tuple<In...>&& args) {
    return std::move(args);
}

template <typename... In>
inline
std::tuple<opt_time_point, In...>
maybe_add_time_point(do_want_time_point, opt_time_point& otp, std::tuple<In...>&& args) {
    return std::tuple_cat(std::make_tuple(otp), std::move(args));
}

inline sstring serialize_connection_id(const connection_id& id) {
    sstring p = uninitialized_string(sizeof(id));
    auto c = p.data();
    write_le(c, id.id());
    return p;
}

inline connection_id deserialize_connection_id(const sstring& s) {
    using id_type = decltype(connection_id{0}.id());
    auto p = s.c_str();
    auto id = read_le<id_type>(p);
    return connection_id{id};
}

template <bool IsSmartPtr>
struct serialize_helper;

template <>
struct serialize_helper<false> {
    template <typename Serializer, typename Output, typename T>
    static inline void serialize(Serializer& serializer, Output& out, const T& t) {
        return write(serializer, out, t);
    }
};

template <>
struct serialize_helper<true> {
    template <typename Serializer, typename Output, typename T>
    static inline void serialize(Serializer& serializer, Output& out, const T& t) {
        return write(serializer, out, *t);
    }
};

template <typename Serializer, typename Output, typename... T>
inline void do_marshall(Serializer& serializer, Output& out, const T&... args);

template <typename Serializer, typename Output>
struct marshall_one {
    template <typename T> struct helper {
        static void doit(Serializer& serializer, Output& out, const T& arg) {
            using serialize_helper_type = serialize_helper<is_smart_ptr<typename std::remove_reference_t<T>>::value>;
            serialize_helper_type::serialize(serializer, out, arg);
        }
    };
    template<typename T> struct helper<std::reference_wrapper<const T>> {
        static void doit(Serializer& serializer, Output& out, const std::reference_wrapper<const T>& arg) {
            helper<T>::doit(serializer, out, arg.get());
        }
    };
    static void put_connection_id(const connection_id& cid, Output& out) {
        sstring id = serialize_connection_id(cid);
        out.write(id.c_str(), id.size());
    }
    template <typename... T> struct helper<sink<T...>> {
        static void doit(Serializer&, Output& out, const sink<T...>& arg) {
            put_connection_id(arg.get_id(), out);
        }
    };
    template <typename... T> struct helper<source<T...>> {
        static void doit(Serializer&, Output& out, const source<T...>& arg) {
            put_connection_id(arg.get_id(), out);
        }
    };
    template <typename... T> struct helper<tuple<T...>> {
        static void doit(Serializer& serializer, Output& out, const tuple<T...>& arg) {
            auto do_do_marshall = [&serializer, &out] (const auto&... args) {
                do_marshall(serializer, out, args...);
            };




            std::apply(do_do_marshall, static_cast<const std::tuple<T...>&>(arg));
        }
    };
};

template <typename Serializer, typename Output, typename... T>
inline void do_marshall(Serializer& serializer, Output& out, const T&... args) {

    (void)std::initializer_list<int>{(marshall_one<Serializer, Output>::template helper<T>::doit(serializer, out, args), 1)...};
}

static inline memory_output_stream<snd_buf::iterator> make_serializer_stream(snd_buf& output) {
    auto* b = std::get_if<temporary_buffer<char>>(&output.bufs);
    if (b) {
        return memory_output_stream<snd_buf::iterator>(memory_output_stream<snd_buf::iterator>::simple(b->get_write(), b->size()));
    } else {
        auto& ar = std::get<std::vector<temporary_buffer<char>>>(output.bufs);
        return memory_output_stream<snd_buf::iterator>(memory_output_stream<snd_buf::iterator>::fragmented(ar.begin(), output.size));
    }
}

template <typename Serializer, typename... T>
inline snd_buf marshall(Serializer& serializer, size_t head_space, const T&... args) {
    measuring_output_stream measure;
    do_marshall(serializer, measure, args...);
    snd_buf ret(measure.size() + head_space);
    auto out = make_serializer_stream(ret);
    out.skip(head_space);
    do_marshall(serializer, out, args...);
    return ret;
}

template <typename Serializer, typename Input, typename... T>
std::tuple<T...> do_unmarshall(connection& c, Input& in);

template<typename Serializer, typename Input>
struct unmarshal_one {
    template<typename T> struct helper {
        static T doit(connection& c, Input& in) {
            return read(c.serializer<Serializer>(), in, type<T>());
        }
    };
    template<typename T> struct helper<optional<T>> {
        static optional<T> doit(connection& c, Input& in) {
            if (in.size()) {
                return optional<T>(read(c.serializer<Serializer>(), in, type<typename remove_optional<T>::type>()));
            } else {
                return optional<T>();
            }
        }
    };
    template<typename T> struct helper<std::reference_wrapper<const T>> {
        static T doit(connection& c, Input& in) {
            return helper<T>::doit(c, in);
        }
    };
    static connection_id get_connection_id(Input& in) {
        sstring id = uninitialized_string(sizeof(connection_id));
        in.read(id.data(), sizeof(connection_id));
        return deserialize_connection_id(id);
    }
    template<typename... T> struct helper<sink<T...>> {
        static sink<T...> doit(connection& c, Input& in) {
            return sink<T...>(make_shared<sink_impl<Serializer, T...>>(c.get_stream(get_connection_id(in))));
        }
    };
    template<typename... T> struct helper<source<T...>> {
        static source<T...> doit(connection& c, Input& in) {
            return source<T...>(make_shared<source_impl<Serializer, T...>>(c.get_stream(get_connection_id(in))));
        }
    };
    template <typename... T> struct helper<tuple<T...>> {
        static tuple<T...> doit(connection& c, Input& in) {
            return do_unmarshall<Serializer, Input, T...>(c, in);
        }
    };
};

template <typename Serializer, typename Input, typename... T>
inline std::tuple<T...> do_unmarshall(connection& c, Input& in) {




    std::tuple<std::optional<T>...> temporary;
    return std::apply([&] (auto&... args) {

        (..., (args = unmarshal_one<Serializer, Input>::template helper<typename std::remove_reference_t<decltype(args)>::value_type>::doit(c, in)));
        return std::tuple(std::move(*args)...);
    }, temporary);
}

template <typename Serializer, typename... T>
inline std::tuple<T...> unmarshall(connection& c, rcv_buf input) {
    auto in = make_deserializer_stream(input);
    return do_unmarshall<Serializer, decltype(in), T...>(c, in);
}

inline std::exception_ptr unmarshal_exception(rcv_buf& d) {
    std::exception_ptr ex;
    auto data = make_deserializer_stream(d);

    uint32_t v32;
    data.read(reinterpret_cast<char*>(&v32), 4);
    exception_type ex_type = exception_type(le_to_cpu(v32));
    data.read(reinterpret_cast<char*>(&v32), 4);
    uint32_t ex_len = le_to_cpu(v32);

    switch (ex_type) {
    case exception_type::USER: {
        std::string s(ex_len, '\0');
        data.read(&*s.begin(), ex_len);
        ex = std::make_exception_ptr(remote_verb_error(std::move(s)));
        break;
    }
    case exception_type::UNKNOWN_VERB: {
        uint64_t v64;
        data.read(reinterpret_cast<char*>(&v64), 8);
        ex = std::make_exception_ptr(unknown_verb_error(le_to_cpu(v64)));
        break;
    }
    default:
        ex = std::make_exception_ptr(unknown_exception_error());
        break;
    }
    return ex;
}

template <typename Payload, typename... T>
struct rcv_reply_base {
    bool done = false;
    promise<T...> p;
    template<typename... V>
    void set_value(V&&... v) {
        done = true;
        p.set_value(internal::untuple(std::forward<V>(v))...);
    }
    ~rcv_reply_base() {
        if (!done) {
            p.set_exception(closed_error());
        }
    }
};

template<typename Serializer, typename T>
struct rcv_reply : rcv_reply_base<T, T> {
    inline void get_reply(rpc::client& dst, rcv_buf input) {
        this->set_value(unmarshall<Serializer, T>(dst, std::move(input)));
    }
};

template<typename Serializer, typename... T>
struct rcv_reply<Serializer, future<T...>> : rcv_reply_base<std::tuple<T...>, T...> {
    inline void get_reply(rpc::client& dst, rcv_buf input) {
        this->set_value(unmarshall<Serializer, T...>(dst, std::move(input)));
    }
};

template<typename Serializer>
struct rcv_reply<Serializer, void> : rcv_reply_base<void, void> {
    inline void get_reply(rpc::client&, rcv_buf) {
        this->set_value();
    }
};

template<typename Serializer>
struct rcv_reply<Serializer, future<>> : rcv_reply<Serializer, void> {};

template <typename Serializer, typename Ret, typename... InArgs>
inline auto wait_for_reply(wait_type, std::optional<rpc_clock_type::time_point> timeout, cancellable* cancel, rpc::client& dst, id_type msg_id,
        signature<Ret (InArgs...)>) {
    using reply_type = rcv_reply<Serializer, Ret>;
    auto lambda = [] (reply_type& r, rpc::client& dst, id_type msg_id, rcv_buf data) mutable {
        if (msg_id >= 0) {
            dst.get_stats_internal().replied++;
            return r.get_reply(dst, std::move(data));
        } else {
            dst.get_stats_internal().exception_received++;
            r.done = true;
            r.p.set_exception(unmarshal_exception(data));
        }
    };
    using handler_type = typename rpc::client::template reply_handler<reply_type, decltype(lambda)>;
    auto r = std::make_unique<handler_type>(std::move(lambda));
    auto fut = r->reply.p.get_future();
    dst.wait_for_reply(msg_id, std::move(r), timeout, cancel);
    return fut;
}

template<typename Serializer, typename... InArgs>
inline auto wait_for_reply(no_wait_type, std::optional<rpc_clock_type::time_point>, cancellable*, rpc::client&, id_type,
        signature<no_wait_type (InArgs...)>) {
    return make_ready_future<>();
}

template<typename Serializer, typename... InArgs>
inline auto wait_for_reply(no_wait_type, std::optional<rpc_clock_type::time_point>, cancellable*, rpc::client&, id_type,
        signature<future<no_wait_type> (InArgs...)>) {
    return make_ready_future<>();
}




inline rpc_clock_type::time_point
relative_timeout_to_absolute(rpc_clock_type::duration relative) {
    rpc_clock_type::time_point now = rpc_clock_type::now();
    return now + std::min(relative, rpc_clock_type::time_point::max() - now);
}


static constexpr size_t request_frame_headroom = 28;





template<typename Serializer, typename MsgType, typename Ret, typename... InArgs>
auto send_helper(MsgType xt, signature<Ret (InArgs...)> xsig) {
    struct shelper {
        MsgType t;
        signature<Ret (InArgs...)> sig;
        auto send(rpc::client& dst, std::optional<rpc_clock_type::time_point> timeout, cancellable* cancel, const InArgs&... args) {
            if (dst.error()) {
                using cleaned_ret_type = typename wait_signature<Ret>::cleaned_type;
                return futurize<cleaned_ret_type>::make_exception_future(closed_error());
            }


            auto msg_id = dst.next_message_id();
            snd_buf data = marshall(dst.template serializer<Serializer>(), request_frame_headroom, args...);


            using wait = wait_signature_t<Ret>;
            return when_all(dst.request(uint64_t(t), msg_id, std::move(data), timeout, cancel), wait_for_reply<Serializer>(wait(), timeout, cancel, dst, msg_id, sig)).then([] (auto r) {
                    std::get<0>(r).ignore_ready_future();
                    return std::move(std::get<1>(r));
            });
        }
        auto operator()(rpc::client& dst, const InArgs&... args) {
            return send(dst, {}, nullptr, args...);
        }
        auto operator()(rpc::client& dst, rpc_clock_type::time_point timeout, const InArgs&... args) {
            return send(dst, timeout, nullptr, args...);
        }
        auto operator()(rpc::client& dst, rpc_clock_type::duration timeout, const InArgs&... args) {
            return send(dst, relative_timeout_to_absolute(timeout), nullptr, args...);
        }
        auto operator()(rpc::client& dst, cancellable& cancel, const InArgs&... args) {
            return send(dst, {}, &cancel, args...);
        }

    };
    return shelper{xt, xsig};
}


static constexpr size_t response_frame_headroom = 12;

template<typename Serializer, typename RetTypes>
inline future<> reply(wait_type, future<RetTypes>&& ret, int64_t msg_id, shared_ptr<server::connection> client,
        std::optional<rpc_clock_type::time_point> timeout) {
    if (!client->error()) {
        snd_buf data;
        try {
            if constexpr (std::is_void_v<RetTypes>) {
                ret.get();
                data = std::invoke(marshall<Serializer>, std::ref(client->template serializer<Serializer>()), response_frame_headroom);
            } else {
                data = std::invoke(marshall<Serializer, const RetTypes&>, std::ref(client->template serializer<Serializer>()), response_frame_headroom, std::move(ret.get()));
            }
        } catch (std::exception& ex) {
            uint32_t len = std::strlen(ex.what());
            data = snd_buf(response_frame_headroom + 2 * sizeof(uint32_t) + len);
            auto os = make_serializer_stream(data);
            os.skip(response_frame_headroom);
            uint32_t v32 = cpu_to_le(uint32_t(exception_type::USER));
            os.write(reinterpret_cast<char*>(&v32), sizeof(v32));
            v32 = cpu_to_le(len);
            os.write(reinterpret_cast<char*>(&v32), sizeof(v32));
            os.write(ex.what(), len);
            msg_id = -msg_id;
        }

        return client->respond(msg_id, std::move(data), timeout);
    } else {
        ret.ignore_ready_future();
        return make_ready_future<>();
    }
}


template<typename Serializer>
inline future<> reply(no_wait_type, future<no_wait_type>&& r, int64_t msgid, shared_ptr<server::connection> client, std::optional<rpc_clock_type::time_point>) {
    try {
        r.get();
    } catch (std::exception& ex) {
        client->get_logger()(client->info(), msgid, to_sstring("exception \"") + ex.what() + "\" in no_wait handler ignored");
    }
    return make_ready_future<>();
}

template<typename Ret, typename... InArgs, typename WantClientInfo, typename WantTimePoint, typename Func, typename ArgsTuple>
inline futurize_t<Ret> apply(Func& func, client_info& info, opt_time_point time_point, WantClientInfo wci, WantTimePoint wtp, signature<Ret (InArgs...)>, ArgsTuple&& args) {
    using futurator = futurize<Ret>;
    return futurator::apply(func, maybe_add_client_info(wci, info, maybe_add_time_point(wtp, time_point, std::forward<ArgsTuple>(args))));
}


template<typename T>
auto lref_to_cref(T&& x) {
    return std::move(x);
}

template<typename T>
auto lref_to_cref(T& x) {
    return std::ref(x);
}



template <typename Serializer, typename Func, typename Ret, typename... InArgs, typename WantClientInfo, typename WantTimePoint>
auto recv_helper(signature<Ret (InArgs...)> sig, Func&& func, WantClientInfo, WantTimePoint) {
    using signature = decltype(sig);
    using wait_style = wait_signature_t<Ret>;
    return [func = lref_to_cref(std::forward<Func>(func))](shared_ptr<server::connection> client,
                                                           std::optional<rpc_clock_type::time_point> timeout,
                                                           int64_t msg_id,
                                                           rcv_buf data,
                                                           gate::holder guard) mutable {
        auto memory_consumed = client->estimate_request_size(data.size);
        if (memory_consumed > client->max_request_size()) {
            auto err = format("request size {:d} large than memory limit {:d}", memory_consumed, client->max_request_size());
            client->get_logger()(client->peer_address(), err);

            (void)try_with_gate(client->get_server().reply_gate(), [client, timeout, msg_id, err = std::move(err)] {
                return reply<Serializer>(wait_style(), futurize<Ret>::make_exception_future(std::runtime_error(err.c_str())), msg_id, client, timeout).handle_exception([client, msg_id] (std::exception_ptr eptr) {
                    client->get_logger()(client->info(), msg_id, format("got exception while processing an oversized message: {}", eptr));
                });
            }).handle_exception_type([] (gate_closed_exception&) { });
            return make_ready_future();
        }

        auto f = client->wait_for_resources(memory_consumed, timeout).then([client, timeout, msg_id, data = std::move(data), &func, g = std::move(guard)] (auto permit) mutable {

                (void)try_with_gate(client->get_server().reply_gate(), [client, timeout, msg_id, data = std::move(data), permit = std::move(permit), &func] () mutable {
                    try {
                        auto args = unmarshall<Serializer, InArgs...>(*client, std::move(data));
                        return apply(func, client->info(), timeout, WantClientInfo(), WantTimePoint(), signature(), std::move(args)).then_wrapped([client, timeout, msg_id, permit = std::move(permit)] (futurize_t<Ret> ret) mutable {
                            return reply<Serializer>(wait_style(), std::move(ret), msg_id, client, timeout).handle_exception([permit = std::move(permit), client, msg_id] (std::exception_ptr eptr) {
                                client->get_logger()(client->info(), msg_id, format("got exception while processing a message: {}", eptr));
                            });
                        });
                    } catch (...) {
                        client->get_logger()(client->info(), msg_id, format("caught exception while processing a message: {}", std::current_exception()));
                        return make_ready_future();
                    }
                }).handle_exception_type([g = std::move(g)] (gate_closed_exception&) { });
        });

        if (timeout) {
            f = f.handle_exception_type([] (semaphore_timed_out&) { });
        }

        return f;
    };
}


template<typename Func>
auto make_copyable_function(Func&& func, std::enable_if_t<!std::is_copy_constructible_v<std::decay_t<Func>>, void*> = nullptr) {
  auto p = make_lw_shared<typename std::decay_t<Func>>(std::forward<Func>(func));
  return [p] (auto&&... args) { return (*p)( std::forward<decltype(args)>(args)... ); };
}

template<typename Func>
auto make_copyable_function(Func&& func, std::enable_if_t<std::is_copy_constructible_v<std::decay_t<Func>>, void*> = nullptr) {
    return std::forward<Func>(func);
}
# 635 "/home/avi/scylla-maint/seastar/include/seastar/rpc/rpc_impl.hh"
template<typename Ret, typename... In>
class client_function_type {
    template<typename T, bool IsSmartPtr>
    struct drop_smart_ptr_impl;
    template<typename T>
    struct drop_smart_ptr_impl<T, true> {
        using type = typename T::element_type;
    };
    template<typename T>
    struct drop_smart_ptr_impl<T, false> {
        using type = T;
    };
    template<typename T>
    using drop_smart_ptr = drop_smart_ptr_impl<T, is_smart_ptr<T>::value>;


    using return_type = typename drop_smart_ptr<Ret>::type;
public:
    using type = return_type(typename remove_optional<In>::type...);
};

template<typename Serializer, typename MsgType>
template<typename Ret, typename... In>
auto protocol<Serializer, MsgType>::make_client(signature<Ret(In...)>, MsgType t) {
    using sig_type = signature<typename client_function_type<Ret, In...>::type>;
    return send_helper<Serializer>(t, sig_type());
}

template<typename Serializer, typename MsgType>
template<typename Func>
auto protocol<Serializer, MsgType>::make_client(MsgType t) {
    return make_client(typename signature<typename function_traits<Func>::signature>::clean(), t);
}

template<typename Serializer, typename MsgType>
template<typename Func>
auto protocol<Serializer, MsgType>::register_handler(MsgType t, scheduling_group sg, Func&& func) {
    using sig_type = signature<typename function_traits<Func>::signature>;
    using clean_sig_type = typename sig_type::clean;
    using want_client_info = typename sig_type::want_client_info;
    using want_time_point = typename sig_type::want_time_point;
    auto recv = recv_helper<Serializer>(clean_sig_type(), std::forward<Func>(func),
            want_client_info(), want_time_point());
    register_receiver(t, rpc_handler{sg, make_copyable_function(std::move(recv)), {}});
    return make_client(clean_sig_type(), t);
}

template<typename Serializer, typename MsgType>
template<typename Func>
auto protocol<Serializer, MsgType>::register_handler(MsgType t, Func&& func) {
    return register_handler(t, scheduling_group(), std::forward<Func>(func));
}

template<typename Serializer, typename MsgType>
future<> protocol<Serializer, MsgType>::unregister_handler(MsgType t) {
    auto it = _handlers.find(t);
    if (it != _handlers.end()) {
        return it->second.use_gate.close().finally([this, t] {
            _handlers.erase(t);
        });
    }
    return make_ready_future<>();
}

template<typename Serializer, typename MsgType>
bool protocol<Serializer, MsgType>::has_handler(MsgType msg_id) {
    auto it = _handlers.find(msg_id);
    if (it == _handlers.end()) {
        return false;
    }
    return !it->second.use_gate.is_closed();
}

template<typename Serializer, typename MsgType>
std::optional<protocol_base::handler_with_holder> protocol<Serializer, MsgType>::get_handler(uint64_t msg_id) {
    const auto it = _handlers.find(MsgType(msg_id));
    if (it != _handlers.end()) {
        try {
            return handler_with_holder{it->second, it->second.use_gate.hold()};
        } catch (gate_closed_exception&) {

        }
    }
    return std::nullopt;
}

template<typename T> T make_shard_local_buffer_copy(foreign_ptr<std::unique_ptr<T>> org);

template<typename Serializer, typename... Out>
future<> sink_impl<Serializer, Out...>::operator()(const Out&... args) {


    snd_buf data = marshall(this->_con->get()->template serializer<Serializer>(), 4, args...);
    static_assert(snd_buf::chunk_size >= 4, "send buffer chunk size is too small");
    auto p = data.front().get_write();
    write_le<uint32_t>(p, data.size - 4);


    auto size = std::min(size_t(data.size), max_stream_buffers_memory);
    const auto seq_num = _next_seq_num++;
    return get_units(this->_sem, size).then([this, data = make_foreign(std::make_unique<snd_buf>(std::move(data))), seq_num] (semaphore_units<> su) mutable {
        if (this->_ex) {
            return make_exception_future(this->_ex);
        }


        (void)smp::submit_to(this->_con->get_owner_shard(), [this, data = std::move(data), seq_num] () mutable {
            connection* con = this->_con->get();
            if (con->error()) {
                return make_exception_future(closed_error());
            }
            if(con->sink_closed()) {
                return make_exception_future(stream_closed());
            }

            auto& last_seq_num = _remote_state.last_seq_num;
            auto& out_of_order_bufs = _remote_state.out_of_order_bufs;

            auto local_data = make_shard_local_buffer_copy(std::move(data));
            const auto seq_num_diff = seq_num - last_seq_num;
            if (seq_num_diff > 1) {
                auto [it, _] = out_of_order_bufs.emplace(seq_num, deferred_snd_buf{promise<>{}, std::move(local_data)});
                return it->second.pr.get_future();
            }

            last_seq_num = seq_num;
            auto ret_fut = con->send(std::move(local_data), {}, nullptr);
            while (!out_of_order_bufs.empty() && out_of_order_bufs.begin()->first == (last_seq_num + 1)) {
                auto it = out_of_order_bufs.begin();
                last_seq_num = it->first;
                auto fut = con->send(std::move(it->second.data), {}, nullptr);
                fut.forward_to(std::move(it->second.pr));
                out_of_order_bufs.erase(it);
            }
            return ret_fut;
        }).then_wrapped([su = std::move(su), this] (future<> f) {
            if (f.failed() && !this->_ex) {
                this->_ex = f.get_exception();
            } else {
                f.ignore_ready_future();
            }
        });
        return make_ready_future<>();
    });
}

template<typename Serializer, typename... Out>
future<> sink_impl<Serializer, Out...>::flush() {

    return with_semaphore(this->_sem, max_stream_buffers_memory, [this] {
        if (this->_ex) {
            return make_exception_future(this->_ex);
        }
        return make_ready_future();
    });
}

template<typename Serializer, typename... Out>
future<> sink_impl<Serializer, Out...>::close() {
    return with_semaphore(this->_sem, max_stream_buffers_memory, [this] {
        return smp::submit_to(this->_con->get_owner_shard(), [this] {
            connection* con = this->_con->get();
            if (con->sink_closed()) {
                return make_exception_future(stream_closed());
            }
            future<> f = make_ready_future<>();
            if (!con->error() && !this->_ex) {
                snd_buf data = marshall(con->template serializer<Serializer>(), 4);
                static_assert(snd_buf::chunk_size >= 4, "send buffer chunk size is too small");
                auto p = data.front().get_write();
                write_le<uint32_t>(p, -1U);
                f = con->send(std::move(data), {}, nullptr);
            } else {
                f = this->_ex ? make_exception_future(this->_ex) : make_exception_future(closed_error());
            }
            return f.finally([con] { return con->close_sink(); });
        });
    });
}

template<typename Serializer, typename... Out>
sink_impl<Serializer, Out...>::~sink_impl() {


    (static_cast <bool> (this->_con->get()->sink_closed()) ? void (0) : __assert_fail ("this->_con->get()->sink_closed()", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
}

template<typename Serializer, typename... In>
future<std::optional<std::tuple<In...>>> source_impl<Serializer, In...>::operator()() {
    auto process_one_buffer = [this] {
        foreign_ptr<std::unique_ptr<rcv_buf>> buf = std::move(this->_bufs.front());
        this->_bufs.pop_front();
        return std::apply([] (In&&... args) {
            auto ret = std::make_optional(std::make_tuple(std::move(args)...));
            return make_ready_future<std::optional<std::tuple<In...>>>(std::move(ret));
        }, unmarshall<Serializer, In...>(*this->_con->get(), make_shard_local_buffer_copy(std::move(buf))));
    };

    if (!this->_bufs.empty()) {
        return process_one_buffer();
    }


    return smp::submit_to(this->_con->get_owner_shard(), [this] () -> future<> {
        connection* con = this->_con->get();
        if (con->_source_closed) {
            return make_exception_future<>(stream_closed());
        }
        return con->stream_receive(this->_bufs).then_wrapped([this, con] (future<>&& f) {
            if (f.failed()) {
                return con->close_source().then_wrapped([ex = f.get_exception()] (future<> f){
                    f.ignore_ready_future();
                    return make_exception_future<>(ex);
                });
            }
            if (this->_bufs.empty()) {
                return con->close_source().then_wrapped([] (future<> f) {
                    f.ignore_ready_future();
                    return make_ready_future<>();
                });
            }
            return make_ready_future<>();
        });
    }).then([this, process_one_buffer] () {
        if (this->_bufs.empty()) {
            return make_ready_future<std::optional<std::tuple<In...>>>(std::nullopt);
        } else {
            return process_one_buffer();
        }
    });
}

template<typename... Out>
connection_id sink<Out...>::get_id() const {
    return _impl->_con->get()->get_connection_id();
}

template<typename... In>
connection_id source<In...>::get_id() const {
    return _impl->_con->get()->get_connection_id();
}

template<typename... In>
template<typename Serializer, typename... Out>
sink<Out...> source<In...>::make_sink() {
    return sink<Out...>(make_shared<sink_impl<Serializer, Out...>>(_impl->_con));
}

}

}

namespace std {
template<>
struct hash<seastar::rpc::streaming_domain_type> {
    size_t operator()(const seastar::rpc::streaming_domain_type& domain) const {
        size_t h = 0;
        boost::hash_combine(h, std::hash<uint64_t>{}(domain._id));
        return h;
    }
};
}
# 966 "/home/avi/scylla-maint/seastar/include/seastar/rpc/rpc.hh" 2
# 2 "/home/avi/scylla-maint/seastar/src/rpc/rpc.cc" 2
# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/align.hh" 1
# 27 "/home/avi/scylla-maint/seastar/include/seastar/core/align.hh"
# 1 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdlib" 1 3
# 40 "/usr/bin/../lib/gcc/x86_64-redhat-linux/14/../../../../include/c++/14/cstdlib" 3
# 28 "/home/avi/scylla-maint/seastar/include/seastar/core/align.hh" 2


namespace seastar {



template <typename T>
inline constexpr
T align_up(T v, T align) {
    return (v + align - 1) & ~(align - 1);
}

template <typename T>
inline constexpr
T* align_up(T* v, size_t align) {
    static_assert(sizeof(T) == 1, "align byte pointers only");
    return reinterpret_cast<T*>(align_up(reinterpret_cast<uintptr_t>(v), align));
}

template <typename T>
inline constexpr
T align_down(T v, T align) {
    return v & ~(align - 1);
}

template <typename T>
inline constexpr
T* align_down(T* v, size_t align) {
    static_assert(sizeof(T) == 1, "align byte pointers only");
    return reinterpret_cast<T*>(align_down(reinterpret_cast<uintptr_t>(v), align));
}



}
# 3 "/home/avi/scylla-maint/seastar/src/rpc/rpc.cc" 2


# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/future-util.hh" 1
# 26 "/home/avi/scylla-maint/seastar/include/seastar/core/future-util.hh"
# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/with_scheduling_group.hh" 1
# 27 "/home/avi/scylla-maint/seastar/include/seastar/core/with_scheduling_group.hh"
# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/make_task.hh" 1
# 30 "/home/avi/scylla-maint/seastar/include/seastar/core/make_task.hh"
namespace seastar {



template <typename Func>
class lambda_task final : public task {
    Func _func;
    using futurator = futurize<std::invoke_result_t<Func>>;
    typename futurator::promise_type _result;
public:
    lambda_task(scheduling_group sg, const Func& func) : task(sg), _func(func) {}
    lambda_task(scheduling_group sg, Func&& func) : task(sg), _func(std::move(func)) {}
    typename futurator::type get_future() noexcept { return _result.get_future(); }
    virtual void run_and_dispose() noexcept override {
        futurator::invoke(_func).forward_to(std::move(_result));
        delete this;
    }
    virtual task* waiting_task() noexcept override {
        return _result.waiting_task();
    }
};

template <typename Func>
inline
lambda_task<Func>*
make_task(Func&& func) noexcept {
    return new lambda_task<Func>(current_scheduling_group(), std::forward<Func>(func));
}

template <typename Func>
inline
lambda_task<Func>*
make_task(scheduling_group sg, Func&& func) noexcept {
    return new lambda_task<Func>(sg, std::forward<Func>(func));
}



}
# 28 "/home/avi/scylla-maint/seastar/include/seastar/core/with_scheduling_group.hh" 2





namespace seastar {




namespace internal {

template <typename Func>
requires std::is_nothrow_move_constructible_v<Func>
auto
schedule_in_group(scheduling_group sg, Func func) noexcept {
    static_assert(std::is_nothrow_move_constructible_v<Func>);
    auto tsk = make_task(sg, std::move(func));
    schedule_checked(tsk);
    return tsk->get_future();
}


}
# 64 "/home/avi/scylla-maint/seastar/include/seastar/core/with_scheduling_group.hh"
template <typename Func, typename... Args>
requires std::is_nothrow_move_constructible_v<Func>
inline
auto
with_scheduling_group(scheduling_group sg, Func func, Args&&... args) noexcept {
    static_assert(std::is_nothrow_move_constructible_v<Func>);
    using return_type = decltype(func(std::forward<Args>(args)...));
    using futurator = futurize<return_type>;
    if (sg.active()) {
        return futurator::invoke(func, std::forward<Args>(args)...);
    } else {
        return internal::schedule_in_group(sg, [func = std::move(func), args = std::make_tuple(std::forward<Args>(args)...)] () mutable {
            return futurator::apply(func, std::move(args));
        });
    }
}



}
# 27 "/home/avi/scylla-maint/seastar/include/seastar/core/future-util.hh" 2



# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/with_timeout.hh" 1
# 35 "/home/avi/scylla-maint/seastar/include/seastar/core/with_timeout.hh"
namespace seastar {
# 53 "/home/avi/scylla-maint/seastar/include/seastar/core/with_timeout.hh"
template<typename ExceptionFactory = default_timeout_exception_factory, typename Clock, typename Duration, typename... T>
future<T...> with_timeout(std::chrono::time_point<Clock, Duration> timeout, future<T...> f) {
    if (f.available()) {
        return f;
    }
    auto pr = std::make_unique<promise<T...>>();
    auto result = pr->get_future();
    timer<Clock> timer([&pr = *pr] {
        pr.set_exception(std::make_exception_ptr(ExceptionFactory::timeout()));
    });
    timer.arm(timeout);

    (void)f.then_wrapped([pr = std::move(pr), timer = std::move(timer)] (auto&& f) mutable {
        if (timer.cancel()) {
            f.forward_to(std::move(*pr));
        } else {
            f.ignore_ready_future();
        }
    });
    return result;
}



}
# 31 "/home/avi/scylla-maint/seastar/include/seastar/core/future-util.hh" 2
# 1 "/home/avi/scylla-maint/seastar/include/seastar/util/later.hh" 1
# 28 "/home/avi/scylla-maint/seastar/include/seastar/util/later.hh"
namespace seastar {





inline
future<> now() {
    return make_ready_future<>();
}







future<> yield() noexcept;
# 56 "/home/avi/scylla-maint/seastar/include/seastar/util/later.hh"
inline
future<> maybe_yield() noexcept {
    if (need_preempt()) {
        return yield();
    } else {
        return make_ready_future<>();
    }
}
# 74 "/home/avi/scylla-maint/seastar/include/seastar/util/later.hh"
future<> check_for_io_immediately() noexcept;




[[deprecated("Use yield() or check_for_io_immediately()")]]
future<> later() noexcept;



}
# 32 "/home/avi/scylla-maint/seastar/include/seastar/core/future-util.hh" 2
# 6 "/home/avi/scylla-maint/seastar/src/rpc/rpc.cc" 2
# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/metrics.hh" 1
# 35 "/home/avi/scylla-maint/seastar/include/seastar/core/metrics.hh"
# 1 "/home/avi/scylla-maint/seastar/include/seastar/core/metrics_types.hh" 1
# 31 "/home/avi/scylla-maint/seastar/include/seastar/core/metrics_types.hh"
namespace seastar {
namespace metrics {
# 42 "/home/avi/scylla-maint/seastar/include/seastar/core/metrics_types.hh"
struct histogram_bucket {
    uint64_t count = 0;
    double upper_bound = 0;
};





struct native_histogram_info {





    int32_t schema;

    int32_t min_id;
};
# 69 "/home/avi/scylla-maint/seastar/include/seastar/core/metrics_types.hh"
struct histogram {
    uint64_t sample_count = 0;
    double sample_sum = 0;
    std::vector<histogram_bucket> buckets;







    histogram& operator+=(const histogram& h);
# 89 "/home/avi/scylla-maint/seastar/include/seastar/core/metrics_types.hh"
    histogram operator+(const histogram& h) const;
# 98 "/home/avi/scylla-maint/seastar/include/seastar/core/metrics_types.hh"
    histogram operator+(histogram&& h) const;


    std::optional<native_histogram_info> native_histogram;
};



}

}
# 36 "/home/avi/scylla-maint/seastar/include/seastar/core/metrics.hh" 2
# 51 "/home/avi/scylla-maint/seastar/include/seastar/core/metrics.hh"
namespace seastar {
# 98 "/home/avi/scylla-maint/seastar/include/seastar/core/metrics.hh"
namespace metrics {



class double_registration : public std::runtime_error {
public:
    double_registration(std::string what);
};







using metric_type_def = sstring;
using metric_name_type = sstring;
using instance_id_type = sstring;
using skip_when_empty = bool_class<class skip_when_empty_tag>;
# 133 "/home/avi/scylla-maint/seastar/include/seastar/core/metrics.hh"
class description {
public:
    description(sstring s = sstring()) : _s(std::move(s))
    {}
    const sstring& str() const {
        return _s;
    }
private:
    sstring _s;
};
# 161 "/home/avi/scylla-maint/seastar/include/seastar/core/metrics.hh"
class label_instance {
    sstring _key;
    sstring _value;
public:
# 177 "/home/avi/scylla-maint/seastar/include/seastar/core/metrics.hh"
    template<typename T>
    label_instance(const sstring& key, T v) : _key(key), _value(fmt::to_string(v)){}




    const sstring key() const {
        return _key;
    }




    const sstring value() const {
        return _value;
    }
    bool operator<(const label_instance&) const;
    bool operator==(const label_instance&) const;
    bool operator!=(const label_instance&) const;
};
# 216 "/home/avi/scylla-maint/seastar/include/seastar/core/metrics.hh"
class label {
    sstring key;
public:
    using instance = label_instance;





    explicit label(const sstring& key) : key(key) {
    }
# 240 "/home/avi/scylla-maint/seastar/include/seastar/core/metrics.hh"
    template<typename T>
    instance operator()(T value) const {
        return label_instance(key, std::forward<T>(value));
    }




    const sstring& name() const {
        return key;
    }
};
# 261 "/home/avi/scylla-maint/seastar/include/seastar/core/metrics.hh"
namespace impl {


enum class data_type : uint8_t {
    COUNTER,
    REAL_COUNTER,
    GAUGE,
    HISTOGRAM,
    SUMMARY,
};

template <bool callable, typename T>
struct real_counter_type_traits {
    using type = T;
};

template <typename T>
struct real_counter_type_traits<true, T> {
    using type = std::invoke_result_t<T>;
};

template <typename T>
struct counter_type_traits {
    using real_traits = real_counter_type_traits<std::is_invocable_v<T>, T>;
    static constexpr bool is_integral = std::is_integral_v<typename real_traits::type>;
    static constexpr data_type type = is_integral ? data_type::COUNTER : data_type::REAL_COUNTER;
};






class metric_value {
public:
    std::variant<double, histogram> u;
    data_type _type;
    data_type type() const {
        return _type;
    }

    double d() const {
        return std::get<double>(u);
    }

    uint64_t ui() const {
        auto d = std::get<double>(u);
        if (d >= 0 && d <= double(std::numeric_limits<long>::max())) {
            return lround(d);
        } else {

            ulong_conversion_error(d);
            return 0;
        }
    }

    int64_t i() const {
        auto d = std::get<double>(u);
        if (d >= double(std::numeric_limits<long>::min()) && d <= double(std::numeric_limits<long>::max())) {
            return lround(d);
        } else {

            ulong_conversion_error(d);
            return 0;
        }
    }

    metric_value()
            : _type(data_type::GAUGE) {
    }

    metric_value(histogram&& h, data_type t = data_type::HISTOGRAM) :
        u(std::move(h)), _type(t) {
    }
    metric_value(const histogram& h, data_type t = data_type::HISTOGRAM) :
        u(h), _type(t) {
    }

    metric_value(double d, data_type t)
            : u(d), _type(t) {
    }

    metric_value& operator+=(const metric_value& c) {
        *this = *this + c;
        return *this;
    }

    metric_value operator+(const metric_value& c);
    const histogram& get_histogram() const {
        return std::get<histogram>(u);
    }







    bool is_empty() const noexcept {
        return ((_type == data_type::HISTOGRAM || _type == data_type::SUMMARY) && get_histogram().sample_count == 0) ||
                ((_type == data_type::COUNTER || _type == data_type::REAL_COUNTER) && d() == 0);
    }
private:
    static void ulong_conversion_error(double d);
};

using metric_function = std::function<metric_value()>;

struct metric_type {
    data_type base_type;
    metric_type_def type_name;
};

struct metric_definition_impl {
    metric_name_type name;
    metric_type type;
    metric_function f;
    description d;
    bool enabled = true;
    skip_when_empty _skip_when_empty = skip_when_empty::no;
    std::vector<std::string> aggregate_labels;
    std::map<sstring, sstring> labels;
    metric_definition_impl& operator ()(bool enabled);
    metric_definition_impl& operator ()(const label_instance& label);
    metric_definition_impl& operator ()(skip_when_empty skip) noexcept;
    metric_definition_impl& aggregate(const std::vector<label>& labels) noexcept;
    metric_definition_impl& set_skip_when_empty(bool skip=true) noexcept;
    metric_definition_impl& set_type(const sstring& type_name);
    metric_definition_impl(
        metric_name_type name,
        metric_type type,
        metric_function f,
        description d,
        std::vector<label_instance> labels,
        std::vector<label> aggregate_labels = {});
};

class metric_groups_def {
public:
    metric_groups_def() = default;
    virtual ~metric_groups_def() = default;
    metric_groups_def(const metric_groups_def&) = delete;
    metric_groups_def(metric_groups_def&&) = default;
    virtual metric_groups_def& add_metric(group_name_type name, const metric_definition& md) = 0;
    virtual metric_groups_def& add_group(group_name_type name, const std::initializer_list<metric_definition>& l) = 0;
    virtual metric_groups_def& add_group(group_name_type name, const std::vector<metric_definition>& l) = 0;
};

instance_id_type shard();

template<typename T, typename = std::enable_if_t<std::is_invocable_v<T>>>
metric_function make_function(T val, data_type dt) {
    return [dt, val = std::move(val)] {
        return metric_value(val(), dt);
    };
}

template<typename T, typename = std::enable_if_t<!std::is_invocable_v<T>>>
metric_function make_function(T& val, data_type dt) {
    return [dt, &val] {
        return metric_value(val, dt);
    };
}
}

extern const bool metric_disabled;

extern label shard_label;
# 441 "/home/avi/scylla-maint/seastar/include/seastar/core/metrics.hh"
template<typename T>
impl::metric_definition_impl make_gauge(metric_name_type name,
        T&& val, description d = description(), std::vector<label_instance> labels = {}) {
    return {name, {impl::data_type::GAUGE, "gauge"}, make_function(std::forward<T>(val), impl::data_type::GAUGE), d, labels};
}






template<typename T>
impl::metric_definition_impl make_gauge(metric_name_type name,
        description d, T&& val) {
    return {name, {impl::data_type::GAUGE, "gauge"}, make_function(std::forward<T>(val), impl::data_type::GAUGE), d, {}};
}






template<typename T>
impl::metric_definition_impl make_gauge(metric_name_type name,
        description d, std::vector<label_instance> labels, T&& val) {
    return {name, {impl::data_type::GAUGE, "gauge"}, make_function(std::forward<T>(val), impl::data_type::GAUGE), d, labels};
}
# 478 "/home/avi/scylla-maint/seastar/include/seastar/core/metrics.hh"
template<typename T>
[[deprecated("Use make_counter()")]]
impl::metric_definition_impl make_derive(metric_name_type name,
        T&& val, description d = description(), std::vector<label_instance> labels = {}) {
    return make_counter(std::move(name), std::forward<T>(val), std::move(d), std::move(labels));
}
# 494 "/home/avi/scylla-maint/seastar/include/seastar/core/metrics.hh"
template<typename T>
[[deprecated("Use make_counter()")]]
impl::metric_definition_impl make_derive(metric_name_type name, description d,
        T&& val) {
    return make_counter(std::move(name), std::forward<T>(val), std::move(d), {});
}
# 510 "/home/avi/scylla-maint/seastar/include/seastar/core/metrics.hh"
template<typename T>
[[deprecated("Use make_counter()")]]
impl::metric_definition_impl make_derive(metric_name_type name, description d, std::vector<label_instance> labels,
        T&& val) {
    return make_counter(std::move(name), std::forward<T>(val), std::move(d), std::move(labels));
}
# 527 "/home/avi/scylla-maint/seastar/include/seastar/core/metrics.hh"
template<typename T>
impl::metric_definition_impl make_counter(metric_name_type name,
        T&& val, description d = description(), std::vector<label_instance> labels = {}) {
    auto type = impl::counter_type_traits<std::remove_reference_t<T>>::type;
    return {name, {type, "counter"}, make_function(std::forward<T>(val), type), d, labels};
}
# 543 "/home/avi/scylla-maint/seastar/include/seastar/core/metrics.hh"
template<typename T>
impl::metric_definition_impl make_counter(metric_name_type name, description d, T&& val) {
    return make_counter(std::move(name), std::forward<T>(val), std::move(d), {});
}
# 557 "/home/avi/scylla-maint/seastar/include/seastar/core/metrics.hh"
template<typename T>
impl::metric_definition_impl make_counter(metric_name_type name, description d, std::vector<label_instance> labels, T&& val) {
    return make_counter(std::move(name), std::forward<T>(val), std::move(d), std::move(labels));
}







template<typename T>
[[deprecated("Use make_counter()")]]
impl::metric_definition_impl make_absolute(metric_name_type name,
        T&& val, description d = description(), std::vector<label_instance> labels = {}) {
    return make_counter(std::move(name), std::forward<T>(val), std::move(d), std::move(labels));
}







template<typename T>
impl::metric_definition_impl make_histogram(metric_name_type name,
        T&& val, description d = description(), std::vector<label_instance> labels = {}) {
    return {name, {impl::data_type::HISTOGRAM, "histogram"}, make_function(std::forward<T>(val), impl::data_type::HISTOGRAM), d, labels};
}







template<typename T>
impl::metric_definition_impl make_histogram(metric_name_type name,
        description d, std::vector<label_instance> labels, T&& val) {
    return {name, {impl::data_type::HISTOGRAM, "histogram"}, make_function(std::forward<T>(val), impl::data_type::HISTOGRAM), d, labels};
}
# 606 "/home/avi/scylla-maint/seastar/include/seastar/core/metrics.hh"
template<typename T>
impl::metric_definition_impl make_histogram(metric_name_type name,
        description d, T&& val) {
    return {name, {impl::data_type::HISTOGRAM, "histogram"}, make_function(std::forward<T>(val), impl::data_type::HISTOGRAM), d, {}};
}







template<typename T>
impl::metric_definition_impl make_summary(metric_name_type name,
        description d, T&& val) {
    return {name, {impl::data_type::SUMMARY, "summary"}, make_function(std::forward<T>(val), impl::data_type::SUMMARY), d, {}};
}
# 632 "/home/avi/scylla-maint/seastar/include/seastar/core/metrics.hh"
template<typename T>
impl::metric_definition_impl make_total_bytes(metric_name_type name,
        T&& val, description d = description(), std::vector<label_instance> labels = {},
        instance_id_type = impl::shard()) {
    return make_counter(name, std::forward<T>(val), d, labels).set_type("total_bytes");
}
# 646 "/home/avi/scylla-maint/seastar/include/seastar/core/metrics.hh"
template<typename T>
impl::metric_definition_impl make_current_bytes(metric_name_type name,
        T&& val, description d = description(), std::vector<label_instance> labels = {},
        instance_id_type = impl::shard()) {
    return make_gauge(name, std::forward<T>(val), d, labels).set_type("bytes");
}
# 660 "/home/avi/scylla-maint/seastar/include/seastar/core/metrics.hh"
template<typename T>
impl::metric_definition_impl make_queue_length(metric_name_type name,
        T&& val, description d = description(), std::vector<label_instance> labels = {},
        instance_id_type = impl::shard()) {
    return make_gauge(name, std::forward<T>(val), d, labels).set_type("queue_length");
}
# 674 "/home/avi/scylla-maint/seastar/include/seastar/core/metrics.hh"
template<typename T>
impl::metric_definition_impl make_total_operations(metric_name_type name,
        T&& val, description d = description(), std::vector<label_instance> labels = {},
        instance_id_type = impl::shard()) {
    return make_counter(name, std::forward<T>(val), d, labels).set_type("total_operations");
}


}
}
# 7 "/home/avi/scylla-maint/seastar/src/rpc/rpc.cc" 2
# 1 "/usr/include/boost/range/adaptor/map.hpp" 1 3 4
# 17 "/usr/include/boost/range/adaptor/map.hpp" 3 4
# 1 "/usr/include/boost/range/reference.hpp" 1 3 4
# 22 "/usr/include/boost/range/reference.hpp" 3 4
namespace boost
{
    template< class T >
    struct range_reference : iterator_reference< typename range_iterator<T>::type >
    { };
}
# 18 "/usr/include/boost/range/adaptor/map.hpp" 2 3 4


namespace boost
{
    namespace range_detail
    {
        struct map_keys_forwarder {};
        struct map_values_forwarder {};

        template< class Map >
        struct select_first
        {
            typedef typename range_reference<const Map>::type argument_type;
            typedef const typename range_value<const Map>::type::first_type& result_type;

            result_type operator()( argument_type r ) const
            {
                return r.first;
            }
        };

        template< class Map >
        struct select_second_mutable
        {
            typedef typename range_reference<Map>::type argument_type;
            typedef typename range_value<Map>::type::second_type& result_type;

            result_type operator()( argument_type r ) const
            {
                return r.second;
            }
        };

        template< class Map >
        struct select_second_const
        {
            typedef typename range_reference<const Map>::type argument_type;
            typedef const typename range_value<const Map>::type::second_type& result_type;

            result_type operator()( argument_type r ) const
            {
                return r.second;
            }
        };

        template<class StdPairRng>
        class select_first_range
            : public transformed_range<
                        select_first<StdPairRng>,
                        const StdPairRng>
        {
            typedef transformed_range<select_first<StdPairRng>, const StdPairRng> base;
        public:
            typedef select_first<StdPairRng> transform_fn_type;
            typedef const StdPairRng source_range_type;

            select_first_range(transform_fn_type fn, source_range_type& rng)
                : base(fn, rng)
            {
            }

            select_first_range(const base& other) : base(other) {}
        };

        template<class StdPairRng>
        class select_second_mutable_range
            : public transformed_range<
                        select_second_mutable<StdPairRng>,
                        StdPairRng>
        {
            typedef transformed_range<select_second_mutable<StdPairRng>, StdPairRng> base;
        public:
            typedef select_second_mutable<StdPairRng> transform_fn_type;
            typedef StdPairRng source_range_type;

            select_second_mutable_range(transform_fn_type fn, source_range_type& rng)
                : base(fn, rng)
            {
            }

            select_second_mutable_range(const base& other) : base(other) {}
        };

        template<class StdPairRng>
        class select_second_const_range
            : public transformed_range<
                        select_second_const<StdPairRng>,
                        const StdPairRng>
        {
            typedef transformed_range<select_second_const<StdPairRng>, const StdPairRng> base;
        public:
            typedef select_second_const<StdPairRng> transform_fn_type;
            typedef const StdPairRng source_range_type;

            select_second_const_range(transform_fn_type fn, source_range_type& rng)
                : base(fn, rng)
            {
            }

            select_second_const_range(const base& other) : base(other) {}
        };

        template< class StdPairRng >
        inline select_first_range<StdPairRng>
        operator|( const StdPairRng& r, map_keys_forwarder )
        {
            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( SinglePassRangeConcept<const StdPairRng>)>::failed> boost_concept_check125 __attribute__((__unused__));


            return operator|( r,
                boost::adaptors::transformed( select_first<StdPairRng>() ) );
        }

        template< class StdPairRng >
        inline select_second_mutable_range<StdPairRng>
        operator|( StdPairRng& r, map_values_forwarder )
        {
            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(SinglePassRangeConcept<StdPairRng>)>::failed> boost_concept_check135 __attribute__((__unused__));

            return operator|( r,
                boost::adaptors::transformed( select_second_mutable<StdPairRng>() ) );
        }

        template< class StdPairRng >
        inline select_second_const_range<StdPairRng>
        operator|( const StdPairRng& r, map_values_forwarder )
        {
            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( SinglePassRangeConcept<const StdPairRng>)>::failed> boost_concept_check146 __attribute__((__unused__));


            return operator|( r,
                boost::adaptors::transformed( select_second_const<StdPairRng>() ) );
        }

    }

    using range_detail::select_first_range;
    using range_detail::select_second_mutable_range;
    using range_detail::select_second_const_range;

    namespace adaptors
    {
        namespace
        {
            const range_detail::map_keys_forwarder map_keys =
                                            range_detail::map_keys_forwarder();

            const range_detail::map_values_forwarder map_values =
                                           range_detail::map_values_forwarder();
        }

        template<class StdPairRange>
        inline select_first_range<StdPairRange>
        keys(const StdPairRange& rng)
        {
            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( SinglePassRangeConcept<const StdPairRange>)>::failed> boost_concept_check174 __attribute__((__unused__));


            return select_first_range<StdPairRange>(
                range_detail::select_first<StdPairRange>(), rng );
        }

        template<class StdPairRange>
        inline select_second_const_range<StdPairRange>
        values(const StdPairRange& rng)
        {
            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)( SinglePassRangeConcept<const StdPairRange>)>::failed> boost_concept_check185 __attribute__((__unused__));


            return select_second_const_range<StdPairRange>(
                range_detail::select_second_const<StdPairRange>(), rng );
        }

        template<class StdPairRange>
        inline select_second_mutable_range<StdPairRange>
        values(StdPairRange& rng)
        {
            typedef ::boost::concepts::detail::instantiate< &::boost::concepts::requirement_<void(*)(SinglePassRangeConcept<StdPairRange>)>::failed> boost_concept_check195 __attribute__((__unused__));

            return select_second_mutable_range<StdPairRange>(
                range_detail::select_second_mutable<StdPairRange>(), rng );
        }
    }

}
# 8 "/home/avi/scylla-maint/seastar/src/rpc/rpc.cc" 2


template <> struct fmt::formatter<seastar::rpc::streaming_domain_type> : fmt::ostream_formatter {};


namespace seastar {

namespace rpc {

    void logger::operator()(const client_info& info, id_type msg_id, const sstring& str) const {
        log(format("client {} msg_id {}:  {}", info.addr, msg_id, str));
    }

    void logger::operator()(const client_info& info, id_type msg_id, log_level level, std::string_view str) const {
        log(level, "client {} msg_id {}:  {}", info.addr, msg_id, str);
    }

    void logger::operator()(const client_info& info, const sstring& str) const {
        (*this)(info.addr, str);
    }

    void logger::operator()(const client_info& info, log_level level, std::string_view str) const {
        (*this)(info.addr, level, str);
    }

    void logger::operator()(const socket_address& addr, const sstring& str) const {
        log(format("client {}: {}", addr, str));
    }

    void logger::operator()(const socket_address& addr, log_level level, std::string_view str) const {
        log(level, "client {}: {}", addr, str);
    }

  no_wait_type no_wait;

  snd_buf::snd_buf(size_t size_) : size(size_) {
      if (size <= chunk_size) {
          bufs = temporary_buffer<char>(size);
      } else {
          std::vector<temporary_buffer<char>> v;
          v.reserve(align_up(size_t(size), chunk_size) / chunk_size);
          while (size_) {
              v.push_back(temporary_buffer<char>(std::min(chunk_size, size_)));
              size_ -= v.back().size();
          }
          bufs = std::move(v);
      }
  }

  snd_buf::snd_buf(snd_buf&&) noexcept = default;
  snd_buf& snd_buf::operator=(snd_buf&&) noexcept = default;

  temporary_buffer<char>& snd_buf::front() {
      auto* one = std::get_if<temporary_buffer<char>>(&bufs);
      if (one) {
          return *one;
      } else {
          return std::get<std::vector<temporary_buffer<char>>>(bufs).front();
      }
  }



  template<typename T>
  T make_shard_local_buffer_copy(foreign_ptr<std::unique_ptr<T>> org) {
      if (org.get_owner_shard() == this_shard_id()) {
          return std::move(*org);
      }
      T buf(org->size);
      auto* one = std::get_if<temporary_buffer<char>>(&org->bufs);

      if (one) {
          buf.bufs = temporary_buffer<char>(one->get_write(), one->size(), make_object_deleter(std::move(org)));
      } else {
          auto& orgbufs = std::get<std::vector<temporary_buffer<char>>>(org->bufs);
          std::vector<temporary_buffer<char>> newbufs;
          newbufs.reserve(orgbufs.size());
          deleter d = make_object_deleter(std::move(org));
          for (auto&& b : orgbufs) {
              newbufs.push_back(temporary_buffer<char>(b.get_write(), b.size(), d.share()));
          }
          buf.bufs = std::move(newbufs);
      }

      return buf;
  }

  template snd_buf make_shard_local_buffer_copy(foreign_ptr<std::unique_ptr<snd_buf>>);
  template rcv_buf make_shard_local_buffer_copy(foreign_ptr<std::unique_ptr<rcv_buf>>);

  static void log_exception(connection& c, log_level level, const char* log, std::exception_ptr eptr) {
      const char* s;
      try {
          std::rethrow_exception(eptr);
      } catch (std::exception& ex) {
          s = ex.what();
      } catch (...) {
          s = "unknown exception";
      }
      auto formatted = format("{}: {}", log, s);
      c.get_logger()(c.peer_address(), level, std::string_view(formatted.data(), formatted.size()));
  }

  snd_buf connection::compress(snd_buf buf) {
      if (_compressor) {
          buf = _compressor->compress(4, std::move(buf));
          static_assert(snd_buf::chunk_size >= 4, "send buffer chunk size is too small");
          write_le<uint32_t>(buf.front().get_write(), buf.size - 4);
          return buf;
      }
      return buf;
  }

  future<> connection::send_buffer(snd_buf buf) {
      auto* b = std::get_if<temporary_buffer<char>>(&buf.bufs);
      if (b) {
          return _write_buf.write(std::move(*b));
      } else {
          return do_with(std::move(std::get<std::vector<temporary_buffer<char>>>(buf.bufs)),
                  [this] (std::vector<temporary_buffer<char>>& ar) {
              return do_for_each(ar.begin(), ar.end(), [this] (auto& b) {
                  return _write_buf.write(std::move(b));
              });
          });
      }
  }

  future<> connection::send_entry(outgoing_entry& d) noexcept {
    return futurize_invoke([this, &d] {
      if (d.buf.size && _propagate_timeout) {
          static_assert(snd_buf::chunk_size >= sizeof(uint64_t), "send buffer chunk size is too small");
          if (_timeout_negotiated) {
              auto expire = d.t.get_timeout();
              uint64_t left = 0;
              if (expire != typename timer<rpc_clock_type>::time_point()) {
                  left = std::chrono::duration_cast<std::chrono::milliseconds>(expire - timer<rpc_clock_type>::clock::now()).count();
              }
              write_le<uint64_t>(d.buf.front().get_write(), left);
          } else {
              d.buf.front().trim_front(sizeof(uint64_t));
              d.buf.size -= sizeof(uint64_t);
          }
      }
      auto buf = compress(std::move(d.buf));
      return send_buffer(std::move(buf)).then([this] {
          _stats.sent_messages++;
          return _write_buf.flush();
      });
    });
  }

  void connection::set_negotiated() noexcept {
      _negotiated->set_value();
      _negotiated = std::nullopt;
  }

  future<> connection::stop_send_loop(std::exception_ptr ex) {
      _error = true;
      if (_connected) {
          _fd.shutdown_output();
      }
      if (ex == nullptr) {
          ex = std::make_exception_ptr(closed_error());
      }
      while (!_outgoing_queue.empty()) {
          auto it = std::prev(_outgoing_queue.end());





          if (it != _outgoing_queue.begin()) {
              withdraw(it, ex);
          } else {
              if (_negotiated) {
                  it->done.set_exception(ex);
              }
              break;
          }
      }
      if (_negotiated) {
          _negotiated->set_exception(ex);
      }
      return when_all(std::move(_outgoing_queue_ready), std::move(_sink_closed_future)).then([this] (std::tuple<future<>, future<bool>> res){


          std::get<0>(res).ignore_ready_future();

          bool sink_closed = std::get<1>(res).get();
          return _connected && !sink_closed ? _write_buf.close() : make_ready_future();
      });
  }

  void connection::set_socket(connected_socket&& fd) {
      if (_connected) {
          throw std::runtime_error("already connected");
      }
      _fd = std::move(fd);
      _read_buf =_fd.input();
      _write_buf = _fd.output();
      _connected = true;
  }

  future<> connection::send_negotiation_frame(feature_map features) {
      auto negotiation_frame_feature_record_size = [] (const feature_map::value_type& e) {
          return 8 + e.second.size();
      };
      auto extra_len = boost::accumulate(
              features | boost::adaptors::transformed(negotiation_frame_feature_record_size),
              uint32_t(0));
      temporary_buffer<char> reply(sizeof(negotiation_frame) + extra_len);
      auto p = reply.get_write();
      p = std::copy_n(rpc_magic, 8, p);
      write_le<uint32_t>(p, extra_len);
      p += 4;
      for (auto&& e : features) {
          write_le<uint32_t>(p, static_cast<uint32_t>(e.first));
          p += 4;
          write_le<uint32_t>(p, e.second.size());
          p += 4;
          p = std::copy_n(e.second.begin(), e.second.size(), p);
      }
      return _write_buf.write(std::move(reply)).then([this] {
          _stats.sent_messages++;
          return _write_buf.flush();
      });
  }

  void connection::withdraw(outgoing_entry::container_t::iterator it, std::exception_ptr ex) {
      (static_cast <bool> (it != _outgoing_queue.end()) ? void (0) : __assert_fail ("it != _outgoing_queue.end()", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));

      auto pit = std::prev(it);
# 252 "/home/avi/scylla-maint/seastar/src/rpc/rpc.cc"
      std::swap(it->done, pit->done);
      it->uncancellable();
      it->unlink();
      if (ex == nullptr) {
          it->done.set_value();
      } else {
          it->done.set_exception(ex);
      }
  }

  future<> connection::send(snd_buf buf, std::optional<rpc_clock_type::time_point> timeout, cancellable* cancel) {
      if (!_error) {
          if (timeout && *timeout <= rpc_clock_type::now()) {
              return make_ready_future<>();
          }

          auto p = std::make_unique<outgoing_entry>(std::move(buf));
          auto& d = *p;
          _outgoing_queue.push_back(d);
          _outgoing_queue_size++;
          auto deleter = [this, it = _outgoing_queue.iterator_to(d)] {


              if (it != _outgoing_queue.begin()) {
                  withdraw(it);
              }
          };

          if (timeout) {
              auto& t = d.t;
              t.set_callback(deleter);
              t.arm(timeout.value());
          }
          if (cancel) {
              cancel->cancel_send = std::move(deleter);
              cancel->send_back_pointer = &d.pcancel;
              d.pcancel = cancel;
          }





          return std::exchange(_outgoing_queue_ready, d.done.get_future()).then([this, p = std::move(p)] () mutable {
              _outgoing_queue_size--;
              if (__builtin_expect(!p->is_linked(), false)) {

                  return make_ready_future<>();
              }

              p->uncancellable();
              return send_entry(*p).then_wrapped([this, p = std::move(p)] (auto f) mutable {
                  if (f.failed()) {
                      f.ignore_ready_future();
                      abort();
                  }
                  p->done.set_value();
              });
          });
      } else {
          return make_exception_future<>(closed_error());
      }
  }

  void connection::abort() {
      if (!_error) {
          _error = true;
          _fd.shutdown_input();
      }
  }

  future<> connection::stop() noexcept {
      try {
          abort();
      } catch (...) {
          log_exception(*this, log_level::error, "fail to shutdown connection while stopping", std::current_exception());
      }
      return _stopped.get_future();
  }

  template<typename Connection>
  static bool verify_frame(Connection& c, temporary_buffer<char>& buf, size_t expected, const char* log) {
      if (buf.size() != expected) {
          if (buf.size() != 0) {
              c.get_logger()(c.peer_address(), log);
          }
          return false;
      }
      return true;
  }

  template<typename Connection>
  static
  future<feature_map>
  receive_negotiation_frame(Connection& c, input_stream<char>& in) {
      return in.read_exactly(sizeof(negotiation_frame)).then([&c, &in] (temporary_buffer<char> neg) {
          if (!verify_frame(c, neg, sizeof(negotiation_frame), "unexpected eof during negotiation frame")) {
              return make_exception_future<feature_map>(closed_error());
          }
          negotiation_frame frame;
          std::copy_n(neg.get_write(), sizeof(frame.magic), frame.magic);
          frame.len = read_le<uint32_t>(neg.get_write() + 8);
          if (std::memcmp(frame.magic, rpc_magic, sizeof(frame.magic)) != 0) {
              c.get_logger()(c.peer_address(), format("wrong protocol magic: {:02x}{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}",
                    frame.magic[0], frame.magic[1], frame.magic[2], frame.magic[3], frame.magic[4], frame.magic[5], frame.magic[6], frame.magic[7]));
              return make_exception_future<feature_map>(closed_error());
          }
          auto len = frame.len;
          return in.read_exactly(len).then([&c, len] (temporary_buffer<char> extra) {
              if (extra.size() != len) {
                  c.get_logger()(c.peer_address(), "unexpected eof during negotiation frame");
                  return make_exception_future<feature_map>(closed_error());
              }
              feature_map map;
              auto p = extra.get();
              auto end = p + extra.size();
              while (p != end) {
                  if (end - p < 8) {
                      c.get_logger()(c.peer_address(), "bad feature data format in negotiation frame");
                      return make_exception_future<feature_map>(closed_error());
                  }
                  auto feature = static_cast<protocol_features>(read_le<uint32_t>(p));
                  auto f_len = read_le<uint32_t>(p + 4);
                  p += 8;
                  if (f_len > end - p) {
                      c.get_logger()(c.peer_address(), "buffer underflow in feature data in negotiation frame");
                      return make_exception_future<feature_map>(closed_error());
                  }
                  auto data = sstring(p, f_len);
                  p += f_len;
                  map.emplace(feature, std::move(data));
              }
              return make_ready_future<feature_map>(std::move(map));
          });
      });
  }

  inline future<rcv_buf>
  read_rcv_buf(input_stream<char>& in, uint32_t size) {
      return in.read_up_to(size).then([&, size] (temporary_buffer<char> data) mutable {
          rcv_buf rb(size);
          if (data.size() == 0) {
              return make_ready_future<rcv_buf>(rcv_buf());
          } else if (data.size() == size) {
              rb.bufs = std::move(data);
              return make_ready_future<rcv_buf>(std::move(rb));
          } else {
              size -= data.size();
              std::vector<temporary_buffer<char>> v;
              v.push_back(std::move(data));
              rb.bufs = std::move(v);
              return do_with(std::move(rb), std::move(size), [&in] (rcv_buf& rb, uint32_t& left) {
                  return repeat([&] () {
                      return in.read_up_to(left).then([&] (temporary_buffer<char> data) {
                          if (!data.size()) {
                              rb.size -= left;
                              return stop_iteration::yes;
                          } else {
                              left -= data.size();
                              std::get<std::vector<temporary_buffer<char>>>(rb.bufs).push_back(std::move(data));
                              return left ? stop_iteration::no : stop_iteration::yes;
                          }
                      });
                  }).then([&rb] {
                      return std::move(rb);
                  });
              });
          }
      });
  }

  template<typename FrameType>
  future<typename FrameType::return_type>
  connection::read_frame(socket_address info, input_stream<char>& in) {
      auto header_size = FrameType::header_size();
      return in.read_exactly(header_size).then([this, header_size, info, &in] (temporary_buffer<char> header) {
          if (header.size() != header_size) {
              if (header.size() != 0) {
                  _logger(info, format("unexpected eof on a {} while reading header: expected {:d} got {:d}", FrameType::role(), header_size, header.size()));
              }
              return make_ready_future<typename FrameType::return_type>(FrameType::empty_value());
          }
          auto [size, h] = FrameType::decode_header(header.get());
          if (!size) {
              return make_ready_future<typename FrameType::return_type>(FrameType::make_value(h, rcv_buf()));
          } else {
              return read_rcv_buf(in, size).then([this, info, h = std::move(h), size] (rcv_buf rb) {
                  if (rb.size != size) {
                      _logger(info, format("unexpected eof on a {} while reading data: expected {:d} got {:d}", FrameType::role(), size, rb.size));
                      return make_ready_future<typename FrameType::return_type>(FrameType::empty_value());
                  } else {
                      return make_ready_future<typename FrameType::return_type>(FrameType::make_value(h, std::move(rb)));
                  }
              });
          }
      });
  }

  template<typename FrameType>
  future<typename FrameType::return_type>
  connection::read_frame_compressed(socket_address info, std::unique_ptr<compressor>& compressor, input_stream<char>& in) {
      if (compressor) {
          return in.read_exactly(4).then([this, info, &in, &compressor] (temporary_buffer<char> compress_header) {
              if (compress_header.size() != 4) {
                  if (compress_header.size() != 0) {
                      _logger(info, format("unexpected eof on a {} while reading compression header: expected 4 got {:d}", FrameType::role(), compress_header.size()));
                  }
                  return make_ready_future<typename FrameType::return_type>(FrameType::empty_value());
              }
              auto ptr = compress_header.get();
              auto size = read_le<uint32_t>(ptr);
              return read_rcv_buf(in, size).then([this, size, &compressor, info, &in] (rcv_buf compressed_data) {
                  if (compressed_data.size != size) {
                      _logger(info, format("unexpected eof on a {} while reading compressed data: expected {:d} got {:d}", FrameType::role(), size, compressed_data.size));
                      return make_ready_future<typename FrameType::return_type>(FrameType::empty_value());
                  }
                  auto eb = compressor->decompress(std::move(compressed_data));
                  if (eb.size == 0) {



                      return yield().then([this, info, &in, &compressor] { return read_frame_compressed<FrameType>(info, compressor, in); });
                  }
                  net::packet p;
                  auto* one = std::get_if<temporary_buffer<char>>(&eb.bufs);
                  if (one) {
                      p = net::packet(std::move(p), std::move(*one));
                  } else {
                      auto&& bufs = std::get<std::vector<temporary_buffer<char>>>(eb.bufs);
                      p.reserve(bufs.size());
                      for (auto&& b : bufs) {
                          p = net::packet(std::move(p), std::move(b));
                      }
                  }
                  return do_with(as_input_stream(std::move(p)), [this, info] (input_stream<char>& in) {
                      return read_frame<FrameType>(info, in);
                  });
              });
          });
      } else {
          return read_frame<FrameType>(info, in);
      }
  }

  struct stream_frame {
      using opt_buf_type = std::optional<rcv_buf>;
      using return_type = opt_buf_type;
      struct header_type {
          bool eos;
      };
      static size_t header_size() {
          return 4;
      }
      static const char* role() {
          return "stream";
      }
      static auto empty_value() {
          return std::nullopt;
      }
      static std::pair<uint32_t, header_type> decode_header(const char* ptr) {
          auto size = read_le<uint32_t>(ptr);
          return size != -1U ? std::make_pair(size, header_type{false}) : std::make_pair(0U, header_type{true});
      }
      static auto make_value(const header_type& t, rcv_buf data) {
          if (t.eos) {
              data.size = -1U;
          }
          return data;
      }
  };

  future<std::optional<rcv_buf>>
  connection::read_stream_frame_compressed(input_stream<char>& in) {
      return read_frame_compressed<stream_frame>(peer_address(), _compressor, in);
  }

  future<> connection::stream_close() {
      auto f = make_ready_future<>();
      if (!error()) {
          promise<bool> p;
          _sink_closed_future = p.get_future();


          f = _write_buf.close().finally([p = std::move(p)] () mutable { p.set_value(true);});
      }
      return f.finally([this] () mutable { return stop(); });
  }

  future<> connection::stream_process_incoming(rcv_buf&& buf) {


      auto size = std::min(size_t(buf.size), max_stream_buffers_memory);
      return get_units(_stream_sem, size).then([this, buf = std::move(buf)] (semaphore_units<>&& su) mutable {
          buf.su = std::move(su);
          return _stream_queue.push_eventually(std::move(buf));
      });
  }

  future<> connection::handle_stream_frame() {
      return read_stream_frame_compressed(_read_buf).then([this] (std::optional<rcv_buf> data) {
          if (!data) {
              _error = true;
              return make_ready_future<>();
          }
          return stream_process_incoming(std::move(*data));
      });
  }

  future<> connection::stream_receive(circular_buffer<foreign_ptr<std::unique_ptr<rcv_buf>>>& bufs) {
      return _stream_queue.not_empty().then([this, &bufs] {
          bool eof = !_stream_queue.consume([&bufs] (rcv_buf&& b) {
              if (b.size == -1U) {
                  return false;
              } else {
                  bufs.push_back(make_foreign(std::make_unique<rcv_buf>(std::move(b))));
                  return true;
              }
          });
          if (eof && !bufs.empty()) {
              (static_cast <bool> (_stream_queue.empty()) ? void (0) : __assert_fail ("_stream_queue.empty()", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
              _stream_queue.push(rcv_buf(-1U));
          }
      });
  }

  void connection::register_stream(connection_id id, xshard_connection_ptr c) {
      _streams.emplace(id, std::move(c));
  }

  xshard_connection_ptr connection::get_stream(connection_id id) const {
      auto it = _streams.find(id);
      if (it == _streams.end()) {
          throw std::logic_error(format("rpc stream id {} not found", id).c_str());
      }
      return it->second;
  }







  struct request_frame {
      using opt_buf_type = std::optional<rcv_buf>;
      using return_type = std::tuple<std::optional<uint64_t>, uint64_t, int64_t, opt_buf_type>;
      using header_type = std::tuple<std::optional<uint64_t>, uint64_t, int64_t>;
      static constexpr size_t raw_header_size = sizeof(uint64_t) + sizeof(int64_t) + sizeof(uint32_t);
      static size_t header_size() {
          static_assert(request_frame_headroom >= raw_header_size);
          return raw_header_size;
      }
      static const char* role() {
          return "server";
      }
      static auto empty_value() {
          return std::make_tuple(std::nullopt, uint64_t(0), 0, std::nullopt);
      }
      static std::pair<size_t, header_type> decode_header(const char* ptr) {
          auto type = read_le<uint64_t>(ptr);
          auto msgid = read_le<int64_t>(ptr + 8);
          auto size = read_le<uint32_t>(ptr + 16);
          return std::make_pair(size, std::make_tuple(std::nullopt, type, msgid));
      }
      static void encode_header(uint64_t type, int64_t msg_id, snd_buf& buf, size_t off) {
          auto p = buf.front().get_write() + off;
          write_le<uint64_t>(p, type);
          write_le<int64_t>(p + 8, msg_id);
          write_le<uint32_t>(p + 16, buf.size - raw_header_size - off);
      }
      static auto make_value(const header_type& t, rcv_buf data) {
          return std::make_tuple(std::get<0>(t), std::get<1>(t), std::get<2>(t), std::move(data));
      }
  };


  struct request_frame_with_timeout : request_frame {
      using super = request_frame;
      static constexpr size_t raw_header_size = sizeof(uint64_t) + request_frame::raw_header_size;
      static size_t header_size() {
          static_assert(request_frame_headroom >= raw_header_size);
          return raw_header_size;
      }
      static std::pair<uint32_t, typename super::header_type> decode_header(const char* ptr) {
          auto h = super::decode_header(ptr + 8);
          std::get<0>(h.second) = read_le<uint64_t>(ptr);
          return h;
      }
      static void encode_header(uint64_t type, int64_t msg_id, snd_buf& buf) {
          static_assert(snd_buf::chunk_size >= raw_header_size, "send buffer chunk size is too small");

          request_frame::encode_header(type, msg_id, buf, 8);
      }
  };

  future<> client::request(uint64_t type, int64_t msg_id, snd_buf buf, std::optional<rpc_clock_type::time_point> timeout, cancellable* cancel) {
      request_frame_with_timeout::encode_header(type, msg_id, buf);
      return send(std::move(buf), timeout, cancel);
  }

  void
  client::negotiate(feature_map provided) {

      for (auto&& e : provided) {
          auto id = e.first;
          switch (id) {

          case protocol_features::COMPRESS:
              if (_options.compressor_factory) {
                  _compressor = _options.compressor_factory->negotiate(e.second, false, [this] { return send({}); });
              }
              if (!_compressor) {
                  throw std::runtime_error(format("RPC server responded with compression {} - unsupported", e.second));
              }
              break;
          case protocol_features::TIMEOUT:
              _timeout_negotiated = true;
              break;
          case protocol_features::CONNECTION_ID: {
              _id = deserialize_connection_id(e.second);
              break;
          }
          default:

              ;
          }
      }
  }

  future<> client::negotiate_protocol(feature_map features) {
      return send_negotiation_frame(std::move(features)).then([this] {
          return receive_negotiation_frame(*this, _read_buf).then([this] (feature_map features) {
              return negotiate(std::move(features));
          });
      });
  }





  struct response_frame {
      using opt_buf_type = std::optional<rcv_buf>;
      using return_type = std::tuple<int64_t, opt_buf_type>;
      using header_type = std::tuple<int64_t>;
      static constexpr size_t raw_header_size = sizeof(int64_t) + sizeof(uint32_t);
      static size_t header_size() {
          static_assert(response_frame_headroom >= raw_header_size);
          return raw_header_size;
      }
      static const char* role() {
          return "client";
      }
      static auto empty_value() {
          return std::make_tuple(0, std::nullopt);
      }
      static std::pair<uint32_t, header_type> decode_header(const char* ptr) {
          auto msgid = read_le<int64_t>(ptr);
          auto size = read_le<uint32_t>(ptr + 8);
          return std::make_pair(size, std::make_tuple(msgid));
      }
      static void encode_header(int64_t msg_id, snd_buf& data) {
          static_assert(snd_buf::chunk_size >= raw_header_size, "send buffer chunk size is too small");
          auto p = data.front().get_write();
          write_le<int64_t>(p, msg_id);
          write_le<uint32_t>(p + 8, data.size - raw_header_size);
      }
      static auto make_value(const header_type& t, rcv_buf data) {
          return std::make_tuple(std::get<0>(t), std::move(data));
      }
  };


  future<response_frame::return_type>
  client::read_response_frame_compressed(input_stream<char>& in) {
      return read_frame_compressed<response_frame>(_server_addr, _compressor, in);
  }

  stats client::get_stats() const {
      stats res = _stats;
      res.wait_reply = incoming_queue_length();
      res.pending = outgoing_queue_length();
      return res;
  }

  void client::wait_for_reply(id_type id, std::unique_ptr<reply_handler_base>&& h, std::optional<rpc_clock_type::time_point> timeout, cancellable* cancel) {
      if (timeout) {
          h->t.set_callback(std::bind(std::mem_fn(&client::wait_timed_out), this, id));
          h->t.arm(timeout.value());
      }
      if (cancel) {
          cancel->cancel_wait = [this, id] {
              _outstanding[id]->cancel();
              _outstanding.erase(id);
          };
          h->pcancel = cancel;
          cancel->wait_back_pointer = &h->pcancel;
      }
      _outstanding.emplace(id, std::move(h));
  }
  void client::wait_timed_out(id_type id) {
      _stats.timeout++;
      _outstanding[id]->timeout();
      _outstanding.erase(id);
  }

  future<> client::stop() noexcept {
      _error = true;
      try {
          _socket.shutdown();
      } catch(...) {
          log_exception(*this, log_level::error, "fail to shutdown connection while stopping", std::current_exception());
      }
      return _stopped.get_future();
  }

  void client::abort_all_streams() {
      while (!_streams.empty()) {
          auto&& s = _streams.begin();
          (static_cast <bool> (s->second->get_owner_shard() == this_shard_id()) ? void (0) : __assert_fail ("s->second->get_owner_shard() == this_shard_id()", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
          s->second->get()->abort();
          _streams.erase(s);
      }
  }

  void client::deregister_this_stream() {
      if (_parent) {
          _parent->_streams.erase(_id);
      }
  }




  void client::enqueue_zero_frame() {
      if (_error) {
          return;
      }

      auto p = std::make_unique<outgoing_entry>(snd_buf(0));
      auto& d = *p;
      _outgoing_queue.push_back(d);



      (void)std::exchange(_outgoing_queue_ready, d.done.get_future()).then_wrapped([p = std::move(p)] (auto f) mutable {
          if (f.failed()) {
              f.ignore_ready_future();
          } else {
              p->done.set_value();
          }
      });
  }

  struct client::metrics::domain {
      metrics::domain_list_t list;
      stats dead;
      seastar::metrics::metric_groups metric_groups;

      static thread_local std::unordered_map<sstring, domain> all;
      static domain& find_or_create(sstring name);

      stats::counter_type count_all(stats::counter_type stats::* field) noexcept {
          stats::counter_type res = dead.*field;
          for (const auto& m : list) {
              res += m._c._stats.*field;
          }
          return res;
      }

      size_t count_all_fn(size_t (client::*fn)(void) const) noexcept {
          size_t res = 0;
          for (const auto& m : list) {
              res += (m._c.*fn)();
          }
          return res;
      }

      domain(sstring name)
      {
          namespace sm = seastar::metrics;
          auto domain_l = sm::label("domain")(name);

          metric_groups.add_group("rpc_client", {
                sm::make_gauge("count", [this] { return list.size(); },
                        sm::description("Total number of clients"), { domain_l }),
                sm::make_counter("sent_messages", std::bind(&domain::count_all, this, &stats::sent_messages),
                        sm::description("Total number of messages sent"), { domain_l }),
                sm::make_counter("replied", std::bind(&domain::count_all, this, &stats::replied),
                        sm::description("Total number of responses received"), { domain_l }),
                sm::make_counter("exception_received", std::bind(&domain::count_all, this, &stats::exception_received),
                        sm::description("Total number of exceptional responses received"), { domain_l }).set_skip_when_empty(),
                sm::make_counter("timeout", std::bind(&domain::count_all, this, &stats::timeout),
                        sm::description("Total number of timeout responses"), { domain_l }).set_skip_when_empty(),
                sm::make_gauge("pending", std::bind(&domain::count_all_fn, this, &client::outgoing_queue_length),
                    sm::description("Number of queued outbound messages"), { domain_l }),
                sm::make_gauge("wait_reply", std::bind(&domain::count_all_fn, this, &client::incoming_queue_length),
                    sm::description("Number of replies waiting for"), { domain_l }),
          });
      }
  };

  thread_local std::unordered_map<sstring, client::metrics::domain> client::metrics::domain::all;

  client::metrics::domain& client::metrics::domain::find_or_create(sstring name) {
      auto i = all.try_emplace(name, name);
      return i.first->second;
  }

  client::metrics::metrics(const client& c)
        : _c(c)
        , _domain(domain::find_or_create(_c._options.metrics_domain))
  {
      _domain.list.push_back(*this);
  }

  client::metrics::~metrics() {
      _domain.dead.replied += _c._stats.replied;
      _domain.dead.exception_received += _c._stats.exception_received;
      _domain.dead.sent_messages += _c._stats.sent_messages;
      _domain.dead.timeout += _c._stats.timeout;
  }

  client::client(const logger& l, void* s, client_options ops, socket socket, const socket_address& addr, const socket_address& local)
  : rpc::connection(l, s), _socket(std::move(socket)), _server_addr(addr), _local_addr(local), _options(ops), _metrics(*this)
  {
       _socket.set_reuseaddr(ops.reuseaddr);



      (void)_socket.connect(addr, local).then([this, ops = std::move(ops)] (connected_socket fd) {
          fd.set_nodelay(ops.tcp_nodelay);
          if (ops.keepalive) {
              fd.set_keepalive(true);
              fd.set_keepalive_parameters(ops.keepalive.value());
          }
          set_socket(std::move(fd));

          feature_map features;
          if (_options.compressor_factory) {
              features[protocol_features::COMPRESS] = _options.compressor_factory->supported();
          }
          if (_options.send_timeout_data) {
              features[protocol_features::TIMEOUT] = "";
          }
          if (_options.stream_parent) {
              features[protocol_features::STREAM_PARENT] = serialize_connection_id(_options.stream_parent);
          }
          if (!_options.isolation_cookie.empty()) {
              features[protocol_features::ISOLATION] = _options.isolation_cookie;
          }

          return negotiate_protocol(std::move(features)).then([this] {
              _propagate_timeout = !is_stream();
              set_negotiated();
              return do_until([this] { return _read_buf.eof() || _error; }, [this] () mutable {
                  if (is_stream()) {
                      return handle_stream_frame();
                  }
                  return read_response_frame_compressed(_read_buf).then([this] (response_frame::return_type msg_id_and_data) {
                      auto& msg_id = std::get<0>(msg_id_and_data);
                      auto& data = std::get<1>(msg_id_and_data);
                      auto it = _outstanding.find(std::abs(msg_id));
                      if (!data) {
                          _error = true;
                      } else if (it != _outstanding.end()) {
                          auto handler = std::move(it->second);
                          _outstanding.erase(it);
                          (*handler)(*this, msg_id, std::move(data.value()));
                      } else if (msg_id < 0) {
                          try {
                              std::rethrow_exception(unmarshal_exception(data.value()));
                          } catch(const unknown_verb_error& ex) {


                              get_logger()(peer_address(), format("unknown verb exception {:d} ignored", ex.type));
                          } catch(...) {

                              log_exception(*this, log_level::info, "ignoring error response", std::current_exception());
                          }
                      } else {


                          get_logger()(peer_address(), log_level::debug, "got a reply for an expired message id");
                      }
                  });
              });
          });
      }).then_wrapped([this] (future<> f) {
          std::exception_ptr ep;
          if (f.failed()) {
              ep = f.get_exception();
              if (_connected) {
                  if (is_stream()) {
                      log_exception(*this, log_level::error, "client stream connection dropped", ep);
                  } else {
                      log_exception(*this, log_level::error, "client connection dropped", ep);
                  }
              } else {
                  if (is_stream()) {
                      log_exception(*this, log_level::debug, "stream fail to connect", ep);
                  } else {
                      log_exception(*this, log_level::debug, "fail to connect", ep);
                  }
              }
          }
          _error = true;
          _stream_queue.abort(std::make_exception_ptr(stream_closed()));
          return stop_send_loop(ep).then_wrapped([this] (future<> f) {
              f.ignore_ready_future();
              _outstanding.clear();
              if (is_stream()) {
                  deregister_this_stream();
              } else {
                  abort_all_streams();
              }
          }).finally([this] {
              return _compressor ? _compressor->close() : make_ready_future();
          }).finally([this]{
              _stopped.set_value();
          });
      });
      enqueue_zero_frame();
  }

  client::client(const logger& l, void* s, const socket_address& addr, const socket_address& local)
  : client(l, s, client_options{}, make_socket(), addr, local)
  {}

  client::client(const logger& l, void* s, client_options options, const socket_address& addr, const socket_address& local)
  : client(l, s, options, make_socket(), addr, local)
  {}

  client::client(const logger& l, void* s, socket socket, const socket_address& addr, const socket_address& local)
  : client(l, s, client_options{}, std::move(socket), addr, local)
  {}


  future<feature_map>
  server::connection::negotiate(feature_map requested) {
      feature_map ret;
      future<> f = make_ready_future<>();
      for (auto&& e : requested) {
          auto id = e.first;
          switch (id) {

          case protocol_features::COMPRESS: {
              if (get_server()._options.compressor_factory) {
                  _compressor = get_server()._options.compressor_factory->negotiate(e.second, true, [this] { return send({}); });
                  if (_compressor) {
                       ret[protocol_features::COMPRESS] = _compressor->name();
                  }
              }
          }
          break;
          case protocol_features::TIMEOUT:
              _timeout_negotiated = true;
              ret[protocol_features::TIMEOUT] = "";
              break;
          case protocol_features::STREAM_PARENT: {
              if (!get_server()._options.streaming_domain) {
                  f = f.then([] {
                      return make_exception_future<>(std::runtime_error("streaming is not configured for the server"));
                  });
              } else {
                  _parent_id = deserialize_connection_id(e.second);
                  _is_stream = true;

                  get_server()._conns.erase(get_connection_id());
                  f = f.then([this, c = shared_from_this()] () mutable {
                      return smp::submit_to(_parent_id.shard(), [this, c = make_foreign(static_pointer_cast<rpc::connection>(c))] () mutable {
                          auto sit = _servers.find(*get_server()._options.streaming_domain);
                          if (sit == _servers.end()) {
                              throw std::logic_error(format("Shard {:d} does not have server with streaming domain {}", this_shard_id(), *get_server()._options.streaming_domain).c_str());
                          }
                          auto s = sit->second;
                          auto it = s->_conns.find(_parent_id);
                          if (it == s->_conns.end()) {
                              throw std::logic_error(format("Unknown parent connection {} on shard {:d}", _parent_id, this_shard_id()).c_str());
                          }
                          if (it->second->_error) {
                              throw std::runtime_error(format("Parent connection {} is aborting on shard {:d}", _parent_id, this_shard_id()).c_str());
                          }
                          auto id = c->get_connection_id();
                          it->second->register_stream(id, make_lw_shared(std::move(c)));
                      });
                  });
              }
              break;
          }
          case protocol_features::ISOLATION: {
              auto&& isolation_cookie = e.second;
              struct isolation_function_visitor {
                  isolation_function_visitor(const sstring& isolation_cookie) :
                        _isolation_cookie(isolation_cookie) { }
                  future<isolation_config> operator() (resource_limits::syncronous_isolation_function f) const {
                      return futurize_invoke(f, _isolation_cookie);
                  }
                  future<isolation_config> operator() (resource_limits::asyncronous_isolation_function f) const {
                      return f(_isolation_cookie);
                  }
              private:
                  sstring _isolation_cookie;
              };

              auto visitor = isolation_function_visitor(isolation_cookie);
              f = f.then([visitor = std::move(visitor), this] () mutable {
                  return std::visit(visitor, get_server()._limits.isolate_connection).then([this] (isolation_config conf) {
                      _isolation_config = conf;
                  });
              });
              ret.emplace(e);
              break;
          }
          default:

              ;
          }
      }
      if (get_server()._options.streaming_domain) {
          ret[protocol_features::CONNECTION_ID] = serialize_connection_id(_id);
      }
      return f.then([ret = std::move(ret)] {
          return ret;
      });
  }

  future<>
  server::connection::negotiate_protocol() {
      return receive_negotiation_frame(*this, _read_buf).then([this] (feature_map requested_features) {
          return negotiate(std::move(requested_features)).then([this] (feature_map returned_features) {
              return send_negotiation_frame(std::move(returned_features));
          });
      });
  }

  future<request_frame::return_type>
  server::connection::read_request_frame_compressed(input_stream<char>& in) {
      if (_timeout_negotiated) {
          return read_frame_compressed<request_frame_with_timeout>(_info.addr, _compressor, in);
      } else {
          return read_frame_compressed<request_frame>(_info.addr, _compressor, in);
      }
  }

  future<>
  server::connection::respond(int64_t msg_id, snd_buf&& data, std::optional<rpc_clock_type::time_point> timeout) {
      response_frame::encode_header(msg_id, data);
      return send(std::move(data), timeout);
  }

future<> server::connection::send_unknown_verb_reply(std::optional<rpc_clock_type::time_point> timeout, int64_t msg_id, uint64_t type) {
    return wait_for_resources(28, timeout).then([this, timeout, msg_id, type] (auto permit) {

        snd_buf data(28);
        static_assert(snd_buf::chunk_size >= 28, "send buffer chunk size is too small");
        auto p = data.front().get_write() + 12;
        write_le<uint32_t>(p, uint32_t(exception_type::UNKNOWN_VERB));
        write_le<uint32_t>(p + 4, uint32_t(8));
        write_le<uint64_t>(p + 8, type);
        try {


            (void)with_gate(get_server()._reply_gate, [this, timeout, msg_id, data = std::move(data), permit = std::move(permit)] () mutable {

                auto c = shared_from_this();
                return respond(-msg_id, std::move(data), timeout).then([c = std::move(c), permit = std::move(permit)] {});
            });
        } catch(gate_closed_exception&) { }
    });
}

  future<> server::connection::process() {
      return negotiate_protocol().then([this] () mutable {
        auto sg = _isolation_config ? _isolation_config->sched_group : current_scheduling_group();
        return with_scheduling_group(sg, [this] {
          set_negotiated();
          return do_until([this] { return _read_buf.eof() || _error; }, [this] () mutable {
              if (is_stream()) {
                  return handle_stream_frame();
              }
              return read_request_frame_compressed(_read_buf).then([this] (request_frame::return_type header_and_buffer) {
                  auto& expire = std::get<0>(header_and_buffer);
                  auto& type = std::get<1>(header_and_buffer);
                  auto& msg_id = std::get<2>(header_and_buffer);
                  auto& data = std::get<3>(header_and_buffer);
                  if (!data) {
                      _error = true;
                      return make_ready_future<>();
                  } else {
                      std::optional<rpc_clock_type::time_point> timeout;
                      if (expire && *expire) {
                          timeout = relative_timeout_to_absolute(std::chrono::milliseconds(*expire));
                      }
                      auto h = get_server()._proto.get_handler(type);
                      if (!h) {
                          return send_unknown_verb_reply(timeout, msg_id, type);
                      }



                      auto sg = _isolation_config ? _isolation_config->sched_group : h->handler.sg;
                      return with_scheduling_group(sg, [this, timeout, msg_id, &h = h->handler, data = std::move(data.value()), guard = std::move(h->holder)] () mutable {
                          return h.func(shared_from_this(), timeout, msg_id, std::move(data), std::move(guard));
                      });
                  }
              });
          });
        });
      }).then_wrapped([this] (future<> f) {
          std::exception_ptr ep;
          if (f.failed()) {
              ep = f.get_exception();
              log_exception(*this, log_level::error,
                      format("server{} connection dropped", is_stream() ? " stream" : "").c_str(), ep);
          }
          _fd.shutdown_input();
          _error = true;
          _stream_queue.abort(std::make_exception_ptr(stream_closed()));
          return stop_send_loop(ep).then_wrapped([this] (future<> f) {
              f.ignore_ready_future();
              get_server()._conns.erase(get_connection_id());
              if (is_stream()) {
                  return deregister_this_stream();
              } else {
                  return abort_all_streams();
              }
          }).finally([this] {
              return _compressor ? _compressor->close() : make_ready_future();
          }).finally([this] {
              _stopped.set_value();
          });
      }).finally([conn_ptr = shared_from_this()] {

      });
  }

  server::connection::connection(server& s, connected_socket&& fd, socket_address&& addr, const logger& l, void* serializer, connection_id id)
          : rpc::connection(std::move(fd), l, serializer, id)
          , _info{.addr{std::move(addr)}, .server{s}, .conn_id{id}} {
  }

  future<> server::connection::deregister_this_stream() {
      if (!get_server()._options.streaming_domain) {
          return make_ready_future<>();
      }
      return smp::submit_to(_parent_id.shard(), [this] () mutable {
          auto sit = server::_servers.find(*get_server()._options.streaming_domain);
          if (sit != server::_servers.end()) {
              auto s = sit->second;
              auto it = s->_conns.find(_parent_id);
              if (it != s->_conns.end()) {
                  it->second->_streams.erase(get_connection_id());
              }
          }
      });
  }

  future<> server::connection::abort_all_streams() {
      return parallel_for_each(_streams | boost::adaptors::map_values, [] (xshard_connection_ptr s) {
          return smp::submit_to(s->get_owner_shard(), [s] {
              s->get()->abort();
          });
      }).then([this] {
          _streams.clear();
      });
  }

  thread_local std::unordered_map<streaming_domain_type, server*> server::_servers;

  server::server(protocol_base* proto, const socket_address& addr, resource_limits limits)
      : server(proto, seastar::listen(addr, listen_options{true}), limits, server_options{})
  {}

  server::server(protocol_base* proto, server_options opts, const socket_address& addr, resource_limits limits)
      : server(proto, seastar::listen(addr, listen_options{true, opts.load_balancing_algorithm}), limits, opts)
  {}

  server::server(protocol_base* proto, server_socket ss, resource_limits limits, server_options opts)
          : _proto(*proto), _ss(std::move(ss)), _limits(limits), _resources_available(limits.max_memory), _options(opts)
  {
      if (_options.streaming_domain) {
          if (_servers.find(*_options.streaming_domain) != _servers.end()) {
              throw std::runtime_error(format("An RPC server with the streaming domain {} is already exist", *_options.streaming_domain));
          }
          _servers[*_options.streaming_domain] = this;
      }
      accept();
  }

  server::server(protocol_base* proto, server_options opts, server_socket ss, resource_limits limits)
          : server(proto, std::move(ss), limits, opts)
  {}

  void server::accept() {



      (void)keep_doing([this] () mutable {
          return _ss.accept().then([this] (accept_result ar) mutable {
              if (_options.filter_connection && !_options.filter_connection(ar.remote_address)) {
                  return;
              }
              auto fd = std::move(ar.connection);
              auto addr = std::move(ar.remote_address);
              fd.set_nodelay(_options.tcp_nodelay);
              connection_id id = _options.streaming_domain ?
                      connection_id::make_id(_next_client_id++, uint16_t(this_shard_id())) :
                      connection_id::make_invalid_id(_next_client_id++);
              auto conn = _proto.make_server_connection(*this, std::move(fd), std::move(addr), id);
              auto r = _conns.emplace(id, conn);
              (static_cast <bool> (r.second) ? void (0) : __assert_fail ("r.second", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));

              (void)conn->process();
          });
      }).then_wrapped([this] (future<>&& f){
          try {
              f.get();
              (static_cast <bool> (false) ? void (0) : __assert_fail ("false", __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
          } catch (...) {
              _ss_stopped.set_value();
          }
      });
  }

  future<> server::shutdown() {
      if (_shutdown) {
          return make_ready_future<>();
      }

      _ss.abort_accept();
      _resources_available.broken();
      if (_options.streaming_domain) {
          _servers.erase(*_options.streaming_domain);
      }
      return _ss_stopped.get_future().then([this] {
          return parallel_for_each(_conns | boost::adaptors::map_values, [] (shared_ptr<connection> conn) {
              return conn->stop();
          });
      }).finally([this] {
          _shutdown = true;
      });
  }

  future<> server::stop() {
      return when_all(
          shutdown(),
          _reply_gate.close()
      ).discard_result();
  }

  void server::abort_connection(connection_id id) {
      auto it = _conns.find(id);
      if (it == _conns.end()) {
          return;
      }
      try {
          it->second->abort();
      } catch (...) {
          log_exception(*it->second, log_level::error,
                        "fail to shutdown connection on user request", std::current_exception());
      }
  }

  std::ostream& operator<<(std::ostream& os, const connection_id& id) {
      fmt::print(os, "{:x}", id.id());
      return os;
  }

  std::ostream& operator<<(std::ostream& os, const streaming_domain_type& domain) {
      fmt::print(os, "{:d}", domain._id);
      return os;
  }

  isolation_config default_isolate_connection(sstring isolation_cookie) {
      return isolation_config{};
  }

}

}